Line data Source code
1 : /* SSA operands management for trees.
2 : Copyright (C) 2003-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify
7 : it under the terms of the GNU General Public License as published by
8 : the Free Software Foundation; either version 3, or (at your option)
9 : any later version.
10 :
11 : GCC is distributed in the hope that it will be useful,
12 : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : GNU General Public License for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #include "config.h"
21 : #include "system.h"
22 : #include "coretypes.h"
23 : #include "backend.h"
24 : #include "tree.h"
25 : #include "gimple.h"
26 : #include "timevar.h"
27 : #include "ssa.h"
28 : #include "gimple-pretty-print.h"
29 : #include "diagnostic-core.h"
30 : #include "stmt.h"
31 : #include "print-tree.h"
32 : #include "dumpfile.h"
33 :
34 :
35 : /* This file contains the code required to manage the operands cache of the
36 : SSA optimizer. For every stmt, we maintain an operand cache in the stmt
37 : annotation. This cache contains operands that will be of interest to
38 : optimizers and other passes wishing to manipulate the IL.
39 :
40 : The operand type are broken up into REAL and VIRTUAL operands. The real
41 : operands are represented as pointers into the stmt's operand tree. Thus
42 : any manipulation of the real operands will be reflected in the actual tree.
43 : Virtual operands are represented solely in the cache, although the base
44 : variable for the SSA_NAME may, or may not occur in the stmt's tree.
45 : Manipulation of the virtual operands will not be reflected in the stmt tree.
46 :
47 : The routines in this file are concerned with creating this operand cache
48 : from a stmt tree.
49 :
50 : The operand tree is the parsed by the various get_* routines which look
51 : through the stmt tree for the occurrence of operands which may be of
52 : interest, and calls are made to the append_* routines whenever one is
53 : found. There are 4 of these routines, each representing one of the
54 : 4 types of operands. Defs, Uses, Virtual Uses, and Virtual May Defs.
55 :
56 : The append_* routines check for duplication, and simply keep a list of
57 : unique objects for each operand type in the build_* extendable vectors.
58 :
59 : Once the stmt tree is completely parsed, the finalize_ssa_operands()
60 : routine is called, which proceeds to perform the finalization routine
61 : on each of the 4 operand vectors which have been built up.
62 :
63 : If the stmt had a previous operand cache, the finalization routines
64 : attempt to match up the new operands with the old ones. If it's a perfect
65 : match, the old vector is simply reused. If it isn't a perfect match, then
66 : a new vector is created and the new operands are placed there. For
67 : virtual operands, if the previous cache had SSA_NAME version of a
68 : variable, and that same variable occurs in the same operands cache, then
69 : the new cache vector will also get the same SSA_NAME.
70 :
71 : i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new
72 : operand vector for VUSE, then the new vector will also be modified
73 : such that it contains 'a_5' rather than 'a'. */
74 :
75 :
76 : /* Flags to describe operand properties in helpers. */
77 :
78 : /* By default, operands are loaded. */
79 : #define opf_use 0
80 :
81 : /* Operand is the target of an assignment expression or a
82 : call-clobbered variable. */
83 : #define opf_def (1 << 0)
84 :
85 : /* No virtual operands should be created in the expression. This is used
86 : when traversing ADDR_EXPR nodes which have different semantics than
87 : other expressions. Inside an ADDR_EXPR node, the only operands that we
88 : need to consider are indices into arrays. For instance, &a.b[i] should
89 : generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
90 : VUSE for 'b'. */
91 : #define opf_no_vops (1 << 1)
92 :
93 : /* Operand is in a place where address-taken does not imply addressable. */
94 : #define opf_non_addressable (1 << 3)
95 :
96 : /* Operand is in a place where opf_non_addressable does not apply. */
97 : #define opf_not_non_addressable (1 << 4)
98 :
99 : /* Operand is having its address taken. */
100 : #define opf_address_taken (1 << 5)
101 :
102 : /* Class containing temporary per-stmt state. */
103 :
104 22644512518 : class operands_scanner
105 : {
106 : public:
107 11322256259 : operands_scanner (struct function *fun, gimple *statement)
108 11322256259 : {
109 11322256259 : build_vuse = NULL_TREE;
110 11322256259 : build_vdef = NULL_TREE;
111 11322256259 : fn = fun;
112 11322256259 : stmt = statement;
113 : }
114 :
115 : /* Create an operands cache for STMT. */
116 : void build_ssa_operands ();
117 :
118 : /* Verifies SSA statement operands. */
119 : DEBUG_FUNCTION bool verify_ssa_operands ();
120 :
121 : private:
122 : /* Disable copy and assign of this class, as it may have problems with
123 : build_uses vec. */
124 : DISABLE_COPY_AND_ASSIGN (operands_scanner);
125 :
126 : /* Array for building all the use operands. */
127 : auto_vec<tree *, 16> build_uses;
128 :
129 : /* The built VDEF operand. */
130 : tree build_vdef;
131 :
132 : /* The built VUSE operand. */
133 : tree build_vuse;
134 :
135 : /* Function which STMT belongs to. */
136 : struct function *fn;
137 :
138 : /* Statement to work on. */
139 : gimple *stmt;
140 :
141 : /* Takes elements from build_uses and turns them into use operands of STMT. */
142 : void finalize_ssa_uses ();
143 :
144 : /* Clear the in_list bits and empty the build array for VDEFs and
145 : VUSEs. */
146 : void cleanup_build_arrays ();
147 :
148 : /* Finalize all the build vectors, fill the new ones into INFO. */
149 : void finalize_ssa_stmt_operands ();
150 :
151 : /* Start the process of building up operands vectors in INFO. */
152 : void start_ssa_stmt_operands ();
153 :
154 : /* Add USE_P to the list of pointers to operands. */
155 : void append_use (tree *use_p);
156 :
157 : /* Add VAR to the set of variables that require a VDEF operator. */
158 : void append_vdef (tree var);
159 :
160 : /* Add VAR to the set of variables that require a VUSE operator. */
161 : void append_vuse (tree var);
162 :
163 : /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */
164 : void add_virtual_operand (int flags);
165 :
166 :
167 : /* Add *VAR_P to the appropriate operand array for statement STMT.
168 : FLAGS is as in get_expr_operands. If *VAR_P is a GIMPLE register,
169 : it will be added to the statement's real operands, otherwise it is
170 : added to virtual operands. */
171 : void add_stmt_operand (tree *var_p, int flags);
172 :
173 : /* A subroutine of get_expr_operands to handle MEM_REF.
174 :
175 : STMT is the statement being processed, EXPR is the MEM_REF
176 : that got us here.
177 :
178 : FLAGS is as in get_expr_operands. */
179 : void get_mem_ref_operands (tree expr, int flags);
180 :
181 : /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
182 : void get_tmr_operands (tree expr, int flags);
183 :
184 :
185 : /* If STMT is a call that may clobber globals and other symbols that
186 : escape, add them to the VDEF/VUSE lists for it. */
187 : void maybe_add_call_vops (gcall *stmt);
188 :
189 : /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
190 : void get_asm_stmt_operands (gasm *stmt);
191 :
192 :
193 : /* Recursively scan the expression pointed to by EXPR_P in statement
194 : STMT. FLAGS is one of the OPF_* constants modifying how to
195 : interpret the operands found. */
196 : void get_expr_operands (tree *expr_p, int flags);
197 :
198 : /* Parse STMT looking for operands. When finished, the various
199 : build_* operand vectors will have potential operands in them. */
200 : void parse_ssa_operands ();
201 :
202 :
203 : /* Takes elements from build_defs and turns them into def operands of STMT.
204 : TODO -- Make build_defs vec of tree *. */
205 : void finalize_ssa_defs ();
206 : };
207 :
208 : /* Accessor to tree-ssa-operands.cc caches. */
209 : static inline struct ssa_operands *
210 785876898 : gimple_ssa_operands (const struct function *fun)
211 : {
212 785876898 : return &fun->gimple_df->ssa_operands;
213 : }
214 :
215 :
216 : /* Return true if the SSA operands cache is active. */
217 :
218 : bool
219 817409202 : ssa_operands_active (struct function *fun)
220 : {
221 817409202 : if (fun == NULL)
222 : return false;
223 :
224 817409202 : return fun->gimple_df && gimple_ssa_operands (fun)->ops_active;
225 : }
226 :
227 :
228 : /* Create the VOP variable, an artificial global variable to act as a
229 : representative of all of the virtual operands FUD chain. */
230 :
231 : static void
232 3184122 : create_vop_var (struct function *fn)
233 : {
234 3184122 : tree global_var;
235 :
236 3184122 : gcc_assert (fn->gimple_df->vop == NULL_TREE);
237 :
238 3184122 : global_var = build_decl (BUILTINS_LOCATION, VAR_DECL,
239 : get_identifier (".MEM"),
240 : void_type_node);
241 3184122 : DECL_ARTIFICIAL (global_var) = 1;
242 3184122 : DECL_IGNORED_P (global_var) = 1;
243 3184122 : TREE_READONLY (global_var) = 0;
244 3184122 : DECL_EXTERNAL (global_var) = 1;
245 3184122 : TREE_STATIC (global_var) = 1;
246 3184122 : TREE_USED (global_var) = 1;
247 3184122 : DECL_CONTEXT (global_var) = NULL_TREE;
248 3184122 : TREE_THIS_VOLATILE (global_var) = 0;
249 3184122 : TREE_ADDRESSABLE (global_var) = 0;
250 3184122 : VAR_DECL_IS_VIRTUAL_OPERAND (global_var) = 1;
251 :
252 3184122 : fn->gimple_df->vop = global_var;
253 3184122 : }
254 :
255 : /* These are the sizes of the operand memory buffer in bytes which gets
256 : allocated each time more operands space is required. The final value is
257 : the amount that is allocated every time after that.
258 : In 1k we can fit 25 use operands (or 63 def operands) on a host with
259 : 8 byte pointers, that would be 10 statements each with 1 def and 2
260 : uses. */
261 :
262 : #define OP_SIZE_INIT 0
263 : #define OP_SIZE_1 (1024 - sizeof (void *))
264 : #define OP_SIZE_2 (1024 * 4 - sizeof (void *))
265 : #define OP_SIZE_3 (1024 * 16 - sizeof (void *))
266 :
267 : /* Initialize the operand cache routines. */
268 :
269 : void
270 3184122 : init_ssa_operands (struct function *fn)
271 : {
272 3184122 : gcc_assert (gimple_ssa_operands (fn)->operand_memory == NULL);
273 3184122 : gimple_ssa_operands (fn)->operand_memory_index
274 3184122 : = gimple_ssa_operands (fn)->ssa_operand_mem_size;
275 3184122 : gimple_ssa_operands (fn)->ops_active = true;
276 3184122 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_INIT;
277 3184122 : create_vop_var (fn);
278 3184122 : }
279 :
280 :
281 : /* Dispose of anything required by the operand routines. */
282 :
283 : void
284 3128378 : fini_ssa_operands (struct function *fn)
285 : {
286 3128378 : struct ssa_operand_memory_d *ptr;
287 :
288 3128378 : gimple_ssa_operands (fn)->free_uses = NULL;
289 :
290 7620104 : while ((ptr = gimple_ssa_operands (fn)->operand_memory) != NULL)
291 : {
292 4491726 : gimple_ssa_operands (fn)->operand_memory
293 4491726 : = gimple_ssa_operands (fn)->operand_memory->next;
294 4491726 : ggc_free (ptr);
295 : }
296 :
297 3128378 : gimple_ssa_operands (fn)->ops_active = false;
298 :
299 3128378 : fn->gimple_df->vop = NULL_TREE;
300 3128378 : }
301 :
302 :
303 : /* Return memory for an operand of size SIZE. */
304 :
305 : static inline void *
306 178471745 : ssa_operand_alloc (struct function *fn, unsigned size)
307 : {
308 178471745 : char *ptr;
309 :
310 178471745 : gcc_assert (size == sizeof (struct use_optype_d));
311 :
312 178471745 : if (gimple_ssa_operands (fn)->operand_memory_index + size
313 178471745 : >= gimple_ssa_operands (fn)->ssa_operand_mem_size)
314 : {
315 4555807 : struct ssa_operand_memory_d *ptr;
316 :
317 4555807 : switch (gimple_ssa_operands (fn)->ssa_operand_mem_size)
318 : {
319 3182209 : case OP_SIZE_INIT:
320 3182209 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_1;
321 3182209 : break;
322 993917 : case OP_SIZE_1:
323 993917 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_2;
324 993917 : break;
325 379681 : case OP_SIZE_2:
326 379681 : case OP_SIZE_3:
327 379681 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_3;
328 379681 : break;
329 0 : default:
330 0 : gcc_unreachable ();
331 : }
332 :
333 :
334 4555807 : ptr = (ssa_operand_memory_d *) ggc_internal_alloc
335 4555807 : (sizeof (void *) + gimple_ssa_operands (fn)->ssa_operand_mem_size);
336 :
337 4555807 : ptr->next = gimple_ssa_operands (fn)->operand_memory;
338 4555807 : gimple_ssa_operands (fn)->operand_memory = ptr;
339 4555807 : gimple_ssa_operands (fn)->operand_memory_index = 0;
340 : }
341 :
342 178471745 : ptr = &(gimple_ssa_operands (fn)->operand_memory
343 178471745 : ->mem[gimple_ssa_operands (fn)->operand_memory_index]);
344 178471745 : gimple_ssa_operands (fn)->operand_memory_index += size;
345 178471745 : return ptr;
346 : }
347 :
348 :
349 : /* Allocate a USE operand. */
350 :
351 : static inline struct use_optype_d *
352 312476768 : alloc_use (struct function *fn)
353 : {
354 312476768 : struct use_optype_d *ret;
355 312476768 : if (gimple_ssa_operands (fn)->free_uses)
356 : {
357 134005023 : ret = gimple_ssa_operands (fn)->free_uses;
358 134005023 : gimple_ssa_operands (fn)->free_uses
359 134005023 : = gimple_ssa_operands (fn)->free_uses->next;
360 : }
361 : else
362 178471745 : ret = (struct use_optype_d *)
363 178471745 : ssa_operand_alloc (fn, sizeof (struct use_optype_d));
364 312476768 : return ret;
365 : }
366 :
367 :
368 : /* Adds OP to the list of uses of statement STMT after LAST. */
369 :
370 : static inline use_optype_p
371 312476768 : add_use_op (struct function *fn, gimple *stmt, tree *op, use_optype_p last)
372 : {
373 312476768 : use_optype_p new_use;
374 :
375 312476768 : new_use = alloc_use (fn);
376 312476768 : USE_OP_PTR (new_use)->use = op;
377 312476768 : link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
378 312476768 : last->next = new_use;
379 312476768 : new_use->next = NULL;
380 312476768 : return new_use;
381 : }
382 :
383 :
384 :
385 : /* Takes elements from build_defs and turns them into def operands of STMT.
386 : TODO -- Make build_defs vec of tree *. */
387 :
388 : inline void
389 380492783 : operands_scanner::finalize_ssa_defs ()
390 : {
391 : /* Pre-pend the vdef we may have built. */
392 380492783 : if (build_vdef != NULL_TREE)
393 : {
394 56139556 : tree oldvdef = gimple_vdef (stmt);
395 56139556 : if (oldvdef
396 20962719 : && TREE_CODE (oldvdef) == SSA_NAME)
397 56139556 : oldvdef = SSA_NAME_VAR (oldvdef);
398 56139556 : if (oldvdef != build_vdef)
399 35176837 : gimple_set_vdef (stmt, build_vdef);
400 : }
401 :
402 : /* Clear and unlink a no longer necessary VDEF. */
403 380492783 : if (build_vdef == NULL_TREE
404 492765558 : && gimple_vdef (stmt) != NULL_TREE)
405 : {
406 4099940 : if (TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
407 : {
408 3943213 : unlink_stmt_vdef (stmt);
409 7886426 : release_ssa_name_fn (fn, gimple_vdef (stmt));
410 : }
411 4099940 : gimple_set_vdef (stmt, NULL_TREE);
412 : }
413 :
414 : /* If we have a non-SSA_NAME VDEF, mark it for renaming. */
415 380492783 : if (gimple_vdef (stmt)
416 168412331 : && TREE_CODE (gimple_vdef (stmt)) != SSA_NAME)
417 : {
418 38462466 : fn->gimple_df->rename_vops = 1;
419 38462466 : fn->gimple_df->ssa_renaming_needed = 1;
420 : }
421 380492783 : }
422 :
423 :
424 : /* Takes elements from build_uses and turns them into use operands of STMT. */
425 :
426 : inline void
427 380492783 : operands_scanner::finalize_ssa_uses ()
428 : {
429 380492783 : unsigned new_i;
430 380492783 : struct use_optype_d new_list;
431 380492783 : use_optype_p old_ops, ptr, last;
432 :
433 : /* Pre-pend the VUSE we may have built. */
434 380492783 : if (build_vuse != NULL_TREE)
435 : {
436 93046692 : tree oldvuse = gimple_vuse (stmt);
437 93046692 : if (oldvuse
438 36509512 : && TREE_CODE (oldvuse) == SSA_NAME)
439 93046692 : oldvuse = SSA_NAME_VAR (oldvuse);
440 93046692 : if (oldvuse != (build_vuse != NULL_TREE
441 : ? build_vuse : build_vdef))
442 56537180 : gimple_set_vuse (stmt, NULL_TREE);
443 186093384 : build_uses.safe_insert (0, gimple_vuse_ptr (stmt));
444 : }
445 :
446 380492783 : new_list.next = NULL;
447 380492783 : last = &new_list;
448 :
449 380492783 : old_ops = gimple_use_ops (stmt);
450 :
451 : /* Clear a no longer necessary VUSE. */
452 380492783 : if (build_vuse == NULL_TREE
453 455858422 : && gimple_vuse (stmt) != NULL_TREE)
454 6570975 : gimple_set_vuse (stmt, NULL_TREE);
455 :
456 : /* If there is anything in the old list, free it. */
457 380492783 : if (old_ops)
458 : {
459 140026730 : for (ptr = old_ops; ptr->next; ptr = ptr->next)
460 42063824 : delink_imm_use (USE_OP_PTR (ptr));
461 97962906 : delink_imm_use (USE_OP_PTR (ptr));
462 97962906 : ptr->next = gimple_ssa_operands (fn)->free_uses;
463 97962906 : gimple_ssa_operands (fn)->free_uses = old_ops;
464 : }
465 :
466 : /* If we added a VUSE, make sure to set the operand if it is not already
467 : present and mark it for renaming. */
468 380492783 : if (build_vuse != NULL_TREE
469 473539475 : && gimple_vuse (stmt) == NULL_TREE)
470 : {
471 56537180 : gimple_set_vuse (stmt, gimple_vop (fn));
472 56537180 : fn->gimple_df->rename_vops = 1;
473 56537180 : fn->gimple_df->ssa_renaming_needed = 1;
474 : }
475 :
476 : /* Now create nodes for all the new nodes. */
477 692969551 : for (new_i = 0; new_i < build_uses.length (); new_i++)
478 : {
479 312476768 : tree *op = build_uses[new_i];
480 312476768 : last = add_use_op (fn, stmt, op, last);
481 : }
482 :
483 : /* Now set the stmt's operands. */
484 380492783 : gimple_set_use_ops (stmt, new_list.next);
485 380492783 : }
486 :
487 :
488 : /* Clear the in_list bits and empty the build array for VDEFs and
489 : VUSEs. */
490 :
491 : inline void
492 11322256259 : operands_scanner::cleanup_build_arrays ()
493 : {
494 11322256259 : build_vdef = NULL_TREE;
495 11322256259 : build_vuse = NULL_TREE;
496 11322256259 : build_uses.truncate (0);
497 : }
498 :
499 :
500 : /* Finalize all the build vectors, fill the new ones into INFO. */
501 :
502 : inline void
503 380492783 : operands_scanner::finalize_ssa_stmt_operands ()
504 : {
505 380492783 : finalize_ssa_defs ();
506 380492783 : finalize_ssa_uses ();
507 380492783 : cleanup_build_arrays ();
508 380492783 : }
509 :
510 :
511 : /* Start the process of building up operands vectors in INFO. */
512 :
513 : inline void
514 11322256259 : operands_scanner::start_ssa_stmt_operands ()
515 : {
516 11322256259 : gcc_assert (build_uses.length () == 0);
517 11322256259 : gcc_assert (build_vuse == NULL_TREE);
518 11322256259 : gcc_assert (build_vdef == NULL_TREE);
519 11322256259 : }
520 :
521 :
522 : /* Add USE_P to the list of pointers to operands. */
523 :
524 : inline void
525 5650175003 : operands_scanner::append_use (tree *use_p)
526 : {
527 5650175003 : build_uses.safe_push (use_p);
528 : }
529 :
530 :
531 : /* Add VAR to the set of variables that require a VDEF operator. */
532 :
533 : inline void
534 1931000509 : operands_scanner::append_vdef (tree var)
535 : {
536 1931000509 : gcc_assert ((build_vdef == NULL_TREE
537 : || build_vdef == var)
538 : && (build_vuse == NULL_TREE
539 : || build_vuse == var));
540 :
541 1931000509 : build_vdef = var;
542 1931000509 : build_vuse = var;
543 1931000509 : }
544 :
545 :
546 : /* Add VAR to the set of variables that require a VUSE operator. */
547 :
548 : inline void
549 1357730299 : operands_scanner::append_vuse (tree var)
550 : {
551 1357730299 : gcc_assert (build_vuse == NULL_TREE
552 : || build_vuse == var);
553 :
554 1357730299 : build_vuse = var;
555 1357730299 : }
556 :
557 : /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */
558 :
559 : void
560 3479237966 : operands_scanner::add_virtual_operand (int flags)
561 : {
562 : /* Add virtual operands to the stmt, unless the caller has specifically
563 : requested not to do that (used when adding operands inside an
564 : ADDR_EXPR expression). */
565 3479237966 : if (flags & opf_no_vops)
566 : return;
567 :
568 3099643801 : gcc_assert (!is_gimple_debug (stmt));
569 :
570 3099643801 : if (flags & opf_def)
571 1931000509 : append_vdef (gimple_vop (fn));
572 : else
573 1168643292 : append_vuse (gimple_vop (fn));
574 : }
575 :
576 :
577 : /* Add *VAR_P to the appropriate operand array for statement STMT.
578 : FLAGS is as in get_expr_operands. If *VAR_P is a GIMPLE register,
579 : it will be added to the statement's real operands, otherwise it is
580 : added to virtual operands. */
581 :
582 : void
583 9679207588 : operands_scanner::add_stmt_operand (tree *var_p, int flags)
584 : {
585 9679207588 : tree var = *var_p;
586 :
587 9679207588 : gcc_assert (SSA_VAR_P (*var_p)
588 : || TREE_CODE (*var_p) == STRING_CST
589 : || TREE_CODE (*var_p) == CONST_DECL);
590 :
591 9679207588 : if (is_gimple_reg (var))
592 : {
593 : /* The variable is a GIMPLE register. Add it to real operands. */
594 8327293982 : if (flags & opf_def)
595 : ;
596 : else
597 5650175003 : append_use (var_p);
598 8327293982 : if (DECL_P (*var_p))
599 67382723 : fn->gimple_df->ssa_renaming_needed = 1;
600 : }
601 : else
602 : {
603 : /* Mark statements with volatile operands. */
604 1351913606 : if (!(flags & opf_no_vops)
605 1336756741 : && TREE_THIS_VOLATILE (var))
606 60934022 : gimple_set_has_volatile_ops (stmt, true);
607 :
608 : /* The variable is a memory access. Add virtual operands. */
609 1351913606 : add_virtual_operand (flags);
610 : }
611 9679207588 : }
612 :
613 : /* Mark the base address of REF as having its address taken.
614 : REF may be a single variable whose address has been taken or any
615 : other valid GIMPLE memory reference (structure reference, array,
616 : etc). */
617 :
618 : static void
619 1518678643 : mark_address_taken (tree ref)
620 : {
621 1518678643 : tree var;
622 :
623 : /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
624 : as the only thing we take the address of. If VAR is a structure,
625 : taking the address of a field means that the whole structure may
626 : be referenced using pointer arithmetic. See PR 21407 and the
627 : ensuing mailing list discussion. */
628 1518678643 : var = get_base_address (ref);
629 1518678643 : if (VAR_P (var)
630 : || TREE_CODE (var) == RESULT_DECL
631 : || TREE_CODE (var) == PARM_DECL)
632 473154227 : TREE_ADDRESSABLE (var) = 1;
633 1518678643 : }
634 :
635 :
636 : /* A subroutine of get_expr_operands to handle MEM_REF.
637 :
638 : STMT is the statement being processed, EXPR is the MEM_REF
639 : that got us here.
640 :
641 : FLAGS is as in get_expr_operands. */
642 :
643 : void
644 1352624954 : operands_scanner::get_mem_ref_operands (tree expr, int flags)
645 : {
646 1352624954 : tree *pptr = &TREE_OPERAND (expr, 0);
647 :
648 1352624954 : if (!(flags & opf_no_vops)
649 988303652 : && TREE_THIS_VOLATILE (expr))
650 1189991 : gimple_set_has_volatile_ops (stmt, true);
651 :
652 : /* Add the VOP. */
653 1352624954 : add_virtual_operand (flags);
654 :
655 : /* If requested, add a USE operand for the base pointer. */
656 1352624954 : get_expr_operands (pptr,
657 : opf_non_addressable | opf_use
658 1352624954 : | (flags & (opf_no_vops|opf_not_non_addressable)));
659 1352624954 : }
660 :
661 :
662 : /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
663 :
664 : void
665 30672916 : operands_scanner::get_tmr_operands(tree expr, int flags)
666 : {
667 30672916 : if (!(flags & opf_no_vops)
668 30556918 : && TREE_THIS_VOLATILE (expr))
669 0 : gimple_set_has_volatile_ops (stmt, true);
670 :
671 : /* First record the real operands. */
672 30672916 : get_expr_operands (&TMR_BASE (expr),
673 : opf_non_addressable | opf_use
674 30672916 : | (flags & (opf_no_vops|opf_not_non_addressable)));
675 30672916 : get_expr_operands (&TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
676 30672916 : get_expr_operands (&TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
677 :
678 30672916 : add_virtual_operand (flags);
679 30672916 : }
680 :
681 :
682 : /* If STMT is a call that may clobber globals and other symbols that
683 : escape, add them to the VDEF/VUSE lists for it. */
684 :
685 : void
686 808050508 : operands_scanner::maybe_add_call_vops (gcall *stmt)
687 : {
688 808050508 : int call_flags = gimple_call_flags (stmt);
689 :
690 : /* If aliases have been computed already, add VDEF or VUSE
691 : operands for all the symbols that have been found to be
692 : call-clobbered. */
693 808050508 : if (!(call_flags & ECF_NOVOPS))
694 : {
695 : /* A 'pure' or a 'const' function never call-clobbers anything. */
696 807406242 : if (!(call_flags & (ECF_PURE | ECF_CONST)))
697 676947492 : add_virtual_operand (opf_def);
698 130458750 : else if (!(call_flags & ECF_CONST))
699 62778439 : add_virtual_operand (opf_use);
700 : }
701 808050508 : }
702 :
703 :
704 : /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
705 :
706 : void
707 11208946 : operands_scanner::get_asm_stmt_operands (gasm *stmt)
708 : {
709 11208946 : size_t i, noutputs;
710 11208946 : const char **oconstraints;
711 11208946 : const char *constraint;
712 11208946 : bool allows_mem, allows_reg, is_inout;
713 :
714 11208946 : noutputs = gimple_asm_noutputs (stmt);
715 11208946 : oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
716 :
717 : /* Gather all output operands. */
718 20735640 : for (i = 0; i < gimple_asm_noutputs (stmt); i++)
719 : {
720 9526694 : tree link = gimple_asm_output_op (stmt, i);
721 9526694 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
722 9526694 : oconstraints[i] = constraint;
723 9526694 : parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
724 : &allows_reg, &is_inout, nullptr);
725 :
726 : /* This should have been split in gimplify_asm_expr. */
727 9526694 : gcc_assert (!allows_reg || !is_inout);
728 :
729 : /* Memory operands are addressable. Note that STMT needs the
730 : address of this operand. */
731 9526694 : if (!allows_reg && allows_mem)
732 593028 : mark_address_taken (TREE_VALUE (link));
733 :
734 9526694 : get_expr_operands (&TREE_VALUE (link), opf_def | opf_not_non_addressable);
735 : }
736 :
737 : /* Gather all input operands. */
738 17518371 : for (i = 0; i < gimple_asm_ninputs (stmt); i++)
739 : {
740 6309425 : tree link = gimple_asm_input_op (stmt, i);
741 6309425 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
742 6309425 : parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints,
743 : &allows_mem, &allows_reg, nullptr);
744 :
745 : /* Memory operands are addressable. Note that STMT needs the
746 : address of this operand. */
747 6309425 : if (!allows_reg && allows_mem)
748 647383 : mark_address_taken (TREE_VALUE (link));
749 :
750 6309425 : get_expr_operands (&TREE_VALUE (link), opf_not_non_addressable);
751 : }
752 :
753 : /* Clobber all memory and addressable symbols for asm ("" : : : "memory"); */
754 11208946 : if (gimple_asm_clobbers_memory_p (stmt))
755 4277627 : add_virtual_operand (opf_def);
756 11208946 : }
757 :
758 :
759 : /* Recursively scan the expression pointed to by EXPR_P in statement
760 : STMT. FLAGS is one of the OPF_* constants modifying how to
761 : interpret the operands found. */
762 :
763 : void
764 22322138857 : operands_scanner::get_expr_operands (tree *expr_p, int flags)
765 : {
766 27462233205 : enum tree_code code;
767 27462233205 : enum tree_code_class codeclass;
768 27462233205 : tree expr = *expr_p;
769 27462233205 : int uflags = opf_use;
770 :
771 27462233205 : if (expr == NULL)
772 : return;
773 :
774 21821546267 : if (is_gimple_debug (stmt))
775 4187845154 : uflags |= (flags & opf_no_vops);
776 :
777 21821546267 : code = TREE_CODE (expr);
778 21821546267 : codeclass = TREE_CODE_CLASS (code);
779 :
780 21821546267 : switch (code)
781 : {
782 2643635129 : case ADDR_EXPR:
783 : /* Taking the address of a variable does not represent a
784 : reference to it, but the fact that the statement takes its
785 : address will be of interest to some passes (e.g. alias
786 : resolution). */
787 2643635129 : if ((!(flags & opf_non_addressable)
788 427743808 : || (flags & opf_not_non_addressable))
789 2749699782 : && !is_gimple_debug (stmt))
790 1517438232 : mark_address_taken (TREE_OPERAND (expr, 0));
791 :
792 : /* Otherwise, there may be variables referenced inside but there
793 : should be no VUSEs created, since the referenced objects are
794 : not really accessed. The only operands that we should find
795 : here are ARRAY_REF indices which will always be real operands
796 : (GIMPLE does not allow non-registers as array indices). */
797 2643635129 : flags |= opf_no_vops;
798 2643635129 : get_expr_operands (&TREE_OPERAND (expr, 0),
799 : flags | opf_not_non_addressable | opf_address_taken);
800 2643635129 : return;
801 :
802 11193411449 : case SSA_NAME:
803 11193411449 : case VAR_DECL:
804 11193411449 : case PARM_DECL:
805 11193411449 : case RESULT_DECL:
806 11193411449 : case STRING_CST:
807 11193411449 : case CONST_DECL:
808 11193411449 : if (!(flags & opf_address_taken))
809 9679207588 : add_stmt_operand (expr_p, flags);
810 : return;
811 :
812 : case OMP_NEXT_VARIANT:
813 : case OMP_TARGET_DEVICE_MATCHES:
814 : return;
815 :
816 561939761 : case DEBUG_EXPR_DECL:
817 561939761 : gcc_assert (gimple_debug_bind_p (stmt));
818 : return;
819 :
820 1352624954 : case MEM_REF:
821 1352624954 : get_mem_ref_operands (expr, flags);
822 1352624954 : return;
823 :
824 30672916 : case TARGET_MEM_REF:
825 30672916 : get_tmr_operands (expr, flags);
826 30672916 : return;
827 :
828 2407407702 : case ARRAY_REF:
829 2407407702 : case ARRAY_RANGE_REF:
830 2407407702 : case COMPONENT_REF:
831 2407407702 : case REALPART_EXPR:
832 2407407702 : case IMAGPART_EXPR:
833 2407407702 : {
834 2407407702 : if (!(flags & opf_no_vops)
835 1751032131 : && TREE_THIS_VOLATILE (expr))
836 5431617 : gimple_set_has_volatile_ops (stmt, true);
837 :
838 2407407702 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
839 :
840 2407407702 : if (code == COMPONENT_REF)
841 2009441723 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
842 397965979 : else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
843 : {
844 370233087 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
845 370233087 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
846 370233087 : get_expr_operands (&TREE_OPERAND (expr, 3), uflags);
847 : }
848 :
849 : return;
850 : }
851 :
852 15771 : case WITH_SIZE_EXPR:
853 : /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
854 : and an rvalue reference to its second argument. */
855 15771 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
856 15771 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
857 15771 : return;
858 :
859 953120 : case COND_EXPR:
860 953120 : case VEC_COND_EXPR:
861 953120 : case VEC_PERM_EXPR:
862 953120 : get_expr_operands (&TREE_OPERAND (expr, 0), uflags);
863 953120 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
864 953120 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
865 953120 : return;
866 :
867 240884582 : case CONSTRUCTOR:
868 240884582 : {
869 : /* General aggregate CONSTRUCTORs have been decomposed, but they
870 : are still in use as the COMPLEX_EXPR equivalent for vectors. */
871 240884582 : constructor_elt *ce;
872 240884582 : unsigned HOST_WIDE_INT idx;
873 :
874 : /* A volatile constructor is actually TREE_CLOBBER_P, transfer
875 : the volatility to the statement, don't use TREE_CLOBBER_P for
876 : mirroring the other uses of THIS_VOLATILE in this file. */
877 240884582 : if (!(flags & opf_no_vops)
878 240881496 : && TREE_THIS_VOLATILE (expr))
879 215176218 : gimple_set_has_volatile_ops (stmt, true);
880 :
881 19071080 : for (idx = 0;
882 259955662 : vec_safe_iterate (CONSTRUCTOR_ELTS (expr), idx, &ce);
883 : idx++)
884 19071080 : get_expr_operands (&ce->value, uflags);
885 :
886 : return;
887 : }
888 :
889 11442439 : case BIT_FIELD_REF:
890 11442439 : if (!(flags & opf_no_vops)
891 11384023 : && TREE_THIS_VOLATILE (expr))
892 850 : gimple_set_has_volatile_ops (stmt, true);
893 : /* FALLTHRU */
894 :
895 69362851 : case VIEW_CONVERT_EXPR:
896 69362851 : do_unary:
897 69362851 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
898 69362851 : return;
899 :
900 46452667 : case BIT_INSERT_EXPR:
901 46452667 : case COMPOUND_EXPR:
902 46452667 : case OBJ_TYPE_REF:
903 46452667 : do_binary:
904 46452667 : {
905 46452667 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
906 46452667 : get_expr_operands (&TREE_OPERAND (expr, 1), flags);
907 46452667 : return;
908 : }
909 :
910 0 : case DOT_PROD_EXPR:
911 0 : case SAD_EXPR:
912 0 : case REALIGN_LOAD_EXPR:
913 0 : case WIDEN_MULT_PLUS_EXPR:
914 0 : case WIDEN_MULT_MINUS_EXPR:
915 0 : {
916 0 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
917 0 : get_expr_operands (&TREE_OPERAND (expr, 1), flags);
918 0 : get_expr_operands (&TREE_OPERAND (expr, 2), flags);
919 0 : return;
920 : }
921 :
922 : case FUNCTION_DECL:
923 : case LABEL_DECL:
924 : case CASE_LABEL_EXPR:
925 : /* Expressions that make no memory references. */
926 : return;
927 :
928 2405033771 : default:
929 2405033771 : if (codeclass == tcc_unary)
930 19816714 : goto do_unary;
931 2385217057 : if (codeclass == tcc_binary || codeclass == tcc_comparison)
932 37356942 : goto do_binary;
933 2347860115 : if (codeclass == tcc_constant || codeclass == tcc_type)
934 : return;
935 : }
936 :
937 : /* If we get here, something has gone wrong. */
938 0 : if (flag_checking)
939 : {
940 0 : fprintf (stderr, "unhandled expression in get_expr_operands():\n");
941 0 : debug_tree (expr);
942 0 : fputs ("\n", stderr);
943 0 : gcc_unreachable ();
944 : }
945 : }
946 :
947 :
948 : /* Parse STMT looking for operands. When finished, the various
949 : build_* operand vectors will have potential operands in them. */
950 :
951 : void
952 11322256259 : operands_scanner::parse_ssa_operands ()
953 : {
954 11322256259 : enum gimple_code code = gimple_code (stmt);
955 11322256259 : size_t i, n, start = 0;
956 :
957 11322256259 : switch (code)
958 : {
959 11208946 : case GIMPLE_ASM:
960 11208946 : get_asm_stmt_operands (as_a <gasm *> (stmt));
961 11208946 : break;
962 :
963 22932 : case GIMPLE_TRANSACTION:
964 : /* The start of a transaction is a memory barrier. */
965 22932 : add_virtual_operand (opf_def | opf_use);
966 22932 : break;
967 :
968 5922932131 : case GIMPLE_DEBUG:
969 5922932131 : if (gimple_debug_bind_p (stmt)
970 5922932131 : && gimple_debug_bind_has_value_p (stmt))
971 2539559958 : get_expr_operands (gimple_debug_bind_get_value_ptr (stmt),
972 : opf_use | opf_no_vops);
973 : break;
974 :
975 189087007 : case GIMPLE_RETURN:
976 189087007 : append_vuse (gimple_vop (fn));
977 189087007 : goto do_default;
978 :
979 808050508 : case GIMPLE_CALL:
980 : /* Add call-clobbered operands, if needed. */
981 808050508 : maybe_add_call_vops (as_a <gcall *> (stmt));
982 : /* FALLTHRU */
983 :
984 4407011947 : case GIMPLE_ASSIGN:
985 4407011947 : get_expr_operands (gimple_op_ptr (stmt, 0), opf_def);
986 4407011947 : start = 1;
987 : /* FALLTHRU */
988 :
989 5388092250 : default:
990 5388092250 : do_default:
991 5388092250 : n = gimple_num_ops (stmt);
992 16087859747 : for (i = start; i < n; i++)
993 10699767497 : get_expr_operands (gimple_op_ptr (stmt, i), opf_use);
994 : break;
995 : }
996 11322256259 : }
997 :
998 :
999 : /* Create an operands cache for STMT. */
1000 :
1001 : void
1002 380492783 : operands_scanner::build_ssa_operands ()
1003 : {
1004 : /* Initially assume that the statement has no volatile operands. */
1005 380492783 : gimple_set_has_volatile_ops (stmt, false);
1006 :
1007 380492783 : start_ssa_stmt_operands ();
1008 380492783 : parse_ssa_operands ();
1009 380492783 : finalize_ssa_stmt_operands ();
1010 380492783 : }
1011 :
1012 : /* Verifies SSA statement operands. */
1013 :
1014 : DEBUG_FUNCTION bool
1015 10941763476 : operands_scanner::verify_ssa_operands ()
1016 : {
1017 10941763476 : use_operand_p use_p;
1018 10941763476 : def_operand_p def_p;
1019 10941763476 : ssa_op_iter iter;
1020 10941763476 : unsigned i;
1021 10941763476 : tree def;
1022 10941763476 : bool volatile_p = gimple_has_volatile_ops (stmt);
1023 :
1024 : /* build_ssa_operands w/o finalizing them. */
1025 10941763476 : gimple_set_has_volatile_ops (stmt, false);
1026 10941763476 : start_ssa_stmt_operands ();
1027 10941763476 : parse_ssa_operands ();
1028 :
1029 : /* Now verify the built operands are the same as present in STMT. */
1030 10941763476 : def = gimple_vdef (stmt);
1031 4438918501 : if (def
1032 1830545993 : && TREE_CODE (def) == SSA_NAME)
1033 10941763476 : def = SSA_NAME_VAR (def);
1034 10941763476 : if (build_vdef != def)
1035 : {
1036 0 : error ("virtual definition of statement not up to date");
1037 0 : return true;
1038 : }
1039 10941763476 : if (gimple_vdef (stmt)
1040 : && ((def_p = gimple_vdef_op (stmt)) == NULL_DEF_OPERAND_P
1041 : || DEF_FROM_PTR (def_p) != gimple_vdef (stmt)))
1042 : {
1043 : error ("virtual def operand missing for statement");
1044 : return true;
1045 : }
1046 :
1047 10941763476 : tree use = gimple_vuse (stmt);
1048 4438918501 : if (use
1049 2949140129 : && TREE_CODE (use) == SSA_NAME)
1050 10941763476 : use = SSA_NAME_VAR (use);
1051 10941763476 : if (build_vuse != use)
1052 : {
1053 0 : error ("virtual use of statement not up to date");
1054 0 : return true;
1055 : }
1056 10941763476 : if (gimple_vuse (stmt)
1057 4438918501 : && ((use_p = gimple_vuse_op (stmt)) == NULL_USE_OPERAND_P
1058 2949140129 : || USE_FROM_PTR (use_p) != gimple_vuse (stmt)))
1059 : {
1060 0 : error ("virtual use operand missing for statement");
1061 0 : return true;
1062 : }
1063 :
1064 16372508403 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1065 : {
1066 : tree *op;
1067 7121402376 : FOR_EACH_VEC_ELT (build_uses, i, op)
1068 : {
1069 7121402376 : if (use_p->use == op)
1070 : {
1071 5430744927 : build_uses[i] = NULL;
1072 5430744927 : break;
1073 : }
1074 : }
1075 10861489854 : if (i == build_uses.length ())
1076 : {
1077 0 : error ("excess use operand for statement");
1078 0 : debug_generic_expr (USE_FROM_PTR (use_p));
1079 0 : return true;
1080 : }
1081 : }
1082 :
1083 : tree *op;
1084 16372508403 : FOR_EACH_VEC_ELT (build_uses, i, op)
1085 5430744927 : if (op != NULL)
1086 : {
1087 0 : error ("use operand missing for statement");
1088 0 : debug_generic_expr (*op);
1089 0 : return true;
1090 : }
1091 :
1092 15431688067 : if (gimple_has_volatile_ops (stmt) != volatile_p)
1093 : {
1094 0 : error ("statement volatile flag not up to date");
1095 0 : return true;
1096 : }
1097 :
1098 10941763476 : cleanup_build_arrays ();
1099 10941763476 : return false;
1100 : }
1101 :
1102 : /* Interface for external use. */
1103 :
1104 : DEBUG_FUNCTION bool
1105 10941763476 : verify_ssa_operands (struct function *fn, gimple *stmt)
1106 : {
1107 10941763476 : return operands_scanner (fn, stmt).verify_ssa_operands ();
1108 : }
1109 :
1110 :
1111 : /* Releases the operands of STMT back to their freelists, and clears
1112 : the stmt operand lists. */
1113 :
1114 : void
1115 2044533 : free_stmt_operands (struct function *fn, gimple *stmt)
1116 : {
1117 2044533 : use_optype_p uses = gimple_use_ops (stmt), last_use;
1118 :
1119 2033292 : if (uses)
1120 : {
1121 8284 : for (last_use = uses; last_use->next; last_use = last_use->next)
1122 2961 : delink_imm_use (USE_OP_PTR (last_use));
1123 5323 : delink_imm_use (USE_OP_PTR (last_use));
1124 5323 : last_use->next = gimple_ssa_operands (fn)->free_uses;
1125 5323 : gimple_ssa_operands (fn)->free_uses = uses;
1126 5323 : gimple_set_use_ops (stmt, NULL);
1127 : }
1128 :
1129 2044533 : if (gimple_has_mem_ops (stmt))
1130 : {
1131 1842150 : gimple_set_vuse (stmt, NULL_TREE);
1132 1842150 : gimple_set_vdef (stmt, NULL_TREE);
1133 : }
1134 2044533 : }
1135 :
1136 :
1137 : /* Get the operands of statement STMT. */
1138 :
1139 : void
1140 382665441 : update_stmt_operands (struct function *fn, gimple *stmt)
1141 : {
1142 : /* If update_stmt_operands is called before SSA is initialized, do
1143 : nothing. */
1144 382665441 : if (!ssa_operands_active (fn))
1145 : return;
1146 :
1147 380492783 : timevar_push (TV_TREE_OPS);
1148 :
1149 760985566 : gcc_assert (gimple_modified_p (stmt));
1150 380492783 : operands_scanner (fn, stmt).build_ssa_operands ();
1151 380492783 : gimple_set_modified (stmt, false);
1152 :
1153 380492783 : timevar_pop (TV_TREE_OPS);
1154 : }
1155 :
1156 :
1157 : /* Swap operands EXP0 and EXP1 in statement STMT. No attempt is done
1158 : to test the validity of the swap operation. */
1159 :
1160 : void
1161 409152 : swap_ssa_operands (gimple *stmt, tree *exp0, tree *exp1)
1162 : {
1163 409152 : tree op0, op1;
1164 409152 : op0 = *exp0;
1165 409152 : op1 = *exp1;
1166 :
1167 409152 : if (op0 != op1)
1168 : {
1169 : /* Attempt to preserve the relative positions of these two operands in
1170 : their * respective immediate use lists by adjusting their use pointer
1171 : to point to the new operand position. */
1172 409152 : use_optype_p use0, use1, ptr;
1173 409152 : use0 = use1 = NULL;
1174 :
1175 : /* Find the 2 operands in the cache, if they are there. */
1176 818421 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1177 409152 : if (USE_OP_PTR (ptr)->use == exp0)
1178 : {
1179 : use0 = ptr;
1180 : break;
1181 : }
1182 :
1183 1227339 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1184 805341 : if (USE_OP_PTR (ptr)->use == exp1)
1185 : {
1186 : use1 = ptr;
1187 : break;
1188 : }
1189 :
1190 : /* And adjust their location to point to the new position of the
1191 : operand. */
1192 409152 : if (use0)
1193 409035 : USE_OP_PTR (use0)->use = exp1;
1194 409152 : if (use1)
1195 396306 : USE_OP_PTR (use1)->use = exp0;
1196 :
1197 : /* Now swap the data. */
1198 409152 : *exp0 = op1;
1199 409152 : *exp1 = op0;
1200 : }
1201 409152 : }
1202 :
1203 :
1204 : /* Scan the immediate_use list for VAR making sure its linked properly.
1205 : Return TRUE if there is a problem and emit an error message to F. */
1206 :
1207 : DEBUG_FUNCTION bool
1208 6194328217 : verify_imm_links (FILE *f, tree var)
1209 : {
1210 6194328217 : use_operand_p ptr, prev, list;
1211 6194328217 : unsigned int count;
1212 :
1213 6194328217 : gcc_assert (TREE_CODE (var) == SSA_NAME);
1214 :
1215 6194328217 : list = &(SSA_NAME_IMM_USE_NODE (var));
1216 6194328217 : gcc_assert (list->use == NULL);
1217 :
1218 6194328217 : if (list->prev == NULL)
1219 : {
1220 0 : gcc_assert (list->next == NULL);
1221 : return false;
1222 : }
1223 :
1224 6194328217 : prev = list;
1225 6194328217 : count = 0;
1226 17186371294 : for (ptr = list->next; ptr != list; )
1227 : {
1228 10992043077 : if (prev != ptr->prev)
1229 : {
1230 0 : fprintf (f, "prev != ptr->prev\n");
1231 0 : goto error;
1232 : }
1233 :
1234 10992043077 : if (ptr->use == NULL)
1235 : {
1236 0 : fprintf (f, "ptr->use == NULL\n");
1237 0 : goto error; /* 2 roots, or SAFE guard node. */
1238 : }
1239 10992043077 : else if (*(ptr->use) != var)
1240 : {
1241 0 : fprintf (f, "*(ptr->use) != var\n");
1242 0 : goto error;
1243 : }
1244 :
1245 10992043077 : prev = ptr;
1246 10992043077 : ptr = ptr->next;
1247 :
1248 10992043077 : count++;
1249 10992043077 : if (count == 0)
1250 : {
1251 0 : fprintf (f, "number of immediate uses doesn't fit unsigned int\n");
1252 0 : goto error;
1253 : }
1254 : }
1255 :
1256 : /* Verify list in the other direction. */
1257 : prev = list;
1258 17186371294 : for (ptr = list->prev; ptr != list; )
1259 : {
1260 10992043077 : if (prev != ptr->next)
1261 : {
1262 0 : fprintf (f, "prev != ptr->next\n");
1263 0 : goto error;
1264 : }
1265 10992043077 : prev = ptr;
1266 10992043077 : ptr = ptr->prev;
1267 10992043077 : if (count == 0)
1268 : {
1269 0 : fprintf (f, "count-- < 0\n");
1270 0 : goto error;
1271 : }
1272 10992043077 : count--;
1273 : }
1274 :
1275 6194328217 : if (count != 0)
1276 : {
1277 0 : fprintf (f, "count != 0\n");
1278 0 : goto error;
1279 : }
1280 :
1281 : return false;
1282 :
1283 0 : error:
1284 0 : if (ptr->loc.stmt && gimple_modified_p (ptr->loc.stmt))
1285 : {
1286 0 : fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->loc.stmt);
1287 0 : print_gimple_stmt (f, ptr->loc.stmt, 0, TDF_SLIM);
1288 : }
1289 0 : fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
1290 0 : (void *)ptr->use);
1291 0 : print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
1292 0 : fprintf (f, "\n");
1293 0 : return true;
1294 : }
1295 :
1296 :
1297 : /* Dump all the immediate uses to FILE. */
1298 :
1299 : void
1300 0 : dump_immediate_uses_for (FILE *file, tree var)
1301 : {
1302 0 : imm_use_iterator iter;
1303 0 : use_operand_p use_p;
1304 :
1305 0 : gcc_assert (var && TREE_CODE (var) == SSA_NAME);
1306 :
1307 0 : print_generic_expr (file, var, TDF_SLIM);
1308 0 : fprintf (file, " : -->");
1309 0 : if (has_zero_uses (var))
1310 0 : fprintf (file, " no uses.\n");
1311 : else
1312 0 : if (has_single_use (var))
1313 0 : fprintf (file, " single use.\n");
1314 : else
1315 0 : fprintf (file, "%d uses.\n", num_imm_uses (var));
1316 :
1317 0 : FOR_EACH_IMM_USE_FAST (use_p, iter, var)
1318 : {
1319 0 : if (use_p->loc.stmt == NULL && use_p->use == NULL)
1320 0 : fprintf (file, "***end of stmt iterator marker***\n");
1321 : else
1322 0 : if (!is_gimple_reg (USE_FROM_PTR (use_p)))
1323 0 : print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
1324 : else
1325 0 : print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
1326 0 : }
1327 0 : fprintf (file, "\n");
1328 0 : }
1329 :
1330 :
1331 : /* Dump all the immediate uses to FILE. */
1332 :
1333 : void
1334 0 : dump_immediate_uses (FILE *file)
1335 : {
1336 0 : tree var;
1337 0 : unsigned int x;
1338 :
1339 0 : fprintf (file, "Immediate_uses: \n\n");
1340 0 : FOR_EACH_SSA_NAME (x, var, cfun)
1341 : {
1342 0 : dump_immediate_uses_for (file, var);
1343 : }
1344 0 : }
1345 :
1346 :
1347 : /* Dump def-use edges on stderr. */
1348 :
1349 : DEBUG_FUNCTION void
1350 0 : debug_immediate_uses (void)
1351 : {
1352 0 : dump_immediate_uses (stderr);
1353 0 : }
1354 :
1355 :
1356 : /* Dump def-use edges on stderr. */
1357 :
1358 : DEBUG_FUNCTION void
1359 0 : debug_immediate_uses_for (tree var)
1360 : {
1361 0 : dump_immediate_uses_for (stderr, var);
1362 0 : }
1363 :
1364 :
1365 : /* Unlink STMTs virtual definition from the IL by propagating its use. */
1366 :
1367 : void
1368 55241605 : unlink_stmt_vdef (gimple *stmt)
1369 : {
1370 55241605 : use_operand_p use_p;
1371 55241605 : imm_use_iterator iter;
1372 55241605 : gimple *use_stmt;
1373 55241605 : tree vdef = gimple_vdef (stmt);
1374 55241605 : tree vuse = gimple_vuse (stmt);
1375 :
1376 55241605 : if (!vdef
1377 14954650 : || TREE_CODE (vdef) != SSA_NAME)
1378 41020097 : return;
1379 :
1380 49663812 : FOR_EACH_IMM_USE_STMT (use_stmt, iter, vdef)
1381 : {
1382 65623382 : FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1383 22201293 : SET_USE (use_p, vuse);
1384 14221508 : }
1385 :
1386 14221508 : if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vdef))
1387 949 : SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse) = 1;
1388 : }
1389 :
1390 : /* Return true if the var whose chain of uses starts at PTR has a
1391 : single nondebug use. Set USE_P and STMT to that single nondebug
1392 : use, if so, or to NULL otherwise. */
1393 : bool
1394 45923245 : single_imm_use_1 (const ssa_use_operand_t *head,
1395 : use_operand_p *use_p, gimple **stmt)
1396 : {
1397 45923245 : ssa_use_operand_t *ptr, *single_use = 0;
1398 :
1399 100045351 : for (ptr = head->next; ptr != head; ptr = ptr->next)
1400 95582298 : if (USE_STMT(ptr) && !is_gimple_debug (USE_STMT (ptr)))
1401 : {
1402 87377794 : if (single_use)
1403 : {
1404 : single_use = NULL;
1405 : break;
1406 : }
1407 : single_use = ptr;
1408 : }
1409 :
1410 45923245 : if (use_p)
1411 45923245 : *use_p = single_use;
1412 :
1413 45923245 : if (stmt)
1414 45923245 : *stmt = single_use ? single_use->loc.stmt : NULL;
1415 :
1416 45923245 : return single_use;
1417 : }
1418 :
1419 : /* Gather all stmts SSAVAR is used on, eliminating duplicates. */
1420 :
1421 : auto_vec<gimple *, 2>
1422 3217223 : gather_imm_use_stmts (tree ssavar)
1423 : {
1424 3217223 : auto_vec<gimple *, 2> stmts;
1425 3217223 : imm_use_iterator iter;
1426 3217223 : use_operand_p use_p;
1427 13749890 : FOR_EACH_IMM_USE_FAST (use_p, iter, ssavar)
1428 : {
1429 7315444 : gimple *use_stmt = USE_STMT (use_p);
1430 7315444 : if (use_stmt->ilf)
1431 47155 : continue;
1432 7268289 : use_stmt->ilf = 1;
1433 7268289 : stmts.safe_push (use_stmt);
1434 3217223 : }
1435 16919958 : for (gimple *use_stmt : stmts)
1436 7268289 : use_stmt->ilf = 0;
1437 3217223 : return stmts;
1438 : }
|
