Branch data Line data Source code
1 : : /* SSA operands management for trees.
2 : : Copyright (C) 2003-2025 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 : 20790266850 : class operands_scanner
105 : : {
106 : : public:
107 : 10395133425 : operands_scanner (struct function *fun, gimple *statement)
108 : 10395133425 : {
109 : 10395133425 : build_vuse = NULL_TREE;
110 : 10395133425 : build_vdef = NULL_TREE;
111 : 10395133425 : fn = fun;
112 : 10395133425 : 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 : 724857372 : gimple_ssa_operands (const struct function *fun)
211 : : {
212 : 724857372 : return &fun->gimple_df->ssa_operands;
213 : : }
214 : :
215 : :
216 : : /* Return true if the SSA operands cache is active. */
217 : :
218 : : bool
219 : 731136323 : ssa_operands_active (struct function *fun)
220 : : {
221 : 731136323 : if (fun == NULL)
222 : : return false;
223 : :
224 : 731136323 : 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 : 3053061 : create_vop_var (struct function *fn)
233 : : {
234 : 3053061 : tree global_var;
235 : :
236 : 3053061 : gcc_assert (fn->gimple_df->vop == NULL_TREE);
237 : :
238 : 3053061 : global_var = build_decl (BUILTINS_LOCATION, VAR_DECL,
239 : : get_identifier (".MEM"),
240 : : void_type_node);
241 : 3053061 : DECL_ARTIFICIAL (global_var) = 1;
242 : 3053061 : DECL_IGNORED_P (global_var) = 1;
243 : 3053061 : TREE_READONLY (global_var) = 0;
244 : 3053061 : DECL_EXTERNAL (global_var) = 1;
245 : 3053061 : TREE_STATIC (global_var) = 1;
246 : 3053061 : TREE_USED (global_var) = 1;
247 : 3053061 : DECL_CONTEXT (global_var) = NULL_TREE;
248 : 3053061 : TREE_THIS_VOLATILE (global_var) = 0;
249 : 3053061 : TREE_ADDRESSABLE (global_var) = 0;
250 : 3053061 : VAR_DECL_IS_VIRTUAL_OPERAND (global_var) = 1;
251 : :
252 : 3053061 : fn->gimple_df->vop = global_var;
253 : 3053061 : }
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 : 3053061 : init_ssa_operands (struct function *fn)
271 : : {
272 : 3053061 : gcc_assert (gimple_ssa_operands (fn)->operand_memory == NULL);
273 : 3053061 : gimple_ssa_operands (fn)->operand_memory_index
274 : 3053061 : = gimple_ssa_operands (fn)->ssa_operand_mem_size;
275 : 3053061 : gimple_ssa_operands (fn)->ops_active = true;
276 : 3053061 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_INIT;
277 : 3053061 : create_vop_var (fn);
278 : 3053061 : }
279 : :
280 : :
281 : : /* Dispose of anything required by the operand routines. */
282 : :
283 : : void
284 : 2996600 : fini_ssa_operands (struct function *fn)
285 : : {
286 : 2996600 : struct ssa_operand_memory_d *ptr;
287 : :
288 : 2996600 : gimple_ssa_operands (fn)->free_uses = NULL;
289 : :
290 : 7276033 : while ((ptr = gimple_ssa_operands (fn)->operand_memory) != NULL)
291 : : {
292 : 4279433 : gimple_ssa_operands (fn)->operand_memory
293 : 4279433 : = gimple_ssa_operands (fn)->operand_memory->next;
294 : 4279433 : ggc_free (ptr);
295 : : }
296 : :
297 : 2996600 : gimple_ssa_operands (fn)->ops_active = false;
298 : :
299 : 2996600 : fn->gimple_df->vop = NULL_TREE;
300 : 2996600 : }
301 : :
302 : :
303 : : /* Return memory for an operand of size SIZE. */
304 : :
305 : : static inline void *
306 : 165309636 : ssa_operand_alloc (struct function *fn, unsigned size)
307 : : {
308 : 165309636 : char *ptr;
309 : :
310 : 165309636 : gcc_assert (size == sizeof (struct use_optype_d));
311 : :
312 : 165309636 : if (gimple_ssa_operands (fn)->operand_memory_index + size
313 : 165309636 : >= gimple_ssa_operands (fn)->ssa_operand_mem_size)
314 : : {
315 : 4344479 : struct ssa_operand_memory_d *ptr;
316 : :
317 : 4344479 : switch (gimple_ssa_operands (fn)->ssa_operand_mem_size)
318 : : {
319 : 3051230 : case OP_SIZE_INIT:
320 : 3051230 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_1;
321 : 3051230 : break;
322 : 949645 : case OP_SIZE_1:
323 : 949645 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_2;
324 : 949645 : break;
325 : 343604 : case OP_SIZE_2:
326 : 343604 : case OP_SIZE_3:
327 : 343604 : gimple_ssa_operands (fn)->ssa_operand_mem_size = OP_SIZE_3;
328 : 343604 : break;
329 : 0 : default:
330 : 0 : gcc_unreachable ();
331 : : }
332 : :
333 : :
334 : 4344479 : ptr = (ssa_operand_memory_d *) ggc_internal_alloc
335 : 4344479 : (sizeof (void *) + gimple_ssa_operands (fn)->ssa_operand_mem_size);
336 : :
337 : 4344479 : ptr->next = gimple_ssa_operands (fn)->operand_memory;
338 : 4344479 : gimple_ssa_operands (fn)->operand_memory = ptr;
339 : 4344479 : gimple_ssa_operands (fn)->operand_memory_index = 0;
340 : : }
341 : :
342 : 165309636 : ptr = &(gimple_ssa_operands (fn)->operand_memory
343 : 165309636 : ->mem[gimple_ssa_operands (fn)->operand_memory_index]);
344 : 165309636 : gimple_ssa_operands (fn)->operand_memory_index += size;
345 : 165309636 : return ptr;
346 : : }
347 : :
348 : :
349 : : /* Allocate a USE operand. */
350 : :
351 : : static inline struct use_optype_d *
352 : 287871380 : alloc_use (struct function *fn)
353 : : {
354 : 287871380 : struct use_optype_d *ret;
355 : 287871380 : if (gimple_ssa_operands (fn)->free_uses)
356 : : {
357 : 122561744 : ret = gimple_ssa_operands (fn)->free_uses;
358 : 122561744 : gimple_ssa_operands (fn)->free_uses
359 : 122561744 : = gimple_ssa_operands (fn)->free_uses->next;
360 : : }
361 : : else
362 : 165309636 : ret = (struct use_optype_d *)
363 : 165309636 : ssa_operand_alloc (fn, sizeof (struct use_optype_d));
364 : 287871380 : 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 : 287871380 : add_use_op (struct function *fn, gimple *stmt, tree *op, use_optype_p last)
372 : : {
373 : 287871380 : use_optype_p new_use;
374 : :
375 : 287871380 : new_use = alloc_use (fn);
376 : 287871380 : USE_OP_PTR (new_use)->use = op;
377 : 287871380 : link_imm_use_stmt (USE_OP_PTR (new_use), *op, stmt);
378 : 287871380 : last->next = new_use;
379 : 287871380 : new_use->next = NULL;
380 : 287871380 : 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 : 334439543 : operands_scanner::finalize_ssa_defs ()
390 : : {
391 : : /* Pre-pend the vdef we may have built. */
392 : 334439543 : if (build_vdef != NULL_TREE)
393 : : {
394 : 51718519 : tree oldvdef = gimple_vdef (stmt);
395 : 51718519 : if (oldvdef
396 : 18295122 : && TREE_CODE (oldvdef) == SSA_NAME)
397 : 15575367 : oldvdef = SSA_NAME_VAR (oldvdef);
398 : 51718519 : if (oldvdef != build_vdef)
399 : 33423397 : gimple_set_vdef (stmt, build_vdef);
400 : : }
401 : :
402 : : /* Clear and unlink a no longer necessary VDEF. */
403 : 334439543 : if (build_vdef == NULL_TREE
404 : 441468696 : && gimple_vdef (stmt) != NULL_TREE)
405 : : {
406 : 3899995 : if (TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
407 : : {
408 : 3785401 : unlink_stmt_vdef (stmt);
409 : 7570802 : release_ssa_name_fn (fn, gimple_vdef (stmt));
410 : : }
411 : 3899995 : gimple_set_vdef (stmt, NULL_TREE);
412 : : }
413 : :
414 : : /* If we have a non-SSA_NAME VDEF, mark it for renaming. */
415 : 334439543 : if (gimple_vdef (stmt)
416 : 158747672 : && TREE_CODE (gimple_vdef (stmt)) != SSA_NAME)
417 : : {
418 : 36143152 : fn->gimple_df->rename_vops = 1;
419 : 36143152 : fn->gimple_df->ssa_renaming_needed = 1;
420 : : }
421 : 334439543 : }
422 : :
423 : :
424 : : /* Takes elements from build_uses and turns them into use operands of STMT. */
425 : :
426 : : inline void
427 : 334439543 : operands_scanner::finalize_ssa_uses ()
428 : : {
429 : 334439543 : unsigned new_i;
430 : 334439543 : struct use_optype_d new_list;
431 : 334439543 : use_optype_p old_ops, ptr, last;
432 : :
433 : : /* Pre-pend the VUSE we may have built. */
434 : 334439543 : if (build_vuse != NULL_TREE)
435 : : {
436 : 85999168 : tree oldvuse = gimple_vuse (stmt);
437 : 85999168 : if (oldvuse
438 : 32263269 : && TREE_CODE (oldvuse) == SSA_NAME)
439 : 26903348 : oldvuse = SSA_NAME_VAR (oldvuse);
440 : 85999168 : if (oldvuse != (build_vuse != NULL_TREE
441 : : ? build_vuse : build_vdef))
442 : 53735899 : gimple_set_vuse (stmt, NULL_TREE);
443 : 171998336 : build_uses.safe_insert (0, gimple_vuse_ptr (stmt));
444 : : }
445 : :
446 : 334439543 : new_list.next = NULL;
447 : 334439543 : last = &new_list;
448 : :
449 : 334439543 : old_ops = gimple_use_ops (stmt);
450 : :
451 : : /* Clear a no longer necessary VUSE. */
452 : 334439543 : if (build_vuse == NULL_TREE
453 : 407188047 : && gimple_vuse (stmt) != NULL_TREE)
454 : 6145957 : gimple_set_vuse (stmt, NULL_TREE);
455 : :
456 : : /* If there is anything in the old list, free it. */
457 : 334439543 : if (old_ops)
458 : : {
459 : 127852613 : for (ptr = old_ops; ptr->next; ptr = ptr->next)
460 : 127852613 : delink_imm_use (USE_OP_PTR (ptr));
461 : 88690914 : delink_imm_use (USE_OP_PTR (ptr));
462 : 88690914 : ptr->next = gimple_ssa_operands (fn)->free_uses;
463 : 88690914 : 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 : 334439543 : if (build_vuse != NULL_TREE
469 : 420438711 : && gimple_vuse (stmt) == NULL_TREE)
470 : : {
471 : 53735899 : gimple_set_vuse (stmt, gimple_vop (fn));
472 : 53735899 : fn->gimple_df->rename_vops = 1;
473 : 53735899 : fn->gimple_df->ssa_renaming_needed = 1;
474 : : }
475 : :
476 : : /* Now create nodes for all the new nodes. */
477 : 622310923 : for (new_i = 0; new_i < build_uses.length (); new_i++)
478 : : {
479 : 287871380 : tree *op = build_uses[new_i];
480 : 287871380 : last = add_use_op (fn, stmt, op, last);
481 : : }
482 : :
483 : : /* Now set the stmt's operands. */
484 : 334439543 : gimple_set_use_ops (stmt, new_list.next);
485 : 334439543 : }
486 : :
487 : :
488 : : /* Clear the in_list bits and empty the build array for VDEFs and
489 : : VUSEs. */
490 : :
491 : : inline void
492 : 10395133425 : operands_scanner::cleanup_build_arrays ()
493 : : {
494 : 10395133425 : build_vdef = NULL_TREE;
495 : 10395133425 : build_vuse = NULL_TREE;
496 : 10395133425 : build_uses.truncate (0);
497 : : }
498 : :
499 : :
500 : : /* Finalize all the build vectors, fill the new ones into INFO. */
501 : :
502 : : inline void
503 : 334439543 : operands_scanner::finalize_ssa_stmt_operands ()
504 : : {
505 : 334439543 : finalize_ssa_defs ();
506 : 334439543 : finalize_ssa_uses ();
507 : 334439543 : cleanup_build_arrays ();
508 : 334439543 : }
509 : :
510 : :
511 : : /* Start the process of building up operands vectors in INFO. */
512 : :
513 : : inline void
514 : 10395133425 : operands_scanner::start_ssa_stmt_operands ()
515 : : {
516 : 10395133425 : gcc_assert (build_uses.length () == 0);
517 : 10395133425 : gcc_assert (build_vuse == NULL_TREE);
518 : 10395133425 : gcc_assert (build_vdef == NULL_TREE);
519 : 10395133425 : }
520 : :
521 : :
522 : : /* Add USE_P to the list of pointers to operands. */
523 : :
524 : : inline void
525 : 5297434353 : operands_scanner::append_use (tree *use_p)
526 : : {
527 : 5297434353 : 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 : 1878534217 : operands_scanner::append_vdef (tree var)
535 : : {
536 : 1878534217 : gcc_assert ((build_vdef == NULL_TREE
537 : : || build_vdef == var)
538 : : && (build_vuse == NULL_TREE
539 : : || build_vuse == var));
540 : :
541 : 1878534217 : build_vdef = var;
542 : 1878534217 : build_vuse = var;
543 : 1878534217 : }
544 : :
545 : :
546 : : /* Add VAR to the set of variables that require a VUSE operator. */
547 : :
548 : : inline void
549 : 1317644013 : operands_scanner::append_vuse (tree var)
550 : : {
551 : 1317644013 : gcc_assert (build_vuse == NULL_TREE
552 : : || build_vuse == var);
553 : :
554 : 1317644013 : build_vuse = var;
555 : 1317644013 : }
556 : :
557 : : /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */
558 : :
559 : : void
560 : 3351837903 : 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 : 3351837903 : if (flags & opf_no_vops)
566 : : return;
567 : :
568 : 3013064455 : gcc_assert (!is_gimple_debug (stmt));
569 : :
570 : 3013064455 : if (flags & opf_def)
571 : 1878534217 : append_vdef (gimple_vop (fn));
572 : : else
573 : 1134530238 : 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 : 9236136892 : operands_scanner::add_stmt_operand (tree *var_p, int flags)
584 : : {
585 : 9236136892 : tree var = *var_p;
586 : :
587 : 9236136892 : gcc_assert (SSA_VAR_P (*var_p)
588 : : || TREE_CODE (*var_p) == STRING_CST
589 : : || TREE_CODE (*var_p) == CONST_DECL);
590 : :
591 : 9236136892 : if (is_gimple_reg (var))
592 : : {
593 : : /* The variable is a GIMPLE register. Add it to real operands. */
594 : 7879500344 : if (flags & opf_def)
595 : : ;
596 : : else
597 : 5297434353 : append_use (var_p);
598 : 7879500344 : if (DECL_P (*var_p))
599 : 66449328 : fn->gimple_df->ssa_renaming_needed = 1;
600 : : }
601 : : else
602 : : {
603 : : /* Mark statements with volatile operands. */
604 : 1356636548 : if (!(flags & opf_no_vops)
605 : 1343736533 : && TREE_THIS_VOLATILE (var))
606 : 61157348 : gimple_set_has_volatile_ops (stmt, true);
607 : :
608 : : /* The variable is a memory access. Add virtual operands. */
609 : 1356636548 : add_virtual_operand (flags);
610 : : }
611 : 9236136892 : }
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 : 1461441165 : mark_address_taken (tree ref)
620 : : {
621 : 1461441165 : 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 : 1461441165 : var = get_base_address (ref);
629 : 1461441165 : if (VAR_P (var)
630 : : || TREE_CODE (var) == RESULT_DECL
631 : : || TREE_CODE (var) == PARM_DECL)
632 : 462142594 : TREE_ADDRESSABLE (var) = 1;
633 : 1461441165 : }
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 : 1247225066 : operands_scanner::get_mem_ref_operands (tree expr, int flags)
645 : : {
646 : 1247225066 : tree *pptr = &TREE_OPERAND (expr, 0);
647 : :
648 : 1247225066 : if (!(flags & opf_no_vops)
649 : 921438627 : && TREE_THIS_VOLATILE (expr))
650 : 1092598 : gimple_set_has_volatile_ops (stmt, true);
651 : :
652 : : /* Add the VOP. */
653 : 1247225066 : add_virtual_operand (flags);
654 : :
655 : : /* If requested, add a USE operand for the base pointer. */
656 : 1247225066 : get_expr_operands (pptr,
657 : : opf_non_addressable | opf_use
658 : 1247225066 : | (flags & (opf_no_vops|opf_not_non_addressable)));
659 : 1247225066 : }
660 : :
661 : :
662 : : /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
663 : :
664 : : void
665 : 28976048 : operands_scanner::get_tmr_operands(tree expr, int flags)
666 : : {
667 : 28976048 : if (!(flags & opf_no_vops)
668 : 28889054 : && TREE_THIS_VOLATILE (expr))
669 : 0 : gimple_set_has_volatile_ops (stmt, true);
670 : :
671 : : /* First record the real operands. */
672 : 28976048 : get_expr_operands (&TMR_BASE (expr),
673 : : opf_non_addressable | opf_use
674 : 28976048 : | (flags & (opf_no_vops|opf_not_non_addressable)));
675 : 28976048 : get_expr_operands (&TMR_INDEX (expr), opf_use | (flags & opf_no_vops));
676 : 28976048 : get_expr_operands (&TMR_INDEX2 (expr), opf_use | (flags & opf_no_vops));
677 : :
678 : 28976048 : add_virtual_operand (flags);
679 : 28976048 : }
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 : 773918374 : operands_scanner::maybe_add_call_vops (gcall *stmt)
687 : : {
688 : 773918374 : 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 : 773918374 : if (!(call_flags & ECF_NOVOPS))
694 : : {
695 : : /* A 'pure' or a 'const' function never call-clobbers anything. */
696 : 773291191 : if (!(call_flags & (ECF_PURE | ECF_CONST)))
697 : 653694337 : add_virtual_operand (opf_def);
698 : 119596854 : else if (!(call_flags & ECF_CONST))
699 : 61084943 : add_virtual_operand (opf_use);
700 : : }
701 : 773918374 : }
702 : :
703 : :
704 : : /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
705 : :
706 : : void
707 : 10887432 : operands_scanner::get_asm_stmt_operands (gasm *stmt)
708 : : {
709 : 10887432 : size_t i, noutputs;
710 : 10887432 : const char **oconstraints;
711 : 10887432 : const char *constraint;
712 : 10887432 : bool allows_mem, allows_reg, is_inout;
713 : :
714 : 10887432 : noutputs = gimple_asm_noutputs (stmt);
715 : 10887432 : oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
716 : :
717 : : /* Gather all output operands. */
718 : 19906238 : for (i = 0; i < gimple_asm_noutputs (stmt); i++)
719 : : {
720 : 9018806 : tree link = gimple_asm_output_op (stmt, i);
721 : 9018806 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
722 : 9018806 : oconstraints[i] = constraint;
723 : 9018806 : parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
724 : : &allows_reg, &is_inout);
725 : :
726 : : /* This should have been split in gimplify_asm_expr. */
727 : 9018806 : gcc_assert (!allows_reg || !is_inout);
728 : :
729 : : /* Memory operands are addressable. Note that STMT needs the
730 : : address of this operand. */
731 : 9018806 : if (!allows_reg && allows_mem)
732 : 506907 : mark_address_taken (TREE_VALUE (link));
733 : :
734 : 9018806 : get_expr_operands (&TREE_VALUE (link), opf_def | opf_not_non_addressable);
735 : : }
736 : :
737 : : /* Gather all input operands. */
738 : 16872276 : for (i = 0; i < gimple_asm_ninputs (stmt); i++)
739 : : {
740 : 5984844 : tree link = gimple_asm_input_op (stmt, i);
741 : 5984844 : constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
742 : 5984844 : parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints,
743 : : &allows_mem, &allows_reg);
744 : :
745 : : /* Memory operands are addressable. Note that STMT needs the
746 : : address of this operand. */
747 : 5984844 : if (!allows_reg && allows_mem)
748 : 564018 : mark_address_taken (TREE_VALUE (link));
749 : :
750 : 5984844 : get_expr_operands (&TREE_VALUE (link), opf_not_non_addressable);
751 : : }
752 : :
753 : : /* Clobber all memory and addressable symbols for asm ("" : : : "memory"); */
754 : 10887432 : if (gimple_asm_clobbers_memory_p (stmt))
755 : 4197839 : add_virtual_operand (opf_def);
756 : 10887432 : }
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 : 21212893454 : operands_scanner::get_expr_operands (tree *expr_p, int flags)
765 : : {
766 : 26082447754 : enum tree_code code;
767 : 26082447754 : enum tree_code_class codeclass;
768 : 26082447754 : tree expr = *expr_p;
769 : 26082447754 : int uflags = opf_use;
770 : :
771 : 26082447754 : if (expr == NULL)
772 : : return;
773 : :
774 : 20653141254 : if (is_gimple_debug (stmt))
775 : 3636162183 : uflags |= (flags & opf_no_vops);
776 : :
777 : 20653141254 : code = TREE_CODE (expr);
778 : 20653141254 : codeclass = TREE_CODE_CLASS (code);
779 : :
780 : 20653141254 : switch (code)
781 : : {
782 : 2433704317 : 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 : 2433704317 : if ((!(flags & opf_non_addressable)
788 : : || (flags & opf_not_non_addressable))
789 : 2433704317 : && !is_gimple_debug (stmt))
790 : 1460370240 : 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 : 2433704317 : flags |= opf_no_vops;
798 : 2433704317 : get_expr_operands (&TREE_OPERAND (expr, 0),
799 : : flags | opf_not_non_addressable | opf_address_taken);
800 : 2433704317 : return;
801 : :
802 : 10605462411 : case SSA_NAME:
803 : 10605462411 : case VAR_DECL:
804 : 10605462411 : case PARM_DECL:
805 : 10605462411 : case RESULT_DECL:
806 : 10605462411 : case STRING_CST:
807 : 10605462411 : case CONST_DECL:
808 : 10605462411 : if (!(flags & opf_address_taken))
809 : 9236136892 : add_stmt_operand (expr_p, flags);
810 : : return;
811 : :
812 : : case OMP_NEXT_VARIANT:
813 : : case OMP_TARGET_DEVICE_MATCHES:
814 : : return;
815 : :
816 : 489147971 : case DEBUG_EXPR_DECL:
817 : 489147971 : gcc_assert (gimple_debug_bind_p (stmt));
818 : : return;
819 : :
820 : 1247225066 : case MEM_REF:
821 : 1247225066 : get_mem_ref_operands (expr, flags);
822 : 1247225066 : return;
823 : :
824 : 28976048 : case TARGET_MEM_REF:
825 : 28976048 : get_tmr_operands (expr, flags);
826 : 28976048 : return;
827 : :
828 : 2354451539 : case ARRAY_REF:
829 : 2354451539 : case ARRAY_RANGE_REF:
830 : 2354451539 : case COMPONENT_REF:
831 : 2354451539 : case REALPART_EXPR:
832 : 2354451539 : case IMAGPART_EXPR:
833 : 2354451539 : {
834 : 2354451539 : if (!(flags & opf_no_vops)
835 : 1767822966 : && TREE_THIS_VOLATILE (expr))
836 : 5191500 : gimple_set_has_volatile_ops (stmt, true);
837 : :
838 : 2354451539 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
839 : :
840 : 2354451539 : if (code == COMPONENT_REF)
841 : 1966604886 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
842 : 387846653 : else if (code == ARRAY_REF || code == ARRAY_RANGE_REF)
843 : : {
844 : 360153122 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
845 : 360153122 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
846 : 360153122 : get_expr_operands (&TREE_OPERAND (expr, 3), uflags);
847 : : }
848 : :
849 : : return;
850 : : }
851 : :
852 : 15805 : 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 : 15805 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
856 : 15805 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
857 : 15805 : return;
858 : :
859 : 1089118 : case COND_EXPR:
860 : 1089118 : case VEC_COND_EXPR:
861 : 1089118 : case VEC_PERM_EXPR:
862 : 1089118 : get_expr_operands (&TREE_OPERAND (expr, 0), uflags);
863 : 1089118 : get_expr_operands (&TREE_OPERAND (expr, 1), uflags);
864 : 1089118 : get_expr_operands (&TREE_OPERAND (expr, 2), uflags);
865 : 1089118 : return;
866 : :
867 : 259868017 : case CONSTRUCTOR:
868 : 259868017 : {
869 : : /* General aggregate CONSTRUCTORs have been decomposed, but they
870 : : are still in use as the COMPLEX_EXPR equivalent for vectors. */
871 : 259868017 : constructor_elt *ce;
872 : 259868017 : 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 : 259868017 : if (!(flags & opf_no_vops)
878 : 259864958 : && TREE_THIS_VOLATILE (expr))
879 : 234566451 : gimple_set_has_volatile_ops (stmt, true);
880 : :
881 : 20006706 : for (idx = 0;
882 : 279874723 : vec_safe_iterate (CONSTRUCTOR_ELTS (expr), idx, &ce);
883 : : idx++)
884 : 20006706 : get_expr_operands (&ce->value, uflags);
885 : :
886 : : return;
887 : : }
888 : :
889 : 11386767 : case BIT_FIELD_REF:
890 : 11386767 : if (!(flags & opf_no_vops)
891 : 11329619 : && TREE_THIS_VOLATILE (expr))
892 : 857 : gimple_set_has_volatile_ops (stmt, true);
893 : : /* FALLTHRU */
894 : :
895 : 66700390 : case VIEW_CONVERT_EXPR:
896 : 66700390 : do_unary:
897 : 66700390 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
898 : 66700390 : return;
899 : :
900 : 41286662 : case BIT_INSERT_EXPR:
901 : 41286662 : case COMPOUND_EXPR:
902 : 41286662 : case OBJ_TYPE_REF:
903 : 41286662 : do_binary:
904 : 41286662 : {
905 : 41286662 : get_expr_operands (&TREE_OPERAND (expr, 0), flags);
906 : 41286662 : get_expr_operands (&TREE_OPERAND (expr, 1), flags);
907 : 41286662 : 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 : 2280397041 : default:
929 : 2280397041 : if (codeclass == tcc_unary)
930 : 17779846 : goto do_unary;
931 : 2262617195 : if (codeclass == tcc_binary || codeclass == tcc_comparison)
932 : 34177704 : goto do_binary;
933 : 2228439491 : 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 : 10395133425 : operands_scanner::parse_ssa_operands ()
953 : : {
954 : 10395133425 : enum gimple_code code = gimple_code (stmt);
955 : 10395133425 : size_t i, n, start = 0;
956 : :
957 : 10395133425 : switch (code)
958 : : {
959 : 10887432 : case GIMPLE_ASM:
960 : 10887432 : get_asm_stmt_operands (as_a <gasm *> (stmt));
961 : 10887432 : break;
962 : :
963 : 23122 : case GIMPLE_TRANSACTION:
964 : : /* The start of a transaction is a memory barrier. */
965 : 23122 : add_virtual_operand (opf_def | opf_use);
966 : 23122 : break;
967 : :
968 : 5183708916 : case GIMPLE_DEBUG:
969 : 5183708916 : if (gimple_debug_bind_p (stmt)
970 : 5183708916 : && gimple_debug_bind_has_value_p (stmt))
971 : 2203648351 : get_expr_operands (gimple_debug_bind_get_value_ptr (stmt),
972 : : opf_use | opf_no_vops);
973 : : break;
974 : :
975 : 183113775 : case GIMPLE_RETURN:
976 : 183113775 : append_vuse (gimple_vop (fn));
977 : 183113775 : goto do_default;
978 : :
979 : 773918374 : case GIMPLE_CALL:
980 : : /* Add call-clobbered operands, if needed. */
981 : 773918374 : maybe_add_call_vops (as_a <gcall *> (stmt));
982 : : /* FALLTHRU */
983 : :
984 : 4262230663 : case GIMPLE_ASSIGN:
985 : 4262230663 : get_expr_operands (gimple_op_ptr (stmt, 0), opf_def);
986 : 4262230663 : start = 1;
987 : : /* FALLTHRU */
988 : :
989 : 5200513955 : default:
990 : 5200513955 : do_default:
991 : 5200513955 : n = gimple_num_ops (stmt);
992 : 15460126343 : for (i = start; i < n; i++)
993 : 10259612388 : get_expr_operands (gimple_op_ptr (stmt, i), opf_use);
994 : : break;
995 : : }
996 : 10395133425 : }
997 : :
998 : :
999 : : /* Create an operands cache for STMT. */
1000 : :
1001 : : void
1002 : 334439543 : operands_scanner::build_ssa_operands ()
1003 : : {
1004 : : /* Initially assume that the statement has no volatile operands. */
1005 : 334439543 : gimple_set_has_volatile_ops (stmt, false);
1006 : :
1007 : 334439543 : start_ssa_stmt_operands ();
1008 : 334439543 : parse_ssa_operands ();
1009 : 334439543 : finalize_ssa_stmt_operands ();
1010 : 334439543 : }
1011 : :
1012 : : /* Verifies SSA statement operands. */
1013 : :
1014 : : DEBUG_FUNCTION bool
1015 : 10060693882 : operands_scanner::verify_ssa_operands ()
1016 : : {
1017 : 10060693882 : use_operand_p use_p;
1018 : 10060693882 : def_operand_p def_p;
1019 : 10060693882 : ssa_op_iter iter;
1020 : 10060693882 : unsigned i;
1021 : 10060693882 : tree def;
1022 : 10060693882 : bool volatile_p = gimple_has_volatile_ops (stmt);
1023 : :
1024 : : /* build_ssa_operands w/o finalizing them. */
1025 : 10060693882 : gimple_set_has_volatile_ops (stmt, false);
1026 : 10060693882 : start_ssa_stmt_operands ();
1027 : 10060693882 : parse_ssa_operands ();
1028 : :
1029 : : /* Now verify the built operands are the same as present in STMT. */
1030 : 10060693882 : def = gimple_vdef (stmt);
1031 : 4297507320 : if (def
1032 : 1781466083 : && TREE_CODE (def) == SSA_NAME)
1033 : 1781466083 : def = SSA_NAME_VAR (def);
1034 : 10060693882 : if (build_vdef != def)
1035 : : {
1036 : 0 : error ("virtual definition of statement not up to date");
1037 : 0 : return true;
1038 : : }
1039 : 10060693882 : 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 : 10060693882 : tree use = gimple_vuse (stmt);
1048 : 4297507320 : if (use
1049 : 2866498957 : && TREE_CODE (use) == SSA_NAME)
1050 : 2866498957 : use = SSA_NAME_VAR (use);
1051 : 10060693882 : if (build_vuse != use)
1052 : : {
1053 : 0 : error ("virtual use of statement not up to date");
1054 : 0 : return true;
1055 : : }
1056 : 10060693882 : if (gimple_vuse (stmt)
1057 : 4297507320 : && ((use_p = gimple_vuse_op (stmt)) == NULL_USE_OPERAND_P
1058 : 2866498957 : || 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 : 15156256023 : FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
1065 : : {
1066 : : tree *op;
1067 : 6731761169 : FOR_EACH_VEC_ELT (build_uses, i, op)
1068 : : {
1069 : 6731761169 : if (use_p->use == op)
1070 : : {
1071 : 5095562141 : build_uses[i] = NULL;
1072 : 5095562141 : break;
1073 : : }
1074 : : }
1075 : 10191124282 : 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 : 15156256023 : FOR_EACH_VEC_ELT (build_uses, i, op)
1085 : 5095562141 : 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 : 14408719610 : 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 : 10060693882 : cleanup_build_arrays ();
1099 : 10060693882 : return false;
1100 : : }
1101 : :
1102 : : /* Interface for external use. */
1103 : :
1104 : : DEBUG_FUNCTION bool
1105 : 10060693882 : verify_ssa_operands (struct function *fn, gimple *stmt)
1106 : : {
1107 : 10060693882 : 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 : 1996517 : free_stmt_operands (struct function *fn, gimple *stmt)
1116 : : {
1117 : 1996517 : use_optype_p uses = gimple_use_ops (stmt), last_use;
1118 : :
1119 : 1985761 : if (uses)
1120 : : {
1121 : 8809 : for (last_use = uses; last_use->next; last_use = last_use->next)
1122 : 8809 : delink_imm_use (USE_OP_PTR (last_use));
1123 : 5633 : delink_imm_use (USE_OP_PTR (last_use));
1124 : 5633 : last_use->next = gimple_ssa_operands (fn)->free_uses;
1125 : 5633 : gimple_ssa_operands (fn)->free_uses = uses;
1126 : 5633 : gimple_set_use_ops (stmt, NULL);
1127 : : }
1128 : :
1129 : 1996517 : if (gimple_has_mem_ops (stmt))
1130 : : {
1131 : 1797445 : gimple_set_vuse (stmt, NULL_TREE);
1132 : 1797445 : gimple_set_vdef (stmt, NULL_TREE);
1133 : : }
1134 : 1996517 : }
1135 : :
1136 : :
1137 : : /* Get the operands of statement STMT. */
1138 : :
1139 : : void
1140 : 336555845 : update_stmt_operands (struct function *fn, gimple *stmt)
1141 : : {
1142 : : /* If update_stmt_operands is called before SSA is initialized, do
1143 : : nothing. */
1144 : 336555845 : if (!ssa_operands_active (fn))
1145 : : return;
1146 : :
1147 : 334439543 : timevar_push (TV_TREE_OPS);
1148 : :
1149 : 668879086 : gcc_assert (gimple_modified_p (stmt));
1150 : 334439543 : operands_scanner (fn, stmt).build_ssa_operands ();
1151 : 334439543 : gimple_set_modified (stmt, false);
1152 : :
1153 : 334439543 : 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 : 396466 : swap_ssa_operands (gimple *stmt, tree *exp0, tree *exp1)
1162 : : {
1163 : 396466 : tree op0, op1;
1164 : 396466 : op0 = *exp0;
1165 : 396466 : op1 = *exp1;
1166 : :
1167 : 396466 : 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 : 396466 : use_optype_p use0, use1, ptr;
1173 : 396466 : use0 = use1 = NULL;
1174 : :
1175 : : /* Find the 2 operands in the cache, if they are there. */
1176 : 793050 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1177 : 396466 : if (USE_OP_PTR (ptr)->use == exp0)
1178 : : {
1179 : : use0 = ptr;
1180 : : break;
1181 : : }
1182 : :
1183 : 1189280 : for (ptr = gimple_use_ops (stmt); ptr; ptr = ptr->next)
1184 : 782561 : 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 : 396466 : if (use0)
1193 : 396348 : USE_OP_PTR (use0)->use = exp1;
1194 : 396466 : if (use1)
1195 : 386213 : USE_OP_PTR (use1)->use = exp0;
1196 : :
1197 : : /* Now swap the data. */
1198 : 396466 : *exp0 = op1;
1199 : 396466 : *exp1 = op0;
1200 : : }
1201 : 396466 : }
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 : 5944362902 : verify_imm_links (FILE *f, tree var)
1209 : : {
1210 : 5944362902 : use_operand_p ptr, prev, list;
1211 : 5944362902 : unsigned int count;
1212 : :
1213 : 5944362902 : gcc_assert (TREE_CODE (var) == SSA_NAME);
1214 : :
1215 : 5944362902 : list = &(SSA_NAME_IMM_USE_NODE (var));
1216 : 5944362902 : gcc_assert (list->use == NULL);
1217 : :
1218 : 5944362902 : if (list->prev == NULL)
1219 : : {
1220 : 0 : gcc_assert (list->next == NULL);
1221 : : return false;
1222 : : }
1223 : :
1224 : 5944362902 : prev = list;
1225 : 5944362902 : count = 0;
1226 : 16318631663 : for (ptr = list->next; ptr != list; )
1227 : : {
1228 : 10374268761 : if (prev != ptr->prev)
1229 : : {
1230 : 0 : fprintf (f, "prev != ptr->prev\n");
1231 : 0 : goto error;
1232 : : }
1233 : :
1234 : 10374268761 : 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 : 10374268761 : else if (*(ptr->use) != var)
1240 : : {
1241 : 0 : fprintf (f, "*(ptr->use) != var\n");
1242 : 0 : goto error;
1243 : : }
1244 : :
1245 : 10374268761 : prev = ptr;
1246 : 10374268761 : ptr = ptr->next;
1247 : :
1248 : 10374268761 : count++;
1249 : 10374268761 : 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 : 16318631663 : for (ptr = list->prev; ptr != list; )
1259 : : {
1260 : 10374268761 : if (prev != ptr->next)
1261 : : {
1262 : 0 : fprintf (f, "prev != ptr->next\n");
1263 : 0 : goto error;
1264 : : }
1265 : 10374268761 : prev = ptr;
1266 : 10374268761 : ptr = ptr->prev;
1267 : 10374268761 : if (count == 0)
1268 : : {
1269 : 0 : fprintf (f, "count-- < 0\n");
1270 : 0 : goto error;
1271 : : }
1272 : 10374268761 : count--;
1273 : : }
1274 : :
1275 : 5944362902 : 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 : : }
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 : 50928528 : unlink_stmt_vdef (gimple *stmt)
1369 : : {
1370 : 50928528 : use_operand_p use_p;
1371 : 50928528 : imm_use_iterator iter;
1372 : 50928528 : gimple *use_stmt;
1373 : 50928528 : tree vdef = gimple_vdef (stmt);
1374 : 50928528 : tree vuse = gimple_vuse (stmt);
1375 : :
1376 : 50928528 : if (!vdef
1377 : 13795101 : || TREE_CODE (vdef) != SSA_NAME)
1378 : 37766069 : return;
1379 : :
1380 : 32464026 : FOR_EACH_IMM_USE_STMT (use_stmt, iter, vdef)
1381 : : {
1382 : 58846429 : FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1383 : 19772431 : SET_USE (use_p, vuse);
1384 : 13162459 : }
1385 : :
1386 : 13162459 : if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vdef))
1387 : 840 : 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 : 37691683 : single_imm_use_1 (const ssa_use_operand_t *head,
1395 : : use_operand_p *use_p, gimple **stmt)
1396 : : {
1397 : 37691683 : ssa_use_operand_t *ptr, *single_use = 0;
1398 : :
1399 : 82085674 : for (ptr = head->next; ptr != head; ptr = ptr->next)
1400 : 77949882 : if (USE_STMT(ptr) && !is_gimple_debug (USE_STMT (ptr)))
1401 : : {
1402 : 71242333 : if (single_use)
1403 : : {
1404 : : single_use = NULL;
1405 : : break;
1406 : : }
1407 : : single_use = ptr;
1408 : : }
1409 : :
1410 : 37691683 : if (use_p)
1411 : 37691683 : *use_p = single_use;
1412 : :
1413 : 37691683 : if (stmt)
1414 : 37691683 : *stmt = single_use ? single_use->loc.stmt : NULL;
1415 : :
1416 : 37691683 : return single_use;
1417 : : }
1418 : :
|
