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 22619507762 : class operands_scanner
105 : {
106 : public:
107 11309753881 : operands_scanner (struct function *fun, gimple *statement)
108 11309753881 : {
109 11309753881 : build_vuse = NULL_TREE;
110 11309753881 : build_vdef = NULL_TREE;
111 11309753881 : fn = fun;
112 11309753881 : 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 787670351 : gimple_ssa_operands (const struct function *fun)
211 : {
212 787670351 : return &fun->gimple_df->ssa_operands;
213 : }
214 :
215 :
216 : /* Return true if the SSA operands cache is active. */
217 :
218 : bool
219 820023042 : ssa_operands_active (struct function *fun)
220 : {
221 820023042 : if (fun == NULL)
222 : return false;
223 :
224 820023042 : 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 3187549 : create_vop_var (struct function *fn)
233 : {
234 3187549 : tree global_var;
235 :
236 3187549 : gcc_assert (fn->gimple_df->vop == NULL_TREE);
237 :
238 3187549 : global_var = build_decl (BUILTINS_LOCATION, VAR_DECL,
239 : get_identifier (".MEM"),
240 : void_type_node);
241 3187549 : DECL_ARTIFICIAL (global_var) = 1;
242 3187549 : DECL_IGNORED_P (global_var) = 1;
243 3187549 : TREE_READONLY (global_var) = 0;
244 3187549 : DECL_EXTERNAL (global_var) = 1;
245 3187549 : TREE_STATIC (global_var) = 1;
246 3187549 : TREE_USED (global_var) = 1;
247 3187549 : DECL_CONTEXT (global_var) = NULL_TREE;
248 3187549 : TREE_THIS_VOLATILE (global_var) = 0;
249 3187549 : TREE_ADDRESSABLE (global_var) = 0;
250 3187549 : VAR_DECL_IS_VIRTUAL_OPERAND (global_var) = 1;
251 :
252 3187549 : fn->gimple_df->vop = global_var;
253 3187549 : }
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 3187549 : init_ssa_operands (struct function *fn)
271 : {
272 3187549 : gcc_assert (gimple_ssa_operands (fn)->operand_memory == NULL);
273 3187549 : gimple_ssa_operands (fn)->operand_memory_index
274 3187549 : = gimple_ssa_operands (fn)->ssa_operand_mem_size;
275 3187549 : gimple_ssa_operands (fn)->ops_active = true;
276 3187549 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_INIT;
277 3187549 : create_vop_var (fn);
278 3187549 : }
279 :
280 :
281 : /* Dispose of anything required by the operand routines. */
282 :
283 : void
284 3131792 : fini_ssa_operands (struct function *fn)
285 : {
286 3131792 : struct ssa_operand_memory_d *ptr;
287 :
288 3131792 : gimple_ssa_operands (fn)->free_uses = NULL;
289 :
290 7631360 : while ((ptr = gimple_ssa_operands (fn)->operand_memory) != NULL)
291 : {
292 4499568 : gimple_ssa_operands (fn)->operand_memory
293 4499568 : = gimple_ssa_operands (fn)->operand_memory->next;
294 4499568 : ggc_free (ptr);
295 : }
296 :
297 3131792 : gimple_ssa_operands (fn)->ops_active = false;
298 :
299 3131792 : fn->gimple_df->vop = NULL_TREE;
300 3131792 : }
301 :
302 :
303 : /* Return memory for an operand of size SIZE. */
304 :
305 : static inline void *
306 179112943 : ssa_operand_alloc (struct function *fn, unsigned size)
307 : {
308 179112943 : char *ptr;
309 :
310 179112943 : gcc_assert (size == sizeof (struct use_optype_d));
311 :
312 179112943 : if (gimple_ssa_operands (fn)->operand_memory_index + size
313 179112943 : >= gimple_ssa_operands (fn)->ssa_operand_mem_size)
314 : {
315 4563703 : struct ssa_operand_memory_d *ptr;
316 :
317 4563703 : switch (gimple_ssa_operands (fn)->ssa_operand_mem_size)
318 : {
319 3185636 : case OP_SIZE_INIT:
320 3185636 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_1;
321 3185636 : break;
322 996408 : case OP_SIZE_1:
323 996408 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_2;
324 996408 : break;
325 381659 : case OP_SIZE_2:
326 381659 : case OP_SIZE_3:
327 381659 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_3;
328 381659 : break;
329 0 : default:
330 0 : gcc_unreachable ();
331 : }
332 :
333 :
334 4563703 : ptr = (ssa_operand_memory_d *) ggc_internal_alloc
335 4563703 : (sizeof (void *) + gimple_ssa_operands (fn)->ssa_operand_mem_size);
336 :
337 4563703 : ptr->next = gimple_ssa_operands (fn)->operand_memory;
338 4563703 : gimple_ssa_operands (fn)->operand_memory = ptr;
339 4563703 : gimple_ssa_operands (fn)->operand_memory_index = 0;
340 : }
341 :
342 179112943 : ptr = &(gimple_ssa_operands (fn)->operand_memory
343 179112943 : ->mem[gimple_ssa_operands (fn)->operand_memory_index]);
344 179112943 : gimple_ssa_operands (fn)->operand_memory_index += size;
345 179112943 : return ptr;
346 : }
347 :
348 :
349 : /* Allocate a USE operand. */
350 :
351 : static inline struct use_optype_d *
352 312998813 : alloc_use (struct function *fn)
353 : {
354 312998813 : struct use_optype_d *ret;
355 312998813 : if (gimple_ssa_operands (fn)->free_uses)
356 : {
357 133885870 : ret = gimple_ssa_operands (fn)->free_uses;
358 133885870 : gimple_ssa_operands (fn)->free_uses
359 133885870 : = gimple_ssa_operands (fn)->free_uses->next;
360 : }
361 : else
362 179112943 : ret = (struct use_optype_d *)
363 179112943 : ssa_operand_alloc (fn, sizeof (struct use_optype_d));
364 312998813 : 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 312998813 : add_use_op (struct function *fn, gimple *stmt, tree *op, use_optype_p last)
372 : {
373 312998813 : use_optype_p new_use;
374 :
375 312998813 : new_use = alloc_use (fn);
376 312998813 : USE_OP_PTR (new_use)->use = op;
377 312998813 : link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
378 312998813 : last->next = new_use;
379 312998813 : new_use->next = NULL;
380 312998813 : 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 382047318 : operands_scanner::finalize_ssa_defs ()
390 : {
391 : /* Pre-pend the vdef we may have built. */
392 382047318 : if (build_vdef != NULL_TREE)
393 : {
394 56356151 : tree oldvdef = gimple_vdef (stmt);
395 56356151 : if (oldvdef
396 21008256 : && TREE_CODE (oldvdef) == SSA_NAME)
397 56356151 : oldvdef = SSA_NAME_VAR (oldvdef);
398 56356151 : if (oldvdef != build_vdef)
399 35347895 : gimple_set_vdef (stmt, build_vdef);
400 : }
401 :
402 : /* Clear and unlink a no longer necessary VDEF. */
403 382047318 : if (build_vdef == NULL_TREE
404 494779447 : && gimple_vdef (stmt) != NULL_TREE)
405 : {
406 4097883 : if (TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
407 : {
408 3936617 : unlink_stmt_vdef (stmt);
409 7873234 : release_ssa_name_fn (fn, gimple_vdef (stmt));
410 : }
411 4097883 : gimple_set_vdef (stmt, NULL_TREE);
412 : }
413 :
414 : /* If we have a non-SSA_NAME VDEF, mark it for renaming. */
415 382047318 : if (gimple_vdef (stmt)
416 169088280 : && TREE_CODE (gimple_vdef (stmt)) != SSA_NAME)
417 : {
418 38649900 : fn->gimple_df->rename_vops = 1;
419 38649900 : fn->gimple_df->ssa_renaming_needed = 1;
420 : }
421 382047318 : }
422 :
423 :
424 : /* Takes elements from build_uses and turns them into use operands of STMT. */
425 :
426 : inline void
427 382047318 : operands_scanner::finalize_ssa_uses ()
428 : {
429 382047318 : unsigned new_i;
430 382047318 : struct use_optype_d new_list;
431 382047318 : use_optype_p old_ops, ptr, last;
432 :
433 : /* Pre-pend the VUSE we may have built. */
434 382047318 : if (build_vuse != NULL_TREE)
435 : {
436 93271820 : tree oldvuse = gimple_vuse (stmt);
437 93271820 : if (oldvuse
438 36515342 : && TREE_CODE (oldvuse) == SSA_NAME)
439 93271820 : oldvuse = SSA_NAME_VAR (oldvuse);
440 93271820 : if (oldvuse != (build_vuse != NULL_TREE
441 : ? build_vuse : build_vdef))
442 56756478 : gimple_set_vuse (stmt, NULL_TREE);
443 186543640 : build_uses.safe_insert (0, gimple_vuse_ptr (stmt));
444 : }
445 :
446 382047318 : new_list.next = NULL;
447 382047318 : last = &new_list;
448 :
449 382047318 : old_ops = gimple_use_ops (stmt);
450 :
451 : /* Clear a no longer necessary VUSE. */
452 382047318 : if (build_vuse == NULL_TREE
453 457863778 : && gimple_vuse (stmt) != NULL_TREE)
454 6593884 : gimple_set_vuse (stmt, NULL_TREE);
455 :
456 : /* If there is anything in the old list, free it. */
457 382047318 : if (old_ops)
458 : {
459 139935572 : for (ptr = old_ops; ptr->next; ptr = ptr->next)
460 42009647 : delink_imm_use (USE_OP_PTR (ptr));
461 97925925 : delink_imm_use (USE_OP_PTR (ptr));
462 97925925 : ptr->next = gimple_ssa_operands (fn)->free_uses;
463 97925925 : 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 382047318 : if (build_vuse != NULL_TREE
469 475319138 : && gimple_vuse (stmt) == NULL_TREE)
470 : {
471 56756478 : gimple_set_vuse (stmt, gimple_vop (fn));
472 56756478 : fn->gimple_df->rename_vops = 1;
473 56756478 : fn->gimple_df->ssa_renaming_needed = 1;
474 : }
475 :
476 : /* Now create nodes for all the new nodes. */
477 695046131 : for (new_i = 0; new_i < build_uses.length (); new_i++)
478 : {
479 312998813 : tree *op = build_uses[new_i];
480 312998813 : last = add_use_op (fn, stmt, op, last);
481 : }
482 :
483 : /* Now set the stmt's operands. */
484 382047318 : gimple_set_use_ops (stmt, new_list.next);
485 382047318 : }
486 :
487 :
488 : /* Clear the in_list bits and empty the build array for VDEFs and
489 : VUSEs. */
490 :
491 : inline void
492 11309753881 : operands_scanner::cleanup_build_arrays ()
493 : {
494 11309753881 : build_vdef = NULL_TREE;
495 11309753881 : build_vuse = NULL_TREE;
496 11309753881 : build_uses.truncate (0);
497 : }
498 :
499 :
500 : /* Finalize all the build vectors, fill the new ones into INFO. */
501 :
502 : inline void
503 382047318 : operands_scanner::finalize_ssa_stmt_operands ()
504 : {
505 382047318 : finalize_ssa_defs ();
506 382047318 : finalize_ssa_uses ();
507 382047318 : cleanup_build_arrays ();
508 382047318 : }
509 :
510 :
511 : /* Start the process of building up operands vectors in INFO. */
512 :
513 : inline void
514 11309753881 : operands_scanner::start_ssa_stmt_operands ()
515 : {
516 11309753881 : gcc_assert (build_uses.length () == 0);
517 11309753881 : gcc_assert (build_vuse == NULL_TREE);
518 11309753881 : gcc_assert (build_vdef == NULL_TREE);
519 11309753881 : }
520 :
521 :
522 : /* Add USE_P to the list of pointers to operands. */
523 :
524 : inline void
525 5647197570 : operands_scanner::append_use (tree *use_p)
526 : {
527 5647197570 : 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 1935907687 : operands_scanner::append_vdef (tree var)
535 : {
536 1935907687 : gcc_assert ((build_vdef == NULL_TREE
537 : || build_vdef == var)
538 : && (build_vuse == NULL_TREE
539 : || build_vuse == var));
540 :
541 1935907687 : build_vdef = var;
542 1935907687 : build_vuse = var;
543 1935907687 : }
544 :
545 :
546 : /* Add VAR to the set of variables that require a VUSE operator. */
547 :
548 : inline void
549 1357223915 : operands_scanner::append_vuse (tree var)
550 : {
551 1357223915 : gcc_assert (build_vuse == NULL_TREE
552 : || build_vuse == var);
553 :
554 1357223915 : build_vuse = var;
555 1357223915 : }
556 :
557 : /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */
558 :
559 : void
560 3483146903 : 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 3483146903 : if (flags & opf_no_vops)
566 : return;
567 :
568 3104381113 : gcc_assert (!is_gimple_debug (stmt));
569 :
570 3104381113 : if (flags & opf_def)
571 1935907687 : append_vdef (gimple_vop (fn));
572 : else
573 1168473426 : 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 9688480071 : operands_scanner::add_stmt_operand (tree *var_p, int flags)
584 : {
585 9688480071 : tree var = *var_p;
586 :
587 9688480071 : gcc_assert (SSA_VAR_P (*var_p)
588 : || TREE_CODE (*var_p) == STRING_CST
589 : || TREE_CODE (*var_p) == CONST_DECL);
590 :
591 9688480071 : if (is_gimple_reg (var))
592 : {
593 : /* The variable is a GIMPLE register. Add it to real operands. */
594 8330028458 : if (flags & opf_def)
595 : ;
596 : else
597 5647197570 : append_use (var_p);
598 8330028458 : if (DECL_P (*var_p))
599 67653411 : fn->gimple_df->ssa_renaming_needed = 1;
600 : }
601 : else
602 : {
603 : /* Mark statements with volatile operands. */
604 1358451613 : if (!(flags & opf_no_vops)
605 1343297999 : && TREE_THIS_VOLATILE (var))
606 60980599 : gimple_set_has_volatile_ops (stmt, true);
607 :
608 : /* The variable is a memory access. Add virtual operands. */
609 1358451613 : add_virtual_operand (flags);
610 : }
611 9688480071 : }
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 1521604484 : mark_address_taken (tree ref)
620 : {
621 1521604484 : 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 1521604484 : var = get_base_address (ref);
629 1521604484 : if (VAR_P (var)
630 : || TREE_CODE (var) == RESULT_DECL
631 : || TREE_CODE (var) == PARM_DECL)
632 474089780 : TREE_ADDRESSABLE (var) = 1;
633 1521604484 : }
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 1351067397 : operands_scanner::get_mem_ref_operands (tree expr, int flags)
645 : {
646 1351067397 : tree *pptr = &TREE_OPERAND (expr, 0);
647 :
648 1351067397 : if (!(flags & opf_no_vops)
649 987571101 : && TREE_THIS_VOLATILE (expr))
650 1189936 : gimple_set_has_volatile_ops (stmt, true);
651 :
652 : /* Add the VOP. */
653 1351067397 : add_virtual_operand (flags);
654 :
655 : /* If requested, add a USE operand for the base pointer. */
656 1351067397 : get_expr_operands (pptr,
657 : opf_non_addressable | opf_use
658 1351067397 : | (flags & (opf_no_vops|opf_not_non_addressable)));
659 1351067397 : }
660 :
661 :
662 : /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
663 :
664 : void
665 30701032 : operands_scanner::get_tmr_operands(tree expr, int flags)
666 : {
667 30701032 : if (!(flags & opf_no_vops)
668 30585152 : && TREE_THIS_VOLATILE (expr))
669 0 : gimple_set_has_volatile_ops (stmt, true);
670 :
671 : /* First record the real operands. */
672 30701032 : get_expr_operands (&TMR_BASE (expr),
673 : opf_non_addressable | opf_use
674 30701032 : | (flags & (opf_no_vops|opf_not_non_addressable)));
675 30701032 : get_expr_operands (&TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
676 30701032 : get_expr_operands (&TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
677 :
678 30701032 : add_virtual_operand (flags);
679 30701032 : }
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 808022638 : operands_scanner::maybe_add_call_vops (gcall *stmt)
687 : {
688 808022638 : 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 808022638 : if (!(call_flags & ECF_NOVOPS))
694 : {
695 : /* A 'pure' or a 'const' function never call-clobbers anything. */
696 807375323 : if (!(call_flags & (ECF_PURE | ECF_CONST)))
697 676159076 : add_virtual_operand (opf_def);
698 131216247 : else if (!(call_flags & ECF_CONST))
699 62472297 : add_virtual_operand (opf_use);
700 : }
701 808022638 : }
702 :
703 :
704 : /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
705 :
706 : void
707 11278323 : operands_scanner::get_asm_stmt_operands (gasm *stmt)
708 : {
709 11278323 : size_t i, noutputs;
710 11278323 : const char **oconstraints;
711 11278323 : const char *constraint;
712 11278323 : bool allows_mem, allows_reg, is_inout;
713 :
714 11278323 : noutputs = gimple_asm_noutputs (stmt);
715 11278323 : oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
716 :
717 : /* Gather all output operands. */
718 20942563 : for (i = 0; i < gimple_asm_noutputs (stmt); i++)
719 : {
720 9664240 : tree link = gimple_asm_output_op (stmt, i);
721 9664240 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
722 9664240 : oconstraints[i] = constraint;
723 9664240 : 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 9664240 : gcc_assert (!allows_reg || !is_inout);
728 :
729 : /* Memory operands are addressable. Note that STMT needs the
730 : address of this operand. */
731 9664240 : if (!allows_reg && allows_mem)
732 672902 : mark_address_taken (TREE_VALUE (link));
733 :
734 9664240 : get_expr_operands (&TREE_VALUE (link), opf_def | opf_not_non_addressable);
735 : }
736 :
737 : /* Gather all input operands. */
738 17742757 : for (i = 0; i < gimple_asm_ninputs (stmt); i++)
739 : {
740 6464434 : tree link = gimple_asm_input_op (stmt, i);
741 6464434 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
742 6464434 : 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 6464434 : if (!allows_reg && allows_mem)
748 727528 : mark_address_taken (TREE_VALUE (link));
749 :
750 6464434 : get_expr_operands (&TREE_VALUE (link), opf_not_non_addressable);
751 : }
752 :
753 : /* Clobber all memory and addressable symbols for asm ("" : : : "memory"); */
754 11278323 : if (gimple_asm_clobbers_memory_p (stmt))
755 4272556 : add_virtual_operand (opf_def);
756 11278323 : }
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 22338388322 : operands_scanner::get_expr_operands (tree *expr_p, int flags)
765 : {
766 27479759928 : enum tree_code code;
767 27479759928 : enum tree_code_class codeclass;
768 27479759928 : tree expr = *expr_p;
769 27479759928 : int uflags = opf_use;
770 :
771 27479759928 : if (expr == NULL)
772 : return;
773 :
774 21842584955 : if (is_gimple_debug (stmt))
775 4179510507 : uflags |= (flags & opf_no_vops);
776 :
777 21842584955 : code = TREE_CODE (expr);
778 21842584955 : codeclass = TREE_CODE_CLASS (code);
779 :
780 21842584955 : switch (code)
781 : {
782 2645543088 : 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 2645543088 : if ((!(flags & opf_non_addressable)
788 427831715 : || (flags & opf_not_non_addressable))
789 2751983479 : && !is_gimple_debug (stmt))
790 1520204054 : 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 2645543088 : flags |= opf_no_vops;
798 2645543088 : get_expr_operands (&TREE_OPERAND (expr, 0),
799 : flags | opf_not_non_addressable | opf_address_taken);
800 2645543088 : return;
801 :
802 11205672648 : case SSA_NAME:
803 11205672648 : case VAR_DECL:
804 11205672648 : case PARM_DECL:
805 11205672648 : case RESULT_DECL:
806 11205672648 : case STRING_CST:
807 11205672648 : case CONST_DECL:
808 11205672648 : if (!(flags & opf_address_taken))
809 9688480071 : add_stmt_operand (expr_p, flags);
810 : return;
811 :
812 : case OMP_NEXT_VARIANT:
813 : case OMP_TARGET_DEVICE_MATCHES:
814 : return;
815 :
816 558453275 : case DEBUG_EXPR_DECL:
817 558453275 : gcc_assert (gimple_debug_bind_p (stmt));
818 : return;
819 :
820 1351067397 : case MEM_REF:
821 1351067397 : get_mem_ref_operands (expr, flags);
822 1351067397 : return;
823 :
824 30701032 : case TARGET_MEM_REF:
825 30701032 : get_tmr_operands (expr, flags);
826 30701032 : return;
827 :
828 2403624155 : case ARRAY_REF:
829 2403624155 : case ARRAY_RANGE_REF:
830 2403624155 : case COMPONENT_REF:
831 2403624155 : case REALPART_EXPR:
832 2403624155 : case IMAGPART_EXPR:
833 2403624155 : {
834 2403624155 : if (!(flags & opf_no_vops)
835 1749792711 : && TREE_THIS_VOLATILE (expr))
836 5431617 : gimple_set_has_volatile_ops (stmt, true);
837 :
838 2403624155 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
839 :
840 2403624155 : if (code == COMPONENT_REF)
841 2005079834 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
842 398544321 : else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
843 : {
844 370802907 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
845 370802907 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
846 370802907 : 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 1218203 : case COND_EXPR:
860 1218203 : case VEC_COND_EXPR:
861 1218203 : case VEC_PERM_EXPR:
862 1218203 : get_expr_operands (&TREE_OPERAND (expr, 0), uflags);
863 1218203 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
864 1218203 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
865 1218203 : return;
866 :
867 242222993 : case CONSTRUCTOR:
868 242222993 : {
869 : /* General aggregate CONSTRUCTORs have been decomposed, but they
870 : are still in use as the COMPLEX_EXPR equivalent for vectors. */
871 242222993 : constructor_elt *ce;
872 242222993 : 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 242222993 : if (!(flags & opf_no_vops)
878 242216583 : && TREE_THIS_VOLATILE (expr))
879 216226035 : gimple_set_has_volatile_ops (stmt, true);
880 :
881 19815155 : for (idx = 0;
882 262038148 : vec_safe_iterate (CONSTRUCTOR_ELTS (expr), idx, &ce);
883 : idx++)
884 19815155 : get_expr_operands (&ce->value, uflags);
885 :
886 : return;
887 : }
888 :
889 13651661 : case BIT_FIELD_REF:
890 13651661 : if (!(flags & opf_no_vops)
891 13054698 : && TREE_THIS_VOLATILE (expr))
892 850 : gimple_set_has_volatile_ops (stmt, true);
893 : /* FALLTHRU */
894 :
895 72109827 : case VIEW_CONVERT_EXPR:
896 72109827 : do_unary:
897 72109827 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
898 72109827 : return;
899 :
900 46601976 : case BIT_INSERT_EXPR:
901 46601976 : case COMPOUND_EXPR:
902 46601976 : case OBJ_TYPE_REF:
903 46601976 : do_binary:
904 46601976 : {
905 46601976 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
906 46601976 : get_expr_operands (&TREE_OPERAND (expr, 1), flags);
907 46601976 : 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 2416830535 : default:
929 2416830535 : if (codeclass == tcc_unary)
930 19770761 : goto do_unary;
931 2397059774 : if (codeclass == tcc_binary || codeclass == tcc_comparison)
932 37634741 : goto do_binary;
933 2359425033 : 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 11309753881 : operands_scanner::parse_ssa_operands ()
953 : {
954 11309753881 : enum gimple_code code = gimple_code (stmt);
955 11309753881 : size_t i, n, start = 0;
956 :
957 11309753881 : switch (code)
958 : {
959 11278323 : case GIMPLE_ASM:
960 11278323 : get_asm_stmt_operands (as_a <gasm *> (stmt));
961 11278323 : 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 5900594818 : case GIMPLE_DEBUG:
969 5900594818 : if (gimple_debug_bind_p (stmt)
970 5900594818 : && gimple_debug_bind_has_value_p (stmt))
971 2531974075 : get_expr_operands (gimple_debug_bind_get_value_ptr (stmt),
972 : opf_use | opf_no_vops);
973 : break;
974 :
975 188750489 : case GIMPLE_RETURN:
976 188750489 : append_vuse (gimple_vop (fn));
977 188750489 : goto do_default;
978 :
979 808022638 : case GIMPLE_CALL:
980 : /* Add call-clobbered operands, if needed. */
981 808022638 : maybe_add_call_vops (as_a <gcall *> (stmt));
982 : /* FALLTHRU */
983 :
984 4417078654 : case GIMPLE_ASSIGN:
985 4417078654 : get_expr_operands (gimple_op_ptr (stmt, 0), opf_def);
986 4417078654 : start = 1;
987 : /* FALLTHRU */
988 :
989 5397857808 : default:
990 5397857808 : do_default:
991 5397857808 : n = gimple_num_ops (stmt);
992 16113794957 : for (i = start; i < n; i++)
993 10715937149 : get_expr_operands (gimple_op_ptr (stmt, i), opf_use);
994 : break;
995 : }
996 11309753881 : }
997 :
998 :
999 : /* Create an operands cache for STMT. */
1000 :
1001 : void
1002 382047318 : operands_scanner::build_ssa_operands ()
1003 : {
1004 : /* Initially assume that the statement has no volatile operands. */
1005 382047318 : gimple_set_has_volatile_ops (stmt, false);
1006 :
1007 382047318 : start_ssa_stmt_operands ();
1008 382047318 : parse_ssa_operands ();
1009 382047318 : finalize_ssa_stmt_operands ();
1010 382047318 : }
1011 :
1012 : /* Verifies SSA statement operands. */
1013 :
1014 : DEBUG_FUNCTION bool
1015 10927706563 : operands_scanner::verify_ssa_operands ()
1016 : {
1017 10927706563 : use_operand_p use_p;
1018 10927706563 : def_operand_p def_p;
1019 10927706563 : ssa_op_iter iter;
1020 10927706563 : unsigned i;
1021 10927706563 : tree def;
1022 10927706563 : bool volatile_p = gimple_has_volatile_ops (stmt);
1023 :
1024 : /* build_ssa_operands w/o finalizing them. */
1025 10927706563 : gimple_set_has_volatile_ops (stmt, false);
1026 10927706563 : start_ssa_stmt_operands ();
1027 10927706563 : parse_ssa_operands ();
1028 :
1029 : /* Now verify the built operands are the same as present in STMT. */
1030 10927706563 : def = gimple_vdef (stmt);
1031 4448042118 : if (def
1032 1835039568 : && TREE_CODE (def) == SSA_NAME)
1033 10927706563 : def = SSA_NAME_VAR (def);
1034 10927706563 : if (build_vdef != def)
1035 : {
1036 0 : error ("virtual definition of statement not up to date");
1037 0 : return true;
1038 : }
1039 10927706563 : 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 10927706563 : tree use = gimple_vuse (stmt);
1048 4448042118 : if (use
1049 2952075616 : && TREE_CODE (use) == SSA_NAME)
1050 10927706563 : use = SSA_NAME_VAR (use);
1051 10927706563 : if (build_vuse != use)
1052 : {
1053 0 : error ("virtual use of statement not up to date");
1054 0 : return true;
1055 : }
1056 10927706563 : if (gimple_vuse (stmt)
1057 4448042118 : && ((use_p = gimple_vuse_op (stmt)) == NULL_USE_OPERAND_P
1058 2952075616 : || 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 16355177140 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1065 : {
1066 : tree *op;
1067 7118581186 : FOR_EACH_VEC_ELT (build_uses, i, op)
1068 : {
1069 7118581186 : if (use_p->use == op)
1070 : {
1071 5427470577 : build_uses[i] = NULL;
1072 5427470577 : break;
1073 : }
1074 : }
1075 10854941154 : 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 16355177140 : FOR_EACH_VEC_ELT (build_uses, i, op)
1085 5427470577 : 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 15426461108 : 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 10927706563 : cleanup_build_arrays ();
1099 10927706563 : return false;
1100 : }
1101 :
1102 : /* Interface for external use. */
1103 :
1104 : DEBUG_FUNCTION bool
1105 10927706563 : verify_ssa_operands (struct function *fn, gimple *stmt)
1106 : {
1107 10927706563 : 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 2045061 : free_stmt_operands (struct function *fn, gimple *stmt)
1116 : {
1117 2045061 : use_optype_p uses = gimple_use_ops (stmt), last_use;
1118 :
1119 2033820 : 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 2045061 : if (gimple_has_mem_ops (stmt))
1130 : {
1131 1842640 : gimple_set_vuse (stmt, NULL_TREE);
1132 1842640 : gimple_set_vdef (stmt, NULL_TREE);
1133 : }
1134 2045061 : }
1135 :
1136 :
1137 : /* Get the operands of statement STMT. */
1138 :
1139 : void
1140 384220575 : update_stmt_operands (struct function *fn, gimple *stmt)
1141 : {
1142 : /* If update_stmt_operands is called before SSA is initialized, do
1143 : nothing. */
1144 384220575 : if (!ssa_operands_active (fn))
1145 : return;
1146 :
1147 382047318 : timevar_push (TV_TREE_OPS);
1148 :
1149 764094636 : gcc_assert (gimple_modified_p (stmt));
1150 382047318 : operands_scanner (fn, stmt).build_ssa_operands ();
1151 382047318 : gimple_set_modified (stmt, false);
1152 :
1153 382047318 : 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 408308 : swap_ssa_operands (gimple *stmt, tree *exp0, tree *exp1)
1162 : {
1163 408308 : tree op0, op1;
1164 408308 : op0 = *exp0;
1165 408308 : op1 = *exp1;
1166 :
1167 408308 : 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 408308 : use_optype_p use0, use1, ptr;
1173 408308 : use0 = use1 = NULL;
1174 :
1175 : /* Find the 2 operands in the cache, if they are there. */
1176 816733 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1177 408308 : if (USE_OP_PTR (ptr)->use == exp0)
1178 : {
1179 : use0 = ptr;
1180 : break;
1181 : }
1182 :
1183 1224807 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1184 803595 : 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 408308 : if (use0)
1193 408191 : USE_OP_PTR (use0)->use = exp1;
1194 408308 : if (use1)
1195 395404 : USE_OP_PTR (use1)->use = exp0;
1196 :
1197 : /* Now swap the data. */
1198 408308 : *exp0 = op1;
1199 408308 : *exp1 = op0;
1200 : }
1201 408308 : }
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 6203890065 : verify_imm_links (FILE *f, tree var)
1209 : {
1210 6203890065 : use_operand_p ptr, prev, list;
1211 6203890065 : unsigned int count;
1212 :
1213 6203890065 : gcc_assert (TREE_CODE (var) == SSA_NAME);
1214 :
1215 6203890065 : list = &(SSA_NAME_IMM_USE_NODE (var));
1216 6203890065 : gcc_assert (list->use == NULL);
1217 :
1218 6203890065 : if (list->prev == NULL)
1219 : {
1220 0 : gcc_assert (list->next == NULL);
1221 : return false;
1222 : }
1223 :
1224 6203890065 : prev = list;
1225 6203890065 : count = 0;
1226 17190964822 : for (ptr = list->next; ptr != list; )
1227 : {
1228 10987074757 : if (prev != ptr->prev)
1229 : {
1230 0 : fprintf (f, "prev != ptr->prev\n");
1231 0 : goto error;
1232 : }
1233 :
1234 10987074757 : 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 10987074757 : else if (*(ptr->use) != var)
1240 : {
1241 0 : fprintf (f, "*(ptr->use) != var\n");
1242 0 : goto error;
1243 : }
1244 :
1245 10987074757 : prev = ptr;
1246 10987074757 : ptr = ptr->next;
1247 :
1248 10987074757 : count++;
1249 10987074757 : 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 17190964822 : for (ptr = list->prev; ptr != list; )
1259 : {
1260 10987074757 : if (prev != ptr->next)
1261 : {
1262 0 : fprintf (f, "prev != ptr->next\n");
1263 0 : goto error;
1264 : }
1265 10987074757 : prev = ptr;
1266 10987074757 : ptr = ptr->prev;
1267 10987074757 : if (count == 0)
1268 : {
1269 0 : fprintf (f, "count-- < 0\n");
1270 0 : goto error;
1271 : }
1272 10987074757 : count--;
1273 : }
1274 :
1275 6203890065 : 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 55331751 : unlink_stmt_vdef (gimple *stmt)
1369 : {
1370 55331751 : use_operand_p use_p;
1371 55331751 : imm_use_iterator iter;
1372 55331751 : gimple *use_stmt;
1373 55331751 : tree vdef = gimple_vdef (stmt);
1374 55331751 : tree vuse = gimple_vuse (stmt);
1375 :
1376 55331751 : if (!vdef
1377 14977536 : || TREE_CODE (vdef) != SSA_NAME)
1378 41082166 : return;
1379 :
1380 49749806 : FOR_EACH_IMM_USE_STMT (use_stmt, iter, vdef)
1381 : {
1382 65508054 : FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1383 22128709 : SET_USE (use_p, vuse);
1384 14249585 : }
1385 :
1386 14249585 : 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 46224978 : single_imm_use_1 (const ssa_use_operand_t *head,
1395 : use_operand_p *use_p, gimple **stmt)
1396 : {
1397 46224978 : ssa_use_operand_t *ptr, *single_use = 0;
1398 :
1399 100591004 : for (ptr = head->next; ptr != head; ptr = ptr->next)
1400 96170932 : if (USE_STMT(ptr) && !is_gimple_debug (USE_STMT (ptr)))
1401 : {
1402 88024060 : if (single_use)
1403 : {
1404 : single_use = NULL;
1405 : break;
1406 : }
1407 : single_use = ptr;
1408 : }
1409 :
1410 46224978 : if (use_p)
1411 46224978 : *use_p = single_use;
1412 :
1413 46224978 : if (stmt)
1414 46224978 : *stmt = single_use ? single_use->loc.stmt : NULL;
1415 :
1416 46224978 : return single_use;
1417 : }
1418 :
1419 : /* Gather all stmts SSAVAR is used on, eliminating duplicates. */
1420 :
1421 : auto_vec<gimple *, 2>
1422 3197372 : gather_imm_use_stmts (tree ssavar)
1423 : {
1424 3197372 : auto_vec<gimple *, 2> stmts;
1425 3197372 : imm_use_iterator iter;
1426 3197372 : use_operand_p use_p;
1427 13667238 : FOR_EACH_IMM_USE_FAST (use_p, iter, ssavar)
1428 : {
1429 7272494 : gimple *use_stmt = USE_STMT (use_p);
1430 7272494 : if (use_stmt->ilf)
1431 46248 : continue;
1432 7226246 : use_stmt->ilf = 1;
1433 7226246 : stmts.safe_push (use_stmt);
1434 3197372 : }
1435 16818362 : for (gimple *use_stmt : stmts)
1436 7226246 : use_stmt->ilf = 0;
1437 3197372 : return stmts;
1438 : }
|
