1 /* Gimple IR support functions.
2
3 Copyright 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "target.h"
27 #include "tree.h"
28 #include "ggc.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
31 #include "gimple.h"
32 #include "diagnostic.h"
33 #include "tree-flow.h"
34 #include "value-prof.h"
35 #include "flags.h"
36 #include "alias.h"
37 #include "demangle.h"
38 #include "langhooks.h"
39
40 /* Global type table. FIXME lto, it should be possible to re-use some
41 of the type hashing routines in tree.c (type_hash_canon, type_hash_lookup,
42 etc), but those assume that types were built with the various
43 build_*_type routines which is not the case with the streamer. */
44 static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node)))
45 htab_t gimple_types;
46 static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node)))
47 htab_t gimple_canonical_types;
48 static GTY((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
49 htab_t type_hash_cache;
50 static GTY((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
51 htab_t canonical_type_hash_cache;
52
53 /* All the tuples have their operand vector (if present) at the very bottom
54 of the structure. Therefore, the offset required to find the
55 operands vector the size of the structure minus the size of the 1
56 element tree array at the end (see gimple_ops). */
57 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
58 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
59 EXPORTED_CONST size_t gimple_ops_offset_[] = {
60 #include "gsstruct.def"
61 };
62 #undef DEFGSSTRUCT
63
64 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT),
65 static const size_t gsstruct_code_size[] = {
66 #include "gsstruct.def"
67 };
68 #undef DEFGSSTRUCT
69
70 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
71 const char *const gimple_code_name[] = {
72 #include "gimple.def"
73 };
74 #undef DEFGSCODE
75
76 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
77 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
78 #include "gimple.def"
79 };
80 #undef DEFGSCODE
81
82 #ifdef GATHER_STATISTICS
83 /* Gimple stats. */
84
85 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
86 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
87
88 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
89 static const char * const gimple_alloc_kind_names[] = {
90 "assignments",
91 "phi nodes",
92 "conditionals",
93 "sequences",
94 "everything else"
95 };
96
97 #endif /* GATHER_STATISTICS */
98
99 /* A cache of gimple_seq objects. Sequences are created and destroyed
100 fairly often during gimplification. */
101 static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
102
103 /* Private API manipulation functions shared only with some
104 other files. */
105 extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
106 extern void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
107
108 /* Gimple tuple constructors.
109 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
110 be passed a NULL to start with an empty sequence. */
111
112 /* Set the code for statement G to CODE. */
113
114 static inline void
gimple_set_code(gimple g,enum gimple_code code)115 gimple_set_code (gimple g, enum gimple_code code)
116 {
117 g->gsbase.code = code;
118 }
119
120 /* Return the number of bytes needed to hold a GIMPLE statement with
121 code CODE. */
122
123 static inline size_t
gimple_size(enum gimple_code code)124 gimple_size (enum gimple_code code)
125 {
126 return gsstruct_code_size[gss_for_code (code)];
127 }
128
129 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
130 operands. */
131
132 gimple
gimple_alloc_stat(enum gimple_code code,unsigned num_ops MEM_STAT_DECL)133 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
134 {
135 size_t size;
136 gimple stmt;
137
138 size = gimple_size (code);
139 if (num_ops > 0)
140 size += sizeof (tree) * (num_ops - 1);
141
142 #ifdef GATHER_STATISTICS
143 {
144 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
145 gimple_alloc_counts[(int) kind]++;
146 gimple_alloc_sizes[(int) kind] += size;
147 }
148 #endif
149
150 stmt = ggc_alloc_cleared_gimple_statement_d_stat (size PASS_MEM_STAT);
151 gimple_set_code (stmt, code);
152 gimple_set_num_ops (stmt, num_ops);
153
154 /* Do not call gimple_set_modified here as it has other side
155 effects and this tuple is still not completely built. */
156 stmt->gsbase.modified = 1;
157
158 return stmt;
159 }
160
161 /* Set SUBCODE to be the code of the expression computed by statement G. */
162
163 static inline void
gimple_set_subcode(gimple g,unsigned subcode)164 gimple_set_subcode (gimple g, unsigned subcode)
165 {
166 /* We only have 16 bits for the RHS code. Assert that we are not
167 overflowing it. */
168 gcc_assert (subcode < (1 << 16));
169 g->gsbase.subcode = subcode;
170 }
171
172
173
174 /* Build a tuple with operands. CODE is the statement to build (which
175 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the sub-code
176 for the new tuple. NUM_OPS is the number of operands to allocate. */
177
178 #define gimple_build_with_ops(c, s, n) \
179 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
180
181 static gimple
gimple_build_with_ops_stat(enum gimple_code code,unsigned subcode,unsigned num_ops MEM_STAT_DECL)182 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
183 unsigned num_ops MEM_STAT_DECL)
184 {
185 gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
186 gimple_set_subcode (s, subcode);
187
188 return s;
189 }
190
191
192 /* Build a GIMPLE_RETURN statement returning RETVAL. */
193
194 gimple
gimple_build_return(tree retval)195 gimple_build_return (tree retval)
196 {
197 gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
198 if (retval)
199 gimple_return_set_retval (s, retval);
200 return s;
201 }
202
203 /* Reset alias information on call S. */
204
205 void
gimple_call_reset_alias_info(gimple s)206 gimple_call_reset_alias_info (gimple s)
207 {
208 if (gimple_call_flags (s) & ECF_CONST)
209 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
210 else
211 pt_solution_reset (gimple_call_use_set (s));
212 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
213 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
214 else
215 pt_solution_reset (gimple_call_clobber_set (s));
216 }
217
218 /* Helper for gimple_build_call, gimple_build_call_valist,
219 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
220 components of a GIMPLE_CALL statement to function FN with NARGS
221 arguments. */
222
223 static inline gimple
gimple_build_call_1(tree fn,unsigned nargs)224 gimple_build_call_1 (tree fn, unsigned nargs)
225 {
226 gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
227 if (TREE_CODE (fn) == FUNCTION_DECL)
228 fn = build_fold_addr_expr (fn);
229 gimple_set_op (s, 1, fn);
230 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
231 gimple_call_reset_alias_info (s);
232 return s;
233 }
234
235
236 /* Build a GIMPLE_CALL statement to function FN with the arguments
237 specified in vector ARGS. */
238
239 gimple
gimple_build_call_vec(tree fn,VEC (tree,heap)* args)240 gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
241 {
242 unsigned i;
243 unsigned nargs = VEC_length (tree, args);
244 gimple call = gimple_build_call_1 (fn, nargs);
245
246 for (i = 0; i < nargs; i++)
247 gimple_call_set_arg (call, i, VEC_index (tree, args, i));
248
249 return call;
250 }
251
252
253 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
254 arguments. The ... are the arguments. */
255
256 gimple
gimple_build_call(tree fn,unsigned nargs,...)257 gimple_build_call (tree fn, unsigned nargs, ...)
258 {
259 va_list ap;
260 gimple call;
261 unsigned i;
262
263 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
264
265 call = gimple_build_call_1 (fn, nargs);
266
267 va_start (ap, nargs);
268 for (i = 0; i < nargs; i++)
269 gimple_call_set_arg (call, i, va_arg (ap, tree));
270 va_end (ap);
271
272 return call;
273 }
274
275
276 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
277 arguments. AP contains the arguments. */
278
279 gimple
gimple_build_call_valist(tree fn,unsigned nargs,va_list ap)280 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
281 {
282 gimple call;
283 unsigned i;
284
285 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
286
287 call = gimple_build_call_1 (fn, nargs);
288
289 for (i = 0; i < nargs; i++)
290 gimple_call_set_arg (call, i, va_arg (ap, tree));
291
292 return call;
293 }
294
295
296 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
297 Build the basic components of a GIMPLE_CALL statement to internal
298 function FN with NARGS arguments. */
299
300 static inline gimple
gimple_build_call_internal_1(enum internal_fn fn,unsigned nargs)301 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
302 {
303 gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
304 s->gsbase.subcode |= GF_CALL_INTERNAL;
305 gimple_call_set_internal_fn (s, fn);
306 gimple_call_reset_alias_info (s);
307 return s;
308 }
309
310
311 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
312 the number of arguments. The ... are the arguments. */
313
314 gimple
gimple_build_call_internal(enum internal_fn fn,unsigned nargs,...)315 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
316 {
317 va_list ap;
318 gimple call;
319 unsigned i;
320
321 call = gimple_build_call_internal_1 (fn, nargs);
322 va_start (ap, nargs);
323 for (i = 0; i < nargs; i++)
324 gimple_call_set_arg (call, i, va_arg (ap, tree));
325 va_end (ap);
326
327 return call;
328 }
329
330
331 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
332 specified in vector ARGS. */
333
334 gimple
gimple_build_call_internal_vec(enum internal_fn fn,VEC (tree,heap)* args)335 gimple_build_call_internal_vec (enum internal_fn fn, VEC(tree, heap) *args)
336 {
337 unsigned i, nargs;
338 gimple call;
339
340 nargs = VEC_length (tree, args);
341 call = gimple_build_call_internal_1 (fn, nargs);
342 for (i = 0; i < nargs; i++)
343 gimple_call_set_arg (call, i, VEC_index (tree, args, i));
344
345 return call;
346 }
347
348
349 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
350 assumed to be in GIMPLE form already. Minimal checking is done of
351 this fact. */
352
353 gimple
gimple_build_call_from_tree(tree t)354 gimple_build_call_from_tree (tree t)
355 {
356 unsigned i, nargs;
357 gimple call;
358 tree fndecl = get_callee_fndecl (t);
359
360 gcc_assert (TREE_CODE (t) == CALL_EXPR);
361
362 nargs = call_expr_nargs (t);
363 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
364
365 for (i = 0; i < nargs; i++)
366 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
367
368 gimple_set_block (call, TREE_BLOCK (t));
369
370 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
371 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
372 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
373 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
374 if (fndecl
375 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
376 && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
377 || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA_WITH_ALIGN))
378 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
379 else
380 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
381 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
382 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
383 gimple_set_no_warning (call, TREE_NO_WARNING (t));
384
385 return call;
386 }
387
388
389 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
390 *OP1_P, *OP2_P and *OP3_P respectively. */
391
392 void
extract_ops_from_tree_1(tree expr,enum tree_code * subcode_p,tree * op1_p,tree * op2_p,tree * op3_p)393 extract_ops_from_tree_1 (tree expr, enum tree_code *subcode_p, tree *op1_p,
394 tree *op2_p, tree *op3_p)
395 {
396 enum gimple_rhs_class grhs_class;
397
398 *subcode_p = TREE_CODE (expr);
399 grhs_class = get_gimple_rhs_class (*subcode_p);
400
401 if (grhs_class == GIMPLE_TERNARY_RHS)
402 {
403 *op1_p = TREE_OPERAND (expr, 0);
404 *op2_p = TREE_OPERAND (expr, 1);
405 *op3_p = TREE_OPERAND (expr, 2);
406 }
407 else if (grhs_class == GIMPLE_BINARY_RHS)
408 {
409 *op1_p = TREE_OPERAND (expr, 0);
410 *op2_p = TREE_OPERAND (expr, 1);
411 *op3_p = NULL_TREE;
412 }
413 else if (grhs_class == GIMPLE_UNARY_RHS)
414 {
415 *op1_p = TREE_OPERAND (expr, 0);
416 *op2_p = NULL_TREE;
417 *op3_p = NULL_TREE;
418 }
419 else if (grhs_class == GIMPLE_SINGLE_RHS)
420 {
421 *op1_p = expr;
422 *op2_p = NULL_TREE;
423 *op3_p = NULL_TREE;
424 }
425 else
426 gcc_unreachable ();
427 }
428
429
430 /* Build a GIMPLE_ASSIGN statement.
431
432 LHS of the assignment.
433 RHS of the assignment which can be unary or binary. */
434
435 gimple
gimple_build_assign_stat(tree lhs,tree rhs MEM_STAT_DECL)436 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
437 {
438 enum tree_code subcode;
439 tree op1, op2, op3;
440
441 extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3);
442 return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2, op3
443 PASS_MEM_STAT);
444 }
445
446
447 /* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
448 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
449 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
450
451 gimple
gimple_build_assign_with_ops_stat(enum tree_code subcode,tree lhs,tree op1,tree op2,tree op3 MEM_STAT_DECL)452 gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
453 tree op2, tree op3 MEM_STAT_DECL)
454 {
455 unsigned num_ops;
456 gimple p;
457
458 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
459 code). */
460 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
461
462 p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
463 PASS_MEM_STAT);
464 gimple_assign_set_lhs (p, lhs);
465 gimple_assign_set_rhs1 (p, op1);
466 if (op2)
467 {
468 gcc_assert (num_ops > 2);
469 gimple_assign_set_rhs2 (p, op2);
470 }
471
472 if (op3)
473 {
474 gcc_assert (num_ops > 3);
475 gimple_assign_set_rhs3 (p, op3);
476 }
477
478 return p;
479 }
480
481
482 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
483
484 DST/SRC are the destination and source respectively. You can pass
485 ungimplified trees in DST or SRC, in which case they will be
486 converted to a gimple operand if necessary.
487
488 This function returns the newly created GIMPLE_ASSIGN tuple. */
489
490 gimple
gimplify_assign(tree dst,tree src,gimple_seq * seq_p)491 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
492 {
493 tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
494 gimplify_and_add (t, seq_p);
495 ggc_free (t);
496 return gimple_seq_last_stmt (*seq_p);
497 }
498
499
500 /* Build a GIMPLE_COND statement.
501
502 PRED is the condition used to compare LHS and the RHS.
503 T_LABEL is the label to jump to if the condition is true.
504 F_LABEL is the label to jump to otherwise. */
505
506 gimple
gimple_build_cond(enum tree_code pred_code,tree lhs,tree rhs,tree t_label,tree f_label)507 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
508 tree t_label, tree f_label)
509 {
510 gimple p;
511
512 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
513 p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
514 gimple_cond_set_lhs (p, lhs);
515 gimple_cond_set_rhs (p, rhs);
516 gimple_cond_set_true_label (p, t_label);
517 gimple_cond_set_false_label (p, f_label);
518 return p;
519 }
520
521
522 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
523
524 void
gimple_cond_get_ops_from_tree(tree cond,enum tree_code * code_p,tree * lhs_p,tree * rhs_p)525 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
526 tree *lhs_p, tree *rhs_p)
527 {
528 gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
529 || TREE_CODE (cond) == TRUTH_NOT_EXPR
530 || is_gimple_min_invariant (cond)
531 || SSA_VAR_P (cond));
532
533 extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
534
535 /* Canonicalize conditionals of the form 'if (!VAL)'. */
536 if (*code_p == TRUTH_NOT_EXPR)
537 {
538 *code_p = EQ_EXPR;
539 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
540 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
541 }
542 /* Canonicalize conditionals of the form 'if (VAL)' */
543 else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
544 {
545 *code_p = NE_EXPR;
546 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
547 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
548 }
549 }
550
551
552 /* Build a GIMPLE_COND statement from the conditional expression tree
553 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
554
555 gimple
gimple_build_cond_from_tree(tree cond,tree t_label,tree f_label)556 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
557 {
558 enum tree_code code;
559 tree lhs, rhs;
560
561 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
562 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
563 }
564
565 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
566 boolean expression tree COND. */
567
568 void
gimple_cond_set_condition_from_tree(gimple stmt,tree cond)569 gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
570 {
571 enum tree_code code;
572 tree lhs, rhs;
573
574 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
575 gimple_cond_set_condition (stmt, code, lhs, rhs);
576 }
577
578 /* Build a GIMPLE_LABEL statement for LABEL. */
579
580 gimple
gimple_build_label(tree label)581 gimple_build_label (tree label)
582 {
583 gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
584 gimple_label_set_label (p, label);
585 return p;
586 }
587
588 /* Build a GIMPLE_GOTO statement to label DEST. */
589
590 gimple
gimple_build_goto(tree dest)591 gimple_build_goto (tree dest)
592 {
593 gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
594 gimple_goto_set_dest (p, dest);
595 return p;
596 }
597
598
599 /* Build a GIMPLE_NOP statement. */
600
601 gimple
gimple_build_nop(void)602 gimple_build_nop (void)
603 {
604 return gimple_alloc (GIMPLE_NOP, 0);
605 }
606
607
608 /* Build a GIMPLE_BIND statement.
609 VARS are the variables in BODY.
610 BLOCK is the containing block. */
611
612 gimple
gimple_build_bind(tree vars,gimple_seq body,tree block)613 gimple_build_bind (tree vars, gimple_seq body, tree block)
614 {
615 gimple p = gimple_alloc (GIMPLE_BIND, 0);
616 gimple_bind_set_vars (p, vars);
617 if (body)
618 gimple_bind_set_body (p, body);
619 if (block)
620 gimple_bind_set_block (p, block);
621 return p;
622 }
623
624 /* Helper function to set the simple fields of a asm stmt.
625
626 STRING is a pointer to a string that is the asm blocks assembly code.
627 NINPUT is the number of register inputs.
628 NOUTPUT is the number of register outputs.
629 NCLOBBERS is the number of clobbered registers.
630 */
631
632 static inline gimple
gimple_build_asm_1(const char * string,unsigned ninputs,unsigned noutputs,unsigned nclobbers,unsigned nlabels)633 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
634 unsigned nclobbers, unsigned nlabels)
635 {
636 gimple p;
637 int size = strlen (string);
638
639 /* ASMs with labels cannot have outputs. This should have been
640 enforced by the front end. */
641 gcc_assert (nlabels == 0 || noutputs == 0);
642
643 p = gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
644 ninputs + noutputs + nclobbers + nlabels);
645
646 p->gimple_asm.ni = ninputs;
647 p->gimple_asm.no = noutputs;
648 p->gimple_asm.nc = nclobbers;
649 p->gimple_asm.nl = nlabels;
650 p->gimple_asm.string = ggc_alloc_string (string, size);
651
652 #ifdef GATHER_STATISTICS
653 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
654 #endif
655
656 return p;
657 }
658
659 /* Build a GIMPLE_ASM statement.
660
661 STRING is the assembly code.
662 NINPUT is the number of register inputs.
663 NOUTPUT is the number of register outputs.
664 NCLOBBERS is the number of clobbered registers.
665 INPUTS is a vector of the input register parameters.
666 OUTPUTS is a vector of the output register parameters.
667 CLOBBERS is a vector of the clobbered register parameters.
668 LABELS is a vector of destination labels. */
669
670 gimple
gimple_build_asm_vec(const char * string,VEC (tree,gc)* inputs,VEC (tree,gc)* outputs,VEC (tree,gc)* clobbers,VEC (tree,gc)* labels)671 gimple_build_asm_vec (const char *string, VEC(tree,gc)* inputs,
672 VEC(tree,gc)* outputs, VEC(tree,gc)* clobbers,
673 VEC(tree,gc)* labels)
674 {
675 gimple p;
676 unsigned i;
677
678 p = gimple_build_asm_1 (string,
679 VEC_length (tree, inputs),
680 VEC_length (tree, outputs),
681 VEC_length (tree, clobbers),
682 VEC_length (tree, labels));
683
684 for (i = 0; i < VEC_length (tree, inputs); i++)
685 gimple_asm_set_input_op (p, i, VEC_index (tree, inputs, i));
686
687 for (i = 0; i < VEC_length (tree, outputs); i++)
688 gimple_asm_set_output_op (p, i, VEC_index (tree, outputs, i));
689
690 for (i = 0; i < VEC_length (tree, clobbers); i++)
691 gimple_asm_set_clobber_op (p, i, VEC_index (tree, clobbers, i));
692
693 for (i = 0; i < VEC_length (tree, labels); i++)
694 gimple_asm_set_label_op (p, i, VEC_index (tree, labels, i));
695
696 return p;
697 }
698
699 /* Build a GIMPLE_CATCH statement.
700
701 TYPES are the catch types.
702 HANDLER is the exception handler. */
703
704 gimple
gimple_build_catch(tree types,gimple_seq handler)705 gimple_build_catch (tree types, gimple_seq handler)
706 {
707 gimple p = gimple_alloc (GIMPLE_CATCH, 0);
708 gimple_catch_set_types (p, types);
709 if (handler)
710 gimple_catch_set_handler (p, handler);
711
712 return p;
713 }
714
715 /* Build a GIMPLE_EH_FILTER statement.
716
717 TYPES are the filter's types.
718 FAILURE is the filter's failure action. */
719
720 gimple
gimple_build_eh_filter(tree types,gimple_seq failure)721 gimple_build_eh_filter (tree types, gimple_seq failure)
722 {
723 gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
724 gimple_eh_filter_set_types (p, types);
725 if (failure)
726 gimple_eh_filter_set_failure (p, failure);
727
728 return p;
729 }
730
731 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
732
733 gimple
gimple_build_eh_must_not_throw(tree decl)734 gimple_build_eh_must_not_throw (tree decl)
735 {
736 gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
737
738 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
739 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
740 gimple_eh_must_not_throw_set_fndecl (p, decl);
741
742 return p;
743 }
744
745 /* Build a GIMPLE_EH_ELSE statement. */
746
747 gimple
gimple_build_eh_else(gimple_seq n_body,gimple_seq e_body)748 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
749 {
750 gimple p = gimple_alloc (GIMPLE_EH_ELSE, 0);
751 gimple_eh_else_set_n_body (p, n_body);
752 gimple_eh_else_set_e_body (p, e_body);
753 return p;
754 }
755
756 /* Build a GIMPLE_TRY statement.
757
758 EVAL is the expression to evaluate.
759 CLEANUP is the cleanup expression.
760 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
761 whether this is a try/catch or a try/finally respectively. */
762
763 gimple
gimple_build_try(gimple_seq eval,gimple_seq cleanup,enum gimple_try_flags kind)764 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
765 enum gimple_try_flags kind)
766 {
767 gimple p;
768
769 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
770 p = gimple_alloc (GIMPLE_TRY, 0);
771 gimple_set_subcode (p, kind);
772 if (eval)
773 gimple_try_set_eval (p, eval);
774 if (cleanup)
775 gimple_try_set_cleanup (p, cleanup);
776
777 return p;
778 }
779
780 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
781
782 CLEANUP is the cleanup expression. */
783
784 gimple
gimple_build_wce(gimple_seq cleanup)785 gimple_build_wce (gimple_seq cleanup)
786 {
787 gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
788 if (cleanup)
789 gimple_wce_set_cleanup (p, cleanup);
790
791 return p;
792 }
793
794
795 /* Build a GIMPLE_RESX statement. */
796
797 gimple
gimple_build_resx(int region)798 gimple_build_resx (int region)
799 {
800 gimple p = gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0);
801 p->gimple_eh_ctrl.region = region;
802 return p;
803 }
804
805
806 /* The helper for constructing a gimple switch statement.
807 INDEX is the switch's index.
808 NLABELS is the number of labels in the switch excluding the default.
809 DEFAULT_LABEL is the default label for the switch statement. */
810
811 gimple
gimple_build_switch_nlabels(unsigned nlabels,tree index,tree default_label)812 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
813 {
814 /* nlabels + 1 default label + 1 index. */
815 gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
816 1 + (default_label != NULL) + nlabels);
817 gimple_switch_set_index (p, index);
818 if (default_label)
819 gimple_switch_set_default_label (p, default_label);
820 return p;
821 }
822
823
824 /* Build a GIMPLE_SWITCH statement.
825
826 INDEX is the switch's index.
827 NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL.
828 ... are the labels excluding the default. */
829
830 gimple
gimple_build_switch(unsigned nlabels,tree index,tree default_label,...)831 gimple_build_switch (unsigned nlabels, tree index, tree default_label, ...)
832 {
833 va_list al;
834 unsigned i, offset;
835 gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
836
837 /* Store the rest of the labels. */
838 va_start (al, default_label);
839 offset = (default_label != NULL);
840 for (i = 0; i < nlabels; i++)
841 gimple_switch_set_label (p, i + offset, va_arg (al, tree));
842 va_end (al);
843
844 return p;
845 }
846
847
848 /* Build a GIMPLE_SWITCH statement.
849
850 INDEX is the switch's index.
851 DEFAULT_LABEL is the default label
852 ARGS is a vector of labels excluding the default. */
853
854 gimple
gimple_build_switch_vec(tree index,tree default_label,VEC (tree,heap)* args)855 gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
856 {
857 unsigned i, offset, nlabels = VEC_length (tree, args);
858 gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
859
860 /* Copy the labels from the vector to the switch statement. */
861 offset = (default_label != NULL);
862 for (i = 0; i < nlabels; i++)
863 gimple_switch_set_label (p, i + offset, VEC_index (tree, args, i));
864
865 return p;
866 }
867
868 /* Build a GIMPLE_EH_DISPATCH statement. */
869
870 gimple
gimple_build_eh_dispatch(int region)871 gimple_build_eh_dispatch (int region)
872 {
873 gimple p = gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0);
874 p->gimple_eh_ctrl.region = region;
875 return p;
876 }
877
878 /* Build a new GIMPLE_DEBUG_BIND statement.
879
880 VAR is bound to VALUE; block and location are taken from STMT. */
881
882 gimple
gimple_build_debug_bind_stat(tree var,tree value,gimple stmt MEM_STAT_DECL)883 gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
884 {
885 gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
886 (unsigned)GIMPLE_DEBUG_BIND, 2
887 PASS_MEM_STAT);
888
889 gimple_debug_bind_set_var (p, var);
890 gimple_debug_bind_set_value (p, value);
891 if (stmt)
892 {
893 gimple_set_block (p, gimple_block (stmt));
894 gimple_set_location (p, gimple_location (stmt));
895 }
896
897 return p;
898 }
899
900
901 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
902
903 VAR is bound to VALUE; block and location are taken from STMT. */
904
905 gimple
gimple_build_debug_source_bind_stat(tree var,tree value,gimple stmt MEM_STAT_DECL)906 gimple_build_debug_source_bind_stat (tree var, tree value,
907 gimple stmt MEM_STAT_DECL)
908 {
909 gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
910 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
911 PASS_MEM_STAT);
912
913 gimple_debug_source_bind_set_var (p, var);
914 gimple_debug_source_bind_set_value (p, value);
915 if (stmt)
916 {
917 gimple_set_block (p, gimple_block (stmt));
918 gimple_set_location (p, gimple_location (stmt));
919 }
920
921 return p;
922 }
923
924
925 /* Build a GIMPLE_OMP_CRITICAL statement.
926
927 BODY is the sequence of statements for which only one thread can execute.
928 NAME is optional identifier for this critical block. */
929
930 gimple
gimple_build_omp_critical(gimple_seq body,tree name)931 gimple_build_omp_critical (gimple_seq body, tree name)
932 {
933 gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
934 gimple_omp_critical_set_name (p, name);
935 if (body)
936 gimple_omp_set_body (p, body);
937
938 return p;
939 }
940
941 /* Build a GIMPLE_OMP_FOR statement.
942
943 BODY is sequence of statements inside the for loop.
944 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
945 lastprivate, reductions, ordered, schedule, and nowait.
946 COLLAPSE is the collapse count.
947 PRE_BODY is the sequence of statements that are loop invariant. */
948
949 gimple
gimple_build_omp_for(gimple_seq body,tree clauses,size_t collapse,gimple_seq pre_body)950 gimple_build_omp_for (gimple_seq body, tree clauses, size_t collapse,
951 gimple_seq pre_body)
952 {
953 gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
954 if (body)
955 gimple_omp_set_body (p, body);
956 gimple_omp_for_set_clauses (p, clauses);
957 p->gimple_omp_for.collapse = collapse;
958 p->gimple_omp_for.iter
959 = ggc_alloc_cleared_vec_gimple_omp_for_iter (collapse);
960 if (pre_body)
961 gimple_omp_for_set_pre_body (p, pre_body);
962
963 return p;
964 }
965
966
967 /* Build a GIMPLE_OMP_PARALLEL statement.
968
969 BODY is sequence of statements which are executed in parallel.
970 CLAUSES, are the OMP parallel construct's clauses.
971 CHILD_FN is the function created for the parallel threads to execute.
972 DATA_ARG are the shared data argument(s). */
973
974 gimple
gimple_build_omp_parallel(gimple_seq body,tree clauses,tree child_fn,tree data_arg)975 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
976 tree data_arg)
977 {
978 gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
979 if (body)
980 gimple_omp_set_body (p, body);
981 gimple_omp_parallel_set_clauses (p, clauses);
982 gimple_omp_parallel_set_child_fn (p, child_fn);
983 gimple_omp_parallel_set_data_arg (p, data_arg);
984
985 return p;
986 }
987
988
989 /* Build a GIMPLE_OMP_TASK statement.
990
991 BODY is sequence of statements which are executed by the explicit task.
992 CLAUSES, are the OMP parallel construct's clauses.
993 CHILD_FN is the function created for the parallel threads to execute.
994 DATA_ARG are the shared data argument(s).
995 COPY_FN is the optional function for firstprivate initialization.
996 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
997
998 gimple
gimple_build_omp_task(gimple_seq body,tree clauses,tree child_fn,tree data_arg,tree copy_fn,tree arg_size,tree arg_align)999 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
1000 tree data_arg, tree copy_fn, tree arg_size,
1001 tree arg_align)
1002 {
1003 gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
1004 if (body)
1005 gimple_omp_set_body (p, body);
1006 gimple_omp_task_set_clauses (p, clauses);
1007 gimple_omp_task_set_child_fn (p, child_fn);
1008 gimple_omp_task_set_data_arg (p, data_arg);
1009 gimple_omp_task_set_copy_fn (p, copy_fn);
1010 gimple_omp_task_set_arg_size (p, arg_size);
1011 gimple_omp_task_set_arg_align (p, arg_align);
1012
1013 return p;
1014 }
1015
1016
1017 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1018
1019 BODY is the sequence of statements in the section. */
1020
1021 gimple
gimple_build_omp_section(gimple_seq body)1022 gimple_build_omp_section (gimple_seq body)
1023 {
1024 gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
1025 if (body)
1026 gimple_omp_set_body (p, body);
1027
1028 return p;
1029 }
1030
1031
1032 /* Build a GIMPLE_OMP_MASTER statement.
1033
1034 BODY is the sequence of statements to be executed by just the master. */
1035
1036 gimple
gimple_build_omp_master(gimple_seq body)1037 gimple_build_omp_master (gimple_seq body)
1038 {
1039 gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
1040 if (body)
1041 gimple_omp_set_body (p, body);
1042
1043 return p;
1044 }
1045
1046
1047 /* Build a GIMPLE_OMP_CONTINUE statement.
1048
1049 CONTROL_DEF is the definition of the control variable.
1050 CONTROL_USE is the use of the control variable. */
1051
1052 gimple
gimple_build_omp_continue(tree control_def,tree control_use)1053 gimple_build_omp_continue (tree control_def, tree control_use)
1054 {
1055 gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
1056 gimple_omp_continue_set_control_def (p, control_def);
1057 gimple_omp_continue_set_control_use (p, control_use);
1058 return p;
1059 }
1060
1061 /* Build a GIMPLE_OMP_ORDERED statement.
1062
1063 BODY is the sequence of statements inside a loop that will executed in
1064 sequence. */
1065
1066 gimple
gimple_build_omp_ordered(gimple_seq body)1067 gimple_build_omp_ordered (gimple_seq body)
1068 {
1069 gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
1070 if (body)
1071 gimple_omp_set_body (p, body);
1072
1073 return p;
1074 }
1075
1076
1077 /* Build a GIMPLE_OMP_RETURN statement.
1078 WAIT_P is true if this is a non-waiting return. */
1079
1080 gimple
gimple_build_omp_return(bool wait_p)1081 gimple_build_omp_return (bool wait_p)
1082 {
1083 gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1084 if (wait_p)
1085 gimple_omp_return_set_nowait (p);
1086
1087 return p;
1088 }
1089
1090
1091 /* Build a GIMPLE_OMP_SECTIONS statement.
1092
1093 BODY is a sequence of section statements.
1094 CLAUSES are any of the OMP sections contsruct's clauses: private,
1095 firstprivate, lastprivate, reduction, and nowait. */
1096
1097 gimple
gimple_build_omp_sections(gimple_seq body,tree clauses)1098 gimple_build_omp_sections (gimple_seq body, tree clauses)
1099 {
1100 gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
1101 if (body)
1102 gimple_omp_set_body (p, body);
1103 gimple_omp_sections_set_clauses (p, clauses);
1104
1105 return p;
1106 }
1107
1108
1109 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1110
1111 gimple
gimple_build_omp_sections_switch(void)1112 gimple_build_omp_sections_switch (void)
1113 {
1114 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1115 }
1116
1117
1118 /* Build a GIMPLE_OMP_SINGLE statement.
1119
1120 BODY is the sequence of statements that will be executed once.
1121 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1122 copyprivate, nowait. */
1123
1124 gimple
gimple_build_omp_single(gimple_seq body,tree clauses)1125 gimple_build_omp_single (gimple_seq body, tree clauses)
1126 {
1127 gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
1128 if (body)
1129 gimple_omp_set_body (p, body);
1130 gimple_omp_single_set_clauses (p, clauses);
1131
1132 return p;
1133 }
1134
1135
1136 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1137
1138 gimple
gimple_build_omp_atomic_load(tree lhs,tree rhs)1139 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1140 {
1141 gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
1142 gimple_omp_atomic_load_set_lhs (p, lhs);
1143 gimple_omp_atomic_load_set_rhs (p, rhs);
1144 return p;
1145 }
1146
1147 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1148
1149 VAL is the value we are storing. */
1150
1151 gimple
gimple_build_omp_atomic_store(tree val)1152 gimple_build_omp_atomic_store (tree val)
1153 {
1154 gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
1155 gimple_omp_atomic_store_set_val (p, val);
1156 return p;
1157 }
1158
1159 /* Build a GIMPLE_TRANSACTION statement. */
1160
1161 gimple
gimple_build_transaction(gimple_seq body,tree label)1162 gimple_build_transaction (gimple_seq body, tree label)
1163 {
1164 gimple p = gimple_alloc (GIMPLE_TRANSACTION, 0);
1165 gimple_transaction_set_body (p, body);
1166 gimple_transaction_set_label (p, label);
1167 return p;
1168 }
1169
1170 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1171 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1172
1173 gimple
gimple_build_predict(enum br_predictor predictor,enum prediction outcome)1174 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
1175 {
1176 gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
1177 /* Ensure all the predictors fit into the lower bits of the subcode. */
1178 gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
1179 gimple_predict_set_predictor (p, predictor);
1180 gimple_predict_set_outcome (p, outcome);
1181 return p;
1182 }
1183
1184 #if defined ENABLE_GIMPLE_CHECKING
1185 /* Complain of a gimple type mismatch and die. */
1186
1187 void
gimple_check_failed(const_gimple gs,const char * file,int line,const char * function,enum gimple_code code,enum tree_code subcode)1188 gimple_check_failed (const_gimple gs, const char *file, int line,
1189 const char *function, enum gimple_code code,
1190 enum tree_code subcode)
1191 {
1192 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1193 gimple_code_name[code],
1194 tree_code_name[subcode],
1195 gimple_code_name[gimple_code (gs)],
1196 gs->gsbase.subcode > 0
1197 ? tree_code_name[gs->gsbase.subcode]
1198 : "",
1199 function, trim_filename (file), line);
1200 }
1201 #endif /* ENABLE_GIMPLE_CHECKING */
1202
1203
1204 /* Allocate a new GIMPLE sequence in GC memory and return it. If
1205 there are free sequences in GIMPLE_SEQ_CACHE return one of those
1206 instead. */
1207
1208 gimple_seq
gimple_seq_alloc(void)1209 gimple_seq_alloc (void)
1210 {
1211 gimple_seq seq = gimple_seq_cache;
1212 if (seq)
1213 {
1214 gimple_seq_cache = gimple_seq_cache->next_free;
1215 gcc_assert (gimple_seq_cache != seq);
1216 memset (seq, 0, sizeof (*seq));
1217 }
1218 else
1219 {
1220 seq = ggc_alloc_cleared_gimple_seq_d ();
1221 #ifdef GATHER_STATISTICS
1222 gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
1223 gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
1224 #endif
1225 }
1226
1227 return seq;
1228 }
1229
1230 /* Return SEQ to the free pool of GIMPLE sequences. */
1231
1232 void
gimple_seq_free(gimple_seq seq)1233 gimple_seq_free (gimple_seq seq)
1234 {
1235 if (seq == NULL)
1236 return;
1237
1238 gcc_assert (gimple_seq_first (seq) == NULL);
1239 gcc_assert (gimple_seq_last (seq) == NULL);
1240
1241 /* If this triggers, it's a sign that the same list is being freed
1242 twice. */
1243 gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
1244
1245 /* Add SEQ to the pool of free sequences. */
1246 seq->next_free = gimple_seq_cache;
1247 gimple_seq_cache = seq;
1248 }
1249
1250
1251 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1252 *SEQ_P is NULL, a new sequence is allocated. */
1253
1254 void
gimple_seq_add_stmt(gimple_seq * seq_p,gimple gs)1255 gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
1256 {
1257 gimple_stmt_iterator si;
1258
1259 if (gs == NULL)
1260 return;
1261
1262 if (*seq_p == NULL)
1263 *seq_p = gimple_seq_alloc ();
1264
1265 si = gsi_last (*seq_p);
1266 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1267 }
1268
1269
1270 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1271 NULL, a new sequence is allocated. */
1272
1273 void
gimple_seq_add_seq(gimple_seq * dst_p,gimple_seq src)1274 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1275 {
1276 gimple_stmt_iterator si;
1277
1278 if (src == NULL)
1279 return;
1280
1281 if (*dst_p == NULL)
1282 *dst_p = gimple_seq_alloc ();
1283
1284 si = gsi_last (*dst_p);
1285 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1286 }
1287
1288
1289 /* Helper function of empty_body_p. Return true if STMT is an empty
1290 statement. */
1291
1292 static bool
empty_stmt_p(gimple stmt)1293 empty_stmt_p (gimple stmt)
1294 {
1295 if (gimple_code (stmt) == GIMPLE_NOP)
1296 return true;
1297 if (gimple_code (stmt) == GIMPLE_BIND)
1298 return empty_body_p (gimple_bind_body (stmt));
1299 return false;
1300 }
1301
1302
1303 /* Return true if BODY contains nothing but empty statements. */
1304
1305 bool
empty_body_p(gimple_seq body)1306 empty_body_p (gimple_seq body)
1307 {
1308 gimple_stmt_iterator i;
1309
1310 if (gimple_seq_empty_p (body))
1311 return true;
1312 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1313 if (!empty_stmt_p (gsi_stmt (i))
1314 && !is_gimple_debug (gsi_stmt (i)))
1315 return false;
1316
1317 return true;
1318 }
1319
1320
1321 /* Perform a deep copy of sequence SRC and return the result. */
1322
1323 gimple_seq
gimple_seq_copy(gimple_seq src)1324 gimple_seq_copy (gimple_seq src)
1325 {
1326 gimple_stmt_iterator gsi;
1327 gimple_seq new_seq = gimple_seq_alloc ();
1328 gimple stmt;
1329
1330 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1331 {
1332 stmt = gimple_copy (gsi_stmt (gsi));
1333 gimple_seq_add_stmt (&new_seq, stmt);
1334 }
1335
1336 return new_seq;
1337 }
1338
1339
1340 /* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
1341 on each one. WI is as in walk_gimple_stmt.
1342
1343 If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
1344 value is stored in WI->CALLBACK_RESULT. Also, the statement that
1345 produced the value is returned if this statement has not been
1346 removed by a callback (wi->removed_stmt). If the statement has
1347 been removed, NULL is returned.
1348
1349 Otherwise, all the statements are walked and NULL returned. */
1350
1351 gimple
walk_gimple_seq(gimple_seq seq,walk_stmt_fn callback_stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)1352 walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
1353 walk_tree_fn callback_op, struct walk_stmt_info *wi)
1354 {
1355 gimple_stmt_iterator gsi;
1356
1357 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
1358 {
1359 tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
1360 if (ret)
1361 {
1362 /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
1363 to hold it. */
1364 gcc_assert (wi);
1365 wi->callback_result = ret;
1366
1367 return wi->removed_stmt ? NULL : gsi_stmt (gsi);
1368 }
1369
1370 if (!wi->removed_stmt)
1371 gsi_next (&gsi);
1372 }
1373
1374 if (wi)
1375 wi->callback_result = NULL_TREE;
1376
1377 return NULL;
1378 }
1379
1380
1381 /* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
1382
1383 static tree
walk_gimple_asm(gimple stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)1384 walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
1385 struct walk_stmt_info *wi)
1386 {
1387 tree ret, op;
1388 unsigned noutputs;
1389 const char **oconstraints;
1390 unsigned i, n;
1391 const char *constraint;
1392 bool allows_mem, allows_reg, is_inout;
1393
1394 noutputs = gimple_asm_noutputs (stmt);
1395 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
1396
1397 if (wi)
1398 wi->is_lhs = true;
1399
1400 for (i = 0; i < noutputs; i++)
1401 {
1402 op = gimple_asm_output_op (stmt, i);
1403 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1404 oconstraints[i] = constraint;
1405 parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
1406 &is_inout);
1407 if (wi)
1408 wi->val_only = (allows_reg || !allows_mem);
1409 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1410 if (ret)
1411 return ret;
1412 }
1413
1414 n = gimple_asm_ninputs (stmt);
1415 for (i = 0; i < n; i++)
1416 {
1417 op = gimple_asm_input_op (stmt, i);
1418 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1419 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1420 oconstraints, &allows_mem, &allows_reg);
1421 if (wi)
1422 {
1423 wi->val_only = (allows_reg || !allows_mem);
1424 /* Although input "m" is not really a LHS, we need a lvalue. */
1425 wi->is_lhs = !wi->val_only;
1426 }
1427 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1428 if (ret)
1429 return ret;
1430 }
1431
1432 if (wi)
1433 {
1434 wi->is_lhs = false;
1435 wi->val_only = true;
1436 }
1437
1438 n = gimple_asm_nlabels (stmt);
1439 for (i = 0; i < n; i++)
1440 {
1441 op = gimple_asm_label_op (stmt, i);
1442 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1443 if (ret)
1444 return ret;
1445 }
1446
1447 return NULL_TREE;
1448 }
1449
1450
1451 /* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
1452 STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
1453
1454 CALLBACK_OP is called on each operand of STMT via walk_tree.
1455 Additional parameters to walk_tree must be stored in WI. For each operand
1456 OP, walk_tree is called as:
1457
1458 walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
1459
1460 If CALLBACK_OP returns non-NULL for an operand, the remaining
1461 operands are not scanned.
1462
1463 The return value is that returned by the last call to walk_tree, or
1464 NULL_TREE if no CALLBACK_OP is specified. */
1465
1466 tree
walk_gimple_op(gimple stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)1467 walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
1468 struct walk_stmt_info *wi)
1469 {
1470 struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
1471 unsigned i;
1472 tree ret = NULL_TREE;
1473
1474 switch (gimple_code (stmt))
1475 {
1476 case GIMPLE_ASSIGN:
1477 /* Walk the RHS operands. If the LHS is of a non-renamable type or
1478 is a register variable, we may use a COMPONENT_REF on the RHS. */
1479 if (wi)
1480 {
1481 tree lhs = gimple_assign_lhs (stmt);
1482 wi->val_only
1483 = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
1484 || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
1485 }
1486
1487 for (i = 1; i < gimple_num_ops (stmt); i++)
1488 {
1489 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
1490 pset);
1491 if (ret)
1492 return ret;
1493 }
1494
1495 /* Walk the LHS. If the RHS is appropriate for a memory, we
1496 may use a COMPONENT_REF on the LHS. */
1497 if (wi)
1498 {
1499 /* If the RHS has more than 1 operand, it is not appropriate
1500 for the memory.
1501 ??? A lhs always requires an lvalue, checking the val_only flag
1502 does not make any sense, so we should be able to avoid computing
1503 it here. */
1504 tree rhs1 = gimple_assign_rhs1 (stmt);
1505 wi->val_only = !(is_gimple_mem_rhs (rhs1)
1506 || TREE_CODE (rhs1) == CONSTRUCTOR)
1507 || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
1508 wi->is_lhs = true;
1509 }
1510
1511 ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
1512 if (ret)
1513 return ret;
1514
1515 if (wi)
1516 {
1517 wi->val_only = true;
1518 wi->is_lhs = false;
1519 }
1520 break;
1521
1522 case GIMPLE_CALL:
1523 if (wi)
1524 {
1525 wi->is_lhs = false;
1526 wi->val_only = true;
1527 }
1528
1529 ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
1530 if (ret)
1531 return ret;
1532
1533 ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
1534 if (ret)
1535 return ret;
1536
1537 for (i = 0; i < gimple_call_num_args (stmt); i++)
1538 {
1539 if (wi)
1540 wi->val_only
1541 = is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
1542 ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
1543 pset);
1544 if (ret)
1545 return ret;
1546 }
1547
1548 if (gimple_call_lhs (stmt))
1549 {
1550 if (wi)
1551 {
1552 wi->is_lhs = true;
1553 wi->val_only
1554 = is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
1555 }
1556
1557 ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
1558 if (ret)
1559 return ret;
1560 }
1561
1562 if (wi)
1563 {
1564 wi->is_lhs = false;
1565 wi->val_only = true;
1566 }
1567 break;
1568
1569 case GIMPLE_CATCH:
1570 ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
1571 pset);
1572 if (ret)
1573 return ret;
1574 break;
1575
1576 case GIMPLE_EH_FILTER:
1577 ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
1578 pset);
1579 if (ret)
1580 return ret;
1581 break;
1582
1583 case GIMPLE_ASM:
1584 ret = walk_gimple_asm (stmt, callback_op, wi);
1585 if (ret)
1586 return ret;
1587 break;
1588
1589 case GIMPLE_OMP_CONTINUE:
1590 ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
1591 callback_op, wi, pset);
1592 if (ret)
1593 return ret;
1594
1595 ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
1596 callback_op, wi, pset);
1597 if (ret)
1598 return ret;
1599 break;
1600
1601 case GIMPLE_OMP_CRITICAL:
1602 ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
1603 pset);
1604 if (ret)
1605 return ret;
1606 break;
1607
1608 case GIMPLE_OMP_FOR:
1609 ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
1610 pset);
1611 if (ret)
1612 return ret;
1613 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1614 {
1615 ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
1616 wi, pset);
1617 if (ret)
1618 return ret;
1619 ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
1620 wi, pset);
1621 if (ret)
1622 return ret;
1623 ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
1624 wi, pset);
1625 if (ret)
1626 return ret;
1627 ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
1628 wi, pset);
1629 }
1630 if (ret)
1631 return ret;
1632 break;
1633
1634 case GIMPLE_OMP_PARALLEL:
1635 ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
1636 wi, pset);
1637 if (ret)
1638 return ret;
1639 ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
1640 wi, pset);
1641 if (ret)
1642 return ret;
1643 ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
1644 wi, pset);
1645 if (ret)
1646 return ret;
1647 break;
1648
1649 case GIMPLE_OMP_TASK:
1650 ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
1651 wi, pset);
1652 if (ret)
1653 return ret;
1654 ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
1655 wi, pset);
1656 if (ret)
1657 return ret;
1658 ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
1659 wi, pset);
1660 if (ret)
1661 return ret;
1662 ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
1663 wi, pset);
1664 if (ret)
1665 return ret;
1666 ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
1667 wi, pset);
1668 if (ret)
1669 return ret;
1670 ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
1671 wi, pset);
1672 if (ret)
1673 return ret;
1674 break;
1675
1676 case GIMPLE_OMP_SECTIONS:
1677 ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
1678 wi, pset);
1679 if (ret)
1680 return ret;
1681
1682 ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
1683 wi, pset);
1684 if (ret)
1685 return ret;
1686
1687 break;
1688
1689 case GIMPLE_OMP_SINGLE:
1690 ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
1691 pset);
1692 if (ret)
1693 return ret;
1694 break;
1695
1696 case GIMPLE_OMP_ATOMIC_LOAD:
1697 ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
1698 pset);
1699 if (ret)
1700 return ret;
1701
1702 ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
1703 pset);
1704 if (ret)
1705 return ret;
1706 break;
1707
1708 case GIMPLE_OMP_ATOMIC_STORE:
1709 ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
1710 wi, pset);
1711 if (ret)
1712 return ret;
1713 break;
1714
1715 case GIMPLE_TRANSACTION:
1716 ret = walk_tree (gimple_transaction_label_ptr (stmt), callback_op,
1717 wi, pset);
1718 if (ret)
1719 return ret;
1720 break;
1721
1722 /* Tuples that do not have operands. */
1723 case GIMPLE_NOP:
1724 case GIMPLE_RESX:
1725 case GIMPLE_OMP_RETURN:
1726 case GIMPLE_PREDICT:
1727 break;
1728
1729 default:
1730 {
1731 enum gimple_statement_structure_enum gss;
1732 gss = gimple_statement_structure (stmt);
1733 if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
1734 for (i = 0; i < gimple_num_ops (stmt); i++)
1735 {
1736 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
1737 if (ret)
1738 return ret;
1739 }
1740 }
1741 break;
1742 }
1743
1744 return NULL_TREE;
1745 }
1746
1747
1748 /* Walk the current statement in GSI (optionally using traversal state
1749 stored in WI). If WI is NULL, no state is kept during traversal.
1750 The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
1751 that it has handled all the operands of the statement, its return
1752 value is returned. Otherwise, the return value from CALLBACK_STMT
1753 is discarded and its operands are scanned.
1754
1755 If CALLBACK_STMT is NULL or it didn't handle the operands,
1756 CALLBACK_OP is called on each operand of the statement via
1757 walk_gimple_op. If walk_gimple_op returns non-NULL for any
1758 operand, the remaining operands are not scanned. In this case, the
1759 return value from CALLBACK_OP is returned.
1760
1761 In any other case, NULL_TREE is returned. */
1762
1763 tree
walk_gimple_stmt(gimple_stmt_iterator * gsi,walk_stmt_fn callback_stmt,walk_tree_fn callback_op,struct walk_stmt_info * wi)1764 walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
1765 walk_tree_fn callback_op, struct walk_stmt_info *wi)
1766 {
1767 gimple ret;
1768 tree tree_ret;
1769 gimple stmt = gsi_stmt (*gsi);
1770
1771 if (wi)
1772 {
1773 wi->gsi = *gsi;
1774 wi->removed_stmt = false;
1775
1776 if (wi->want_locations && gimple_has_location (stmt))
1777 input_location = gimple_location (stmt);
1778 }
1779
1780 ret = NULL;
1781
1782 /* Invoke the statement callback. Return if the callback handled
1783 all of STMT operands by itself. */
1784 if (callback_stmt)
1785 {
1786 bool handled_ops = false;
1787 tree_ret = callback_stmt (gsi, &handled_ops, wi);
1788 if (handled_ops)
1789 return tree_ret;
1790
1791 /* If CALLBACK_STMT did not handle operands, it should not have
1792 a value to return. */
1793 gcc_assert (tree_ret == NULL);
1794
1795 if (wi && wi->removed_stmt)
1796 return NULL;
1797
1798 /* Re-read stmt in case the callback changed it. */
1799 stmt = gsi_stmt (*gsi);
1800 }
1801
1802 /* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
1803 if (callback_op)
1804 {
1805 tree_ret = walk_gimple_op (stmt, callback_op, wi);
1806 if (tree_ret)
1807 return tree_ret;
1808 }
1809
1810 /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
1811 switch (gimple_code (stmt))
1812 {
1813 case GIMPLE_BIND:
1814 ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
1815 callback_op, wi);
1816 if (ret)
1817 return wi->callback_result;
1818 break;
1819
1820 case GIMPLE_CATCH:
1821 ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
1822 callback_op, wi);
1823 if (ret)
1824 return wi->callback_result;
1825 break;
1826
1827 case GIMPLE_EH_FILTER:
1828 ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
1829 callback_op, wi);
1830 if (ret)
1831 return wi->callback_result;
1832 break;
1833
1834 case GIMPLE_EH_ELSE:
1835 ret = walk_gimple_seq (gimple_eh_else_n_body (stmt),
1836 callback_stmt, callback_op, wi);
1837 if (ret)
1838 return wi->callback_result;
1839 ret = walk_gimple_seq (gimple_eh_else_e_body (stmt),
1840 callback_stmt, callback_op, wi);
1841 if (ret)
1842 return wi->callback_result;
1843 break;
1844
1845 case GIMPLE_TRY:
1846 ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
1847 wi);
1848 if (ret)
1849 return wi->callback_result;
1850
1851 ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
1852 callback_op, wi);
1853 if (ret)
1854 return wi->callback_result;
1855 break;
1856
1857 case GIMPLE_OMP_FOR:
1858 ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
1859 callback_op, wi);
1860 if (ret)
1861 return wi->callback_result;
1862
1863 /* FALL THROUGH. */
1864 case GIMPLE_OMP_CRITICAL:
1865 case GIMPLE_OMP_MASTER:
1866 case GIMPLE_OMP_ORDERED:
1867 case GIMPLE_OMP_SECTION:
1868 case GIMPLE_OMP_PARALLEL:
1869 case GIMPLE_OMP_TASK:
1870 case GIMPLE_OMP_SECTIONS:
1871 case GIMPLE_OMP_SINGLE:
1872 ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt,
1873 callback_op, wi);
1874 if (ret)
1875 return wi->callback_result;
1876 break;
1877
1878 case GIMPLE_WITH_CLEANUP_EXPR:
1879 ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
1880 callback_op, wi);
1881 if (ret)
1882 return wi->callback_result;
1883 break;
1884
1885 case GIMPLE_TRANSACTION:
1886 ret = walk_gimple_seq (gimple_transaction_body (stmt),
1887 callback_stmt, callback_op, wi);
1888 if (ret)
1889 return wi->callback_result;
1890 break;
1891
1892 default:
1893 gcc_assert (!gimple_has_substatements (stmt));
1894 break;
1895 }
1896
1897 return NULL;
1898 }
1899
1900
1901 /* Set sequence SEQ to be the GIMPLE body for function FN. */
1902
1903 void
gimple_set_body(tree fndecl,gimple_seq seq)1904 gimple_set_body (tree fndecl, gimple_seq seq)
1905 {
1906 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1907 if (fn == NULL)
1908 {
1909 /* If FNDECL still does not have a function structure associated
1910 with it, then it does not make sense for it to receive a
1911 GIMPLE body. */
1912 gcc_assert (seq == NULL);
1913 }
1914 else
1915 fn->gimple_body = seq;
1916 }
1917
1918
1919 /* Return the body of GIMPLE statements for function FN. After the
1920 CFG pass, the function body doesn't exist anymore because it has
1921 been split up into basic blocks. In this case, it returns
1922 NULL. */
1923
1924 gimple_seq
gimple_body(tree fndecl)1925 gimple_body (tree fndecl)
1926 {
1927 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1928 return fn ? fn->gimple_body : NULL;
1929 }
1930
1931 /* Return true when FNDECL has Gimple body either in unlowered
1932 or CFG form. */
1933 bool
gimple_has_body_p(tree fndecl)1934 gimple_has_body_p (tree fndecl)
1935 {
1936 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1937 return (gimple_body (fndecl) || (fn && fn->cfg));
1938 }
1939
1940 /* Return true if calls C1 and C2 are known to go to the same function. */
1941
1942 bool
gimple_call_same_target_p(const_gimple c1,const_gimple c2)1943 gimple_call_same_target_p (const_gimple c1, const_gimple c2)
1944 {
1945 if (gimple_call_internal_p (c1))
1946 return (gimple_call_internal_p (c2)
1947 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2));
1948 else
1949 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1950 || (gimple_call_fndecl (c1)
1951 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1952 }
1953
1954 /* Detect flags from a GIMPLE_CALL. This is just like
1955 call_expr_flags, but for gimple tuples. */
1956
1957 int
gimple_call_flags(const_gimple stmt)1958 gimple_call_flags (const_gimple stmt)
1959 {
1960 int flags;
1961 tree decl = gimple_call_fndecl (stmt);
1962
1963 if (decl)
1964 flags = flags_from_decl_or_type (decl);
1965 else if (gimple_call_internal_p (stmt))
1966 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1967 else
1968 flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1969
1970 if (stmt->gsbase.subcode & GF_CALL_NOTHROW)
1971 flags |= ECF_NOTHROW;
1972
1973 return flags;
1974 }
1975
1976 /* Return the "fn spec" string for call STMT. */
1977
1978 static tree
gimple_call_fnspec(const_gimple stmt)1979 gimple_call_fnspec (const_gimple stmt)
1980 {
1981 tree type, attr;
1982
1983 type = gimple_call_fntype (stmt);
1984 if (!type)
1985 return NULL_TREE;
1986
1987 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1988 if (!attr)
1989 return NULL_TREE;
1990
1991 return TREE_VALUE (TREE_VALUE (attr));
1992 }
1993
1994 /* Detects argument flags for argument number ARG on call STMT. */
1995
1996 int
gimple_call_arg_flags(const_gimple stmt,unsigned arg)1997 gimple_call_arg_flags (const_gimple stmt, unsigned arg)
1998 {
1999 tree attr = gimple_call_fnspec (stmt);
2000
2001 if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
2002 return 0;
2003
2004 switch (TREE_STRING_POINTER (attr)[1 + arg])
2005 {
2006 case 'x':
2007 case 'X':
2008 return EAF_UNUSED;
2009
2010 case 'R':
2011 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
2012
2013 case 'r':
2014 return EAF_NOCLOBBER | EAF_NOESCAPE;
2015
2016 case 'W':
2017 return EAF_DIRECT | EAF_NOESCAPE;
2018
2019 case 'w':
2020 return EAF_NOESCAPE;
2021
2022 case '.':
2023 default:
2024 return 0;
2025 }
2026 }
2027
2028 /* Detects return flags for the call STMT. */
2029
2030 int
gimple_call_return_flags(const_gimple stmt)2031 gimple_call_return_flags (const_gimple stmt)
2032 {
2033 tree attr;
2034
2035 if (gimple_call_flags (stmt) & ECF_MALLOC)
2036 return ERF_NOALIAS;
2037
2038 attr = gimple_call_fnspec (stmt);
2039 if (!attr || TREE_STRING_LENGTH (attr) < 1)
2040 return 0;
2041
2042 switch (TREE_STRING_POINTER (attr)[0])
2043 {
2044 case '1':
2045 case '2':
2046 case '3':
2047 case '4':
2048 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
2049
2050 case 'm':
2051 return ERF_NOALIAS;
2052
2053 case '.':
2054 default:
2055 return 0;
2056 }
2057 }
2058
2059
2060 /* Return true if GS is a copy assignment. */
2061
2062 bool
gimple_assign_copy_p(gimple gs)2063 gimple_assign_copy_p (gimple gs)
2064 {
2065 return (gimple_assign_single_p (gs)
2066 && is_gimple_val (gimple_op (gs, 1)));
2067 }
2068
2069
2070 /* Return true if GS is a SSA_NAME copy assignment. */
2071
2072 bool
gimple_assign_ssa_name_copy_p(gimple gs)2073 gimple_assign_ssa_name_copy_p (gimple gs)
2074 {
2075 return (gimple_assign_single_p (gs)
2076 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
2077 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
2078 }
2079
2080
2081 /* Return true if GS is an assignment with a unary RHS, but the
2082 operator has no effect on the assigned value. The logic is adapted
2083 from STRIP_NOPS. This predicate is intended to be used in tuplifying
2084 instances in which STRIP_NOPS was previously applied to the RHS of
2085 an assignment.
2086
2087 NOTE: In the use cases that led to the creation of this function
2088 and of gimple_assign_single_p, it is typical to test for either
2089 condition and to proceed in the same manner. In each case, the
2090 assigned value is represented by the single RHS operand of the
2091 assignment. I suspect there may be cases where gimple_assign_copy_p,
2092 gimple_assign_single_p, or equivalent logic is used where a similar
2093 treatment of unary NOPs is appropriate. */
2094
2095 bool
gimple_assign_unary_nop_p(gimple gs)2096 gimple_assign_unary_nop_p (gimple gs)
2097 {
2098 return (is_gimple_assign (gs)
2099 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
2100 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
2101 && gimple_assign_rhs1 (gs) != error_mark_node
2102 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
2103 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
2104 }
2105
2106 /* Set BB to be the basic block holding G. */
2107
2108 void
gimple_set_bb(gimple stmt,basic_block bb)2109 gimple_set_bb (gimple stmt, basic_block bb)
2110 {
2111 stmt->gsbase.bb = bb;
2112
2113 /* If the statement is a label, add the label to block-to-labels map
2114 so that we can speed up edge creation for GIMPLE_GOTOs. */
2115 if (cfun->cfg && gimple_code (stmt) == GIMPLE_LABEL)
2116 {
2117 tree t;
2118 int uid;
2119
2120 t = gimple_label_label (stmt);
2121 uid = LABEL_DECL_UID (t);
2122 if (uid == -1)
2123 {
2124 unsigned old_len = VEC_length (basic_block, label_to_block_map);
2125 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
2126 if (old_len <= (unsigned) uid)
2127 {
2128 unsigned new_len = 3 * uid / 2 + 1;
2129
2130 VEC_safe_grow_cleared (basic_block, gc, label_to_block_map,
2131 new_len);
2132 }
2133 }
2134
2135 VEC_replace (basic_block, label_to_block_map, uid, bb);
2136 }
2137 }
2138
2139
2140 /* Modify the RHS of the assignment pointed-to by GSI using the
2141 operands in the expression tree EXPR.
2142
2143 NOTE: The statement pointed-to by GSI may be reallocated if it
2144 did not have enough operand slots.
2145
2146 This function is useful to convert an existing tree expression into
2147 the flat representation used for the RHS of a GIMPLE assignment.
2148 It will reallocate memory as needed to expand or shrink the number
2149 of operand slots needed to represent EXPR.
2150
2151 NOTE: If you find yourself building a tree and then calling this
2152 function, you are most certainly doing it the slow way. It is much
2153 better to build a new assignment or to use the function
2154 gimple_assign_set_rhs_with_ops, which does not require an
2155 expression tree to be built. */
2156
2157 void
gimple_assign_set_rhs_from_tree(gimple_stmt_iterator * gsi,tree expr)2158 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
2159 {
2160 enum tree_code subcode;
2161 tree op1, op2, op3;
2162
2163 extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3);
2164 gimple_assign_set_rhs_with_ops_1 (gsi, subcode, op1, op2, op3);
2165 }
2166
2167
2168 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
2169 operands OP1, OP2 and OP3.
2170
2171 NOTE: The statement pointed-to by GSI may be reallocated if it
2172 did not have enough operand slots. */
2173
2174 void
gimple_assign_set_rhs_with_ops_1(gimple_stmt_iterator * gsi,enum tree_code code,tree op1,tree op2,tree op3)2175 gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code,
2176 tree op1, tree op2, tree op3)
2177 {
2178 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
2179 gimple stmt = gsi_stmt (*gsi);
2180
2181 /* If the new CODE needs more operands, allocate a new statement. */
2182 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
2183 {
2184 tree lhs = gimple_assign_lhs (stmt);
2185 gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
2186 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
2187 gsi_replace (gsi, new_stmt, true);
2188 stmt = new_stmt;
2189
2190 /* The LHS needs to be reset as this also changes the SSA name
2191 on the LHS. */
2192 gimple_assign_set_lhs (stmt, lhs);
2193 }
2194
2195 gimple_set_num_ops (stmt, new_rhs_ops + 1);
2196 gimple_set_subcode (stmt, code);
2197 gimple_assign_set_rhs1 (stmt, op1);
2198 if (new_rhs_ops > 1)
2199 gimple_assign_set_rhs2 (stmt, op2);
2200 if (new_rhs_ops > 2)
2201 gimple_assign_set_rhs3 (stmt, op3);
2202 }
2203
2204
2205 /* Return the LHS of a statement that performs an assignment,
2206 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
2207 for a call to a function that returns no value, or for a
2208 statement other than an assignment or a call. */
2209
2210 tree
gimple_get_lhs(const_gimple stmt)2211 gimple_get_lhs (const_gimple stmt)
2212 {
2213 enum gimple_code code = gimple_code (stmt);
2214
2215 if (code == GIMPLE_ASSIGN)
2216 return gimple_assign_lhs (stmt);
2217 else if (code == GIMPLE_CALL)
2218 return gimple_call_lhs (stmt);
2219 else
2220 return NULL_TREE;
2221 }
2222
2223
2224 /* Set the LHS of a statement that performs an assignment,
2225 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2226
2227 void
gimple_set_lhs(gimple stmt,tree lhs)2228 gimple_set_lhs (gimple stmt, tree lhs)
2229 {
2230 enum gimple_code code = gimple_code (stmt);
2231
2232 if (code == GIMPLE_ASSIGN)
2233 gimple_assign_set_lhs (stmt, lhs);
2234 else if (code == GIMPLE_CALL)
2235 gimple_call_set_lhs (stmt, lhs);
2236 else
2237 gcc_unreachable();
2238 }
2239
2240 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
2241 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
2242 expression with a different value.
2243
2244 This will update any annotations (say debug bind stmts) referring
2245 to the original LHS, so that they use the RHS instead. This is
2246 done even if NLHS and LHS are the same, for it is understood that
2247 the RHS will be modified afterwards, and NLHS will not be assigned
2248 an equivalent value.
2249
2250 Adjusting any non-annotation uses of the LHS, if needed, is a
2251 responsibility of the caller.
2252
2253 The effect of this call should be pretty much the same as that of
2254 inserting a copy of STMT before STMT, and then removing the
2255 original stmt, at which time gsi_remove() would have update
2256 annotations, but using this function saves all the inserting,
2257 copying and removing. */
2258
2259 void
gimple_replace_lhs(gimple stmt,tree nlhs)2260 gimple_replace_lhs (gimple stmt, tree nlhs)
2261 {
2262 if (MAY_HAVE_DEBUG_STMTS)
2263 {
2264 tree lhs = gimple_get_lhs (stmt);
2265
2266 gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
2267
2268 insert_debug_temp_for_var_def (NULL, lhs);
2269 }
2270
2271 gimple_set_lhs (stmt, nlhs);
2272 }
2273
2274 /* Return a deep copy of statement STMT. All the operands from STMT
2275 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
2276 and VUSE operand arrays are set to empty in the new copy. */
2277
2278 gimple
gimple_copy(gimple stmt)2279 gimple_copy (gimple stmt)
2280 {
2281 enum gimple_code code = gimple_code (stmt);
2282 unsigned num_ops = gimple_num_ops (stmt);
2283 gimple copy = gimple_alloc (code, num_ops);
2284 unsigned i;
2285
2286 /* Shallow copy all the fields from STMT. */
2287 memcpy (copy, stmt, gimple_size (code));
2288
2289 /* If STMT has sub-statements, deep-copy them as well. */
2290 if (gimple_has_substatements (stmt))
2291 {
2292 gimple_seq new_seq;
2293 tree t;
2294
2295 switch (gimple_code (stmt))
2296 {
2297 case GIMPLE_BIND:
2298 new_seq = gimple_seq_copy (gimple_bind_body (stmt));
2299 gimple_bind_set_body (copy, new_seq);
2300 gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
2301 gimple_bind_set_block (copy, gimple_bind_block (stmt));
2302 break;
2303
2304 case GIMPLE_CATCH:
2305 new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
2306 gimple_catch_set_handler (copy, new_seq);
2307 t = unshare_expr (gimple_catch_types (stmt));
2308 gimple_catch_set_types (copy, t);
2309 break;
2310
2311 case GIMPLE_EH_FILTER:
2312 new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
2313 gimple_eh_filter_set_failure (copy, new_seq);
2314 t = unshare_expr (gimple_eh_filter_types (stmt));
2315 gimple_eh_filter_set_types (copy, t);
2316 break;
2317
2318 case GIMPLE_EH_ELSE:
2319 new_seq = gimple_seq_copy (gimple_eh_else_n_body (stmt));
2320 gimple_eh_else_set_n_body (copy, new_seq);
2321 new_seq = gimple_seq_copy (gimple_eh_else_e_body (stmt));
2322 gimple_eh_else_set_e_body (copy, new_seq);
2323 break;
2324
2325 case GIMPLE_TRY:
2326 new_seq = gimple_seq_copy (gimple_try_eval (stmt));
2327 gimple_try_set_eval (copy, new_seq);
2328 new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
2329 gimple_try_set_cleanup (copy, new_seq);
2330 break;
2331
2332 case GIMPLE_OMP_FOR:
2333 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
2334 gimple_omp_for_set_pre_body (copy, new_seq);
2335 t = unshare_expr (gimple_omp_for_clauses (stmt));
2336 gimple_omp_for_set_clauses (copy, t);
2337 copy->gimple_omp_for.iter
2338 = ggc_alloc_vec_gimple_omp_for_iter
2339 (gimple_omp_for_collapse (stmt));
2340 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
2341 {
2342 gimple_omp_for_set_cond (copy, i,
2343 gimple_omp_for_cond (stmt, i));
2344 gimple_omp_for_set_index (copy, i,
2345 gimple_omp_for_index (stmt, i));
2346 t = unshare_expr (gimple_omp_for_initial (stmt, i));
2347 gimple_omp_for_set_initial (copy, i, t);
2348 t = unshare_expr (gimple_omp_for_final (stmt, i));
2349 gimple_omp_for_set_final (copy, i, t);
2350 t = unshare_expr (gimple_omp_for_incr (stmt, i));
2351 gimple_omp_for_set_incr (copy, i, t);
2352 }
2353 goto copy_omp_body;
2354
2355 case GIMPLE_OMP_PARALLEL:
2356 t = unshare_expr (gimple_omp_parallel_clauses (stmt));
2357 gimple_omp_parallel_set_clauses (copy, t);
2358 t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
2359 gimple_omp_parallel_set_child_fn (copy, t);
2360 t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
2361 gimple_omp_parallel_set_data_arg (copy, t);
2362 goto copy_omp_body;
2363
2364 case GIMPLE_OMP_TASK:
2365 t = unshare_expr (gimple_omp_task_clauses (stmt));
2366 gimple_omp_task_set_clauses (copy, t);
2367 t = unshare_expr (gimple_omp_task_child_fn (stmt));
2368 gimple_omp_task_set_child_fn (copy, t);
2369 t = unshare_expr (gimple_omp_task_data_arg (stmt));
2370 gimple_omp_task_set_data_arg (copy, t);
2371 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
2372 gimple_omp_task_set_copy_fn (copy, t);
2373 t = unshare_expr (gimple_omp_task_arg_size (stmt));
2374 gimple_omp_task_set_arg_size (copy, t);
2375 t = unshare_expr (gimple_omp_task_arg_align (stmt));
2376 gimple_omp_task_set_arg_align (copy, t);
2377 goto copy_omp_body;
2378
2379 case GIMPLE_OMP_CRITICAL:
2380 t = unshare_expr (gimple_omp_critical_name (stmt));
2381 gimple_omp_critical_set_name (copy, t);
2382 goto copy_omp_body;
2383
2384 case GIMPLE_OMP_SECTIONS:
2385 t = unshare_expr (gimple_omp_sections_clauses (stmt));
2386 gimple_omp_sections_set_clauses (copy, t);
2387 t = unshare_expr (gimple_omp_sections_control (stmt));
2388 gimple_omp_sections_set_control (copy, t);
2389 /* FALLTHRU */
2390
2391 case GIMPLE_OMP_SINGLE:
2392 case GIMPLE_OMP_SECTION:
2393 case GIMPLE_OMP_MASTER:
2394 case GIMPLE_OMP_ORDERED:
2395 copy_omp_body:
2396 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2397 gimple_omp_set_body (copy, new_seq);
2398 break;
2399
2400 case GIMPLE_TRANSACTION:
2401 new_seq = gimple_seq_copy (gimple_transaction_body (stmt));
2402 gimple_transaction_set_body (copy, new_seq);
2403 break;
2404
2405 case GIMPLE_WITH_CLEANUP_EXPR:
2406 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2407 gimple_wce_set_cleanup (copy, new_seq);
2408 break;
2409
2410 default:
2411 gcc_unreachable ();
2412 }
2413 }
2414
2415 /* Make copy of operands. */
2416 if (num_ops > 0)
2417 {
2418 for (i = 0; i < num_ops; i++)
2419 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2420
2421 /* Clear out SSA operand vectors on COPY. */
2422 if (gimple_has_ops (stmt))
2423 {
2424 gimple_set_def_ops (copy, NULL);
2425 gimple_set_use_ops (copy, NULL);
2426 }
2427
2428 if (gimple_has_mem_ops (stmt))
2429 {
2430 gimple_set_vdef (copy, gimple_vdef (stmt));
2431 gimple_set_vuse (copy, gimple_vuse (stmt));
2432 }
2433
2434 /* SSA operands need to be updated. */
2435 gimple_set_modified (copy, true);
2436 }
2437
2438 return copy;
2439 }
2440
2441
2442 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2443 a MODIFIED field. */
2444
2445 void
gimple_set_modified(gimple s,bool modifiedp)2446 gimple_set_modified (gimple s, bool modifiedp)
2447 {
2448 if (gimple_has_ops (s))
2449 s->gsbase.modified = (unsigned) modifiedp;
2450 }
2451
2452
2453 /* Return true if statement S has side-effects. We consider a
2454 statement to have side effects if:
2455
2456 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2457 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2458
2459 bool
gimple_has_side_effects(const_gimple s)2460 gimple_has_side_effects (const_gimple s)
2461 {
2462 if (is_gimple_debug (s))
2463 return false;
2464
2465 /* We don't have to scan the arguments to check for
2466 volatile arguments, though, at present, we still
2467 do a scan to check for TREE_SIDE_EFFECTS. */
2468 if (gimple_has_volatile_ops (s))
2469 return true;
2470
2471 if (gimple_code (s) == GIMPLE_ASM
2472 && gimple_asm_volatile_p (s))
2473 return true;
2474
2475 if (is_gimple_call (s))
2476 {
2477 int flags = gimple_call_flags (s);
2478
2479 /* An infinite loop is considered a side effect. */
2480 if (!(flags & (ECF_CONST | ECF_PURE))
2481 || (flags & ECF_LOOPING_CONST_OR_PURE))
2482 return true;
2483
2484 return false;
2485 }
2486
2487 return false;
2488 }
2489
2490 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2491 Return true if S can trap. When INCLUDE_MEM is true, check whether
2492 the memory operations could trap. When INCLUDE_STORES is true and
2493 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2494
2495 bool
gimple_could_trap_p_1(gimple s,bool include_mem,bool include_stores)2496 gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
2497 {
2498 tree t, div = NULL_TREE;
2499 enum tree_code op;
2500
2501 if (include_mem)
2502 {
2503 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
2504
2505 for (i = start; i < gimple_num_ops (s); i++)
2506 if (tree_could_trap_p (gimple_op (s, i)))
2507 return true;
2508 }
2509
2510 switch (gimple_code (s))
2511 {
2512 case GIMPLE_ASM:
2513 return gimple_asm_volatile_p (s);
2514
2515 case GIMPLE_CALL:
2516 t = gimple_call_fndecl (s);
2517 /* Assume that calls to weak functions may trap. */
2518 if (!t || !DECL_P (t) || DECL_WEAK (t))
2519 return true;
2520 return false;
2521
2522 case GIMPLE_ASSIGN:
2523 t = gimple_expr_type (s);
2524 op = gimple_assign_rhs_code (s);
2525 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2526 div = gimple_assign_rhs2 (s);
2527 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2528 (INTEGRAL_TYPE_P (t)
2529 && TYPE_OVERFLOW_TRAPS (t)),
2530 div));
2531
2532 default:
2533 break;
2534 }
2535
2536 return false;
2537 }
2538
2539 /* Return true if statement S can trap. */
2540
2541 bool
gimple_could_trap_p(gimple s)2542 gimple_could_trap_p (gimple s)
2543 {
2544 return gimple_could_trap_p_1 (s, true, true);
2545 }
2546
2547 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2548
2549 bool
gimple_assign_rhs_could_trap_p(gimple s)2550 gimple_assign_rhs_could_trap_p (gimple s)
2551 {
2552 gcc_assert (is_gimple_assign (s));
2553 return gimple_could_trap_p_1 (s, true, false);
2554 }
2555
2556
2557 /* Print debugging information for gimple stmts generated. */
2558
2559 void
dump_gimple_statistics(void)2560 dump_gimple_statistics (void)
2561 {
2562 #ifdef GATHER_STATISTICS
2563 int i, total_tuples = 0, total_bytes = 0;
2564
2565 fprintf (stderr, "\nGIMPLE statements\n");
2566 fprintf (stderr, "Kind Stmts Bytes\n");
2567 fprintf (stderr, "---------------------------------------\n");
2568 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2569 {
2570 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2571 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2572 total_tuples += gimple_alloc_counts[i];
2573 total_bytes += gimple_alloc_sizes[i];
2574 }
2575 fprintf (stderr, "---------------------------------------\n");
2576 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2577 fprintf (stderr, "---------------------------------------\n");
2578 #else
2579 fprintf (stderr, "No gimple statistics\n");
2580 #endif
2581 }
2582
2583
2584 /* Return the number of operands needed on the RHS of a GIMPLE
2585 assignment for an expression with tree code CODE. */
2586
2587 unsigned
get_gimple_rhs_num_ops(enum tree_code code)2588 get_gimple_rhs_num_ops (enum tree_code code)
2589 {
2590 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2591
2592 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2593 return 1;
2594 else if (rhs_class == GIMPLE_BINARY_RHS)
2595 return 2;
2596 else if (rhs_class == GIMPLE_TERNARY_RHS)
2597 return 3;
2598 else
2599 gcc_unreachable ();
2600 }
2601
2602 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2603 (unsigned char) \
2604 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2605 : ((TYPE) == tcc_binary \
2606 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2607 : ((TYPE) == tcc_constant \
2608 || (TYPE) == tcc_declaration \
2609 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2610 : ((SYM) == TRUTH_AND_EXPR \
2611 || (SYM) == TRUTH_OR_EXPR \
2612 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2613 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2614 : ((SYM) == COND_EXPR \
2615 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2616 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2617 || (SYM) == DOT_PROD_EXPR \
2618 || (SYM) == REALIGN_LOAD_EXPR \
2619 || (SYM) == VEC_COND_EXPR \
2620 || (SYM) == VEC_PERM_EXPR \
2621 || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS \
2622 : ((SYM) == CONSTRUCTOR \
2623 || (SYM) == OBJ_TYPE_REF \
2624 || (SYM) == ASSERT_EXPR \
2625 || (SYM) == ADDR_EXPR \
2626 || (SYM) == WITH_SIZE_EXPR \
2627 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2628 : GIMPLE_INVALID_RHS),
2629 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2630
2631 const unsigned char gimple_rhs_class_table[] = {
2632 #include "all-tree.def"
2633 };
2634
2635 #undef DEFTREECODE
2636 #undef END_OF_BASE_TREE_CODES
2637
2638 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
2639
2640 /* Validation of GIMPLE expressions. */
2641
2642 /* Returns true iff T is a valid RHS for an assignment to a renamed
2643 user -- or front-end generated artificial -- variable. */
2644
2645 bool
is_gimple_reg_rhs(tree t)2646 is_gimple_reg_rhs (tree t)
2647 {
2648 return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
2649 }
2650
2651 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
2652 LHS, or for a call argument. */
2653
2654 bool
is_gimple_mem_rhs(tree t)2655 is_gimple_mem_rhs (tree t)
2656 {
2657 /* If we're dealing with a renamable type, either source or dest must be
2658 a renamed variable. */
2659 if (is_gimple_reg_type (TREE_TYPE (t)))
2660 return is_gimple_val (t);
2661 else
2662 return is_gimple_val (t) || is_gimple_lvalue (t);
2663 }
2664
2665 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
2666
2667 bool
is_gimple_lvalue(tree t)2668 is_gimple_lvalue (tree t)
2669 {
2670 return (is_gimple_addressable (t)
2671 || TREE_CODE (t) == WITH_SIZE_EXPR
2672 /* These are complex lvalues, but don't have addresses, so they
2673 go here. */
2674 || TREE_CODE (t) == BIT_FIELD_REF);
2675 }
2676
2677 /* Return true if T is a GIMPLE condition. */
2678
2679 bool
is_gimple_condexpr(tree t)2680 is_gimple_condexpr (tree t)
2681 {
2682 return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
2683 && !tree_could_throw_p (t)
2684 && is_gimple_val (TREE_OPERAND (t, 0))
2685 && is_gimple_val (TREE_OPERAND (t, 1))));
2686 }
2687
2688 /* Return true if T is something whose address can be taken. */
2689
2690 bool
is_gimple_addressable(tree t)2691 is_gimple_addressable (tree t)
2692 {
2693 return (is_gimple_id (t) || handled_component_p (t)
2694 || TREE_CODE (t) == MEM_REF);
2695 }
2696
2697 /* Return true if T is a valid gimple constant. */
2698
2699 bool
is_gimple_constant(const_tree t)2700 is_gimple_constant (const_tree t)
2701 {
2702 switch (TREE_CODE (t))
2703 {
2704 case INTEGER_CST:
2705 case REAL_CST:
2706 case FIXED_CST:
2707 case STRING_CST:
2708 case COMPLEX_CST:
2709 case VECTOR_CST:
2710 return true;
2711
2712 /* Vector constant constructors are gimple invariant. */
2713 case CONSTRUCTOR:
2714 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2715 return TREE_CONSTANT (t);
2716 else
2717 return false;
2718
2719 default:
2720 return false;
2721 }
2722 }
2723
2724 /* Return true if T is a gimple address. */
2725
2726 bool
is_gimple_address(const_tree t)2727 is_gimple_address (const_tree t)
2728 {
2729 tree op;
2730
2731 if (TREE_CODE (t) != ADDR_EXPR)
2732 return false;
2733
2734 op = TREE_OPERAND (t, 0);
2735 while (handled_component_p (op))
2736 {
2737 if ((TREE_CODE (op) == ARRAY_REF
2738 || TREE_CODE (op) == ARRAY_RANGE_REF)
2739 && !is_gimple_val (TREE_OPERAND (op, 1)))
2740 return false;
2741
2742 op = TREE_OPERAND (op, 0);
2743 }
2744
2745 if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF)
2746 return true;
2747
2748 switch (TREE_CODE (op))
2749 {
2750 case PARM_DECL:
2751 case RESULT_DECL:
2752 case LABEL_DECL:
2753 case FUNCTION_DECL:
2754 case VAR_DECL:
2755 case CONST_DECL:
2756 return true;
2757
2758 default:
2759 return false;
2760 }
2761 }
2762
2763 /* Return true if T is a gimple invariant address. */
2764
2765 bool
is_gimple_invariant_address(const_tree t)2766 is_gimple_invariant_address (const_tree t)
2767 {
2768 const_tree op;
2769
2770 if (TREE_CODE (t) != ADDR_EXPR)
2771 return false;
2772
2773 op = strip_invariant_refs (TREE_OPERAND (t, 0));
2774 if (!op)
2775 return false;
2776
2777 if (TREE_CODE (op) == MEM_REF)
2778 {
2779 const_tree op0 = TREE_OPERAND (op, 0);
2780 return (TREE_CODE (op0) == ADDR_EXPR
2781 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
2782 || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
2783 }
2784
2785 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2786 }
2787
2788 /* Return true if T is a gimple invariant address at IPA level
2789 (so addresses of variables on stack are not allowed). */
2790
2791 bool
is_gimple_ip_invariant_address(const_tree t)2792 is_gimple_ip_invariant_address (const_tree t)
2793 {
2794 const_tree op;
2795
2796 if (TREE_CODE (t) != ADDR_EXPR)
2797 return false;
2798
2799 op = strip_invariant_refs (TREE_OPERAND (t, 0));
2800 if (!op)
2801 return false;
2802
2803 if (TREE_CODE (op) == MEM_REF)
2804 {
2805 const_tree op0 = TREE_OPERAND (op, 0);
2806 return (TREE_CODE (op0) == ADDR_EXPR
2807 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
2808 || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0))));
2809 }
2810
2811 return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op);
2812 }
2813
2814 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
2815 form of function invariant. */
2816
2817 bool
is_gimple_min_invariant(const_tree t)2818 is_gimple_min_invariant (const_tree t)
2819 {
2820 if (TREE_CODE (t) == ADDR_EXPR)
2821 return is_gimple_invariant_address (t);
2822
2823 return is_gimple_constant (t);
2824 }
2825
2826 /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
2827 form of gimple minimal invariant. */
2828
2829 bool
is_gimple_ip_invariant(const_tree t)2830 is_gimple_ip_invariant (const_tree t)
2831 {
2832 if (TREE_CODE (t) == ADDR_EXPR)
2833 return is_gimple_ip_invariant_address (t);
2834
2835 return is_gimple_constant (t);
2836 }
2837
2838 /* Return true if T looks like a valid GIMPLE statement. */
2839
2840 bool
is_gimple_stmt(tree t)2841 is_gimple_stmt (tree t)
2842 {
2843 const enum tree_code code = TREE_CODE (t);
2844
2845 switch (code)
2846 {
2847 case NOP_EXPR:
2848 /* The only valid NOP_EXPR is the empty statement. */
2849 return IS_EMPTY_STMT (t);
2850
2851 case BIND_EXPR:
2852 case COND_EXPR:
2853 /* These are only valid if they're void. */
2854 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
2855
2856 case SWITCH_EXPR:
2857 case GOTO_EXPR:
2858 case RETURN_EXPR:
2859 case LABEL_EXPR:
2860 case CASE_LABEL_EXPR:
2861 case TRY_CATCH_EXPR:
2862 case TRY_FINALLY_EXPR:
2863 case EH_FILTER_EXPR:
2864 case CATCH_EXPR:
2865 case ASM_EXPR:
2866 case STATEMENT_LIST:
2867 case OMP_PARALLEL:
2868 case OMP_FOR:
2869 case OMP_SECTIONS:
2870 case OMP_SECTION:
2871 case OMP_SINGLE:
2872 case OMP_MASTER:
2873 case OMP_ORDERED:
2874 case OMP_CRITICAL:
2875 case OMP_TASK:
2876 /* These are always void. */
2877 return true;
2878
2879 case CALL_EXPR:
2880 case MODIFY_EXPR:
2881 case PREDICT_EXPR:
2882 /* These are valid regardless of their type. */
2883 return true;
2884
2885 default:
2886 return false;
2887 }
2888 }
2889
2890 /* Return true if T is a variable. */
2891
2892 bool
is_gimple_variable(tree t)2893 is_gimple_variable (tree t)
2894 {
2895 return (TREE_CODE (t) == VAR_DECL
2896 || TREE_CODE (t) == PARM_DECL
2897 || TREE_CODE (t) == RESULT_DECL
2898 || TREE_CODE (t) == SSA_NAME);
2899 }
2900
2901 /* Return true if T is a GIMPLE identifier (something with an address). */
2902
2903 bool
is_gimple_id(tree t)2904 is_gimple_id (tree t)
2905 {
2906 return (is_gimple_variable (t)
2907 || TREE_CODE (t) == FUNCTION_DECL
2908 || TREE_CODE (t) == LABEL_DECL
2909 || TREE_CODE (t) == CONST_DECL
2910 /* Allow string constants, since they are addressable. */
2911 || TREE_CODE (t) == STRING_CST);
2912 }
2913
2914 /* Return true if T is a non-aggregate register variable. */
2915
2916 bool
is_gimple_reg(tree t)2917 is_gimple_reg (tree t)
2918 {
2919 if (TREE_CODE (t) == SSA_NAME)
2920 t = SSA_NAME_VAR (t);
2921
2922 if (!is_gimple_variable (t))
2923 return false;
2924
2925 if (!is_gimple_reg_type (TREE_TYPE (t)))
2926 return false;
2927
2928 /* A volatile decl is not acceptable because we can't reuse it as
2929 needed. We need to copy it into a temp first. */
2930 if (TREE_THIS_VOLATILE (t))
2931 return false;
2932
2933 /* We define "registers" as things that can be renamed as needed,
2934 which with our infrastructure does not apply to memory. */
2935 if (needs_to_live_in_memory (t))
2936 return false;
2937
2938 /* Hard register variables are an interesting case. For those that
2939 are call-clobbered, we don't know where all the calls are, since
2940 we don't (want to) take into account which operations will turn
2941 into libcalls at the rtl level. For those that are call-saved,
2942 we don't currently model the fact that calls may in fact change
2943 global hard registers, nor do we examine ASM_CLOBBERS at the tree
2944 level, and so miss variable changes that might imply. All around,
2945 it seems safest to not do too much optimization with these at the
2946 tree level at all. We'll have to rely on the rtl optimizers to
2947 clean this up, as there we've got all the appropriate bits exposed. */
2948 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2949 return false;
2950
2951 /* Complex and vector values must have been put into SSA-like form.
2952 That is, no assignments to the individual components. */
2953 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
2954 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2955 return DECL_GIMPLE_REG_P (t);
2956
2957 return true;
2958 }
2959
2960
2961 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
2962
2963 bool
is_gimple_val(tree t)2964 is_gimple_val (tree t)
2965 {
2966 /* Make loads from volatiles and memory vars explicit. */
2967 if (is_gimple_variable (t)
2968 && is_gimple_reg_type (TREE_TYPE (t))
2969 && !is_gimple_reg (t))
2970 return false;
2971
2972 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
2973 }
2974
2975 /* Similarly, but accept hard registers as inputs to asm statements. */
2976
2977 bool
is_gimple_asm_val(tree t)2978 is_gimple_asm_val (tree t)
2979 {
2980 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2981 return true;
2982
2983 return is_gimple_val (t);
2984 }
2985
2986 /* Return true if T is a GIMPLE minimal lvalue. */
2987
2988 bool
is_gimple_min_lval(tree t)2989 is_gimple_min_lval (tree t)
2990 {
2991 if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
2992 return false;
2993 return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
2994 }
2995
2996 /* Return true if T is a valid function operand of a CALL_EXPR. */
2997
2998 bool
is_gimple_call_addr(tree t)2999 is_gimple_call_addr (tree t)
3000 {
3001 return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
3002 }
3003
3004 /* Return true if T is a valid address operand of a MEM_REF. */
3005
3006 bool
is_gimple_mem_ref_addr(tree t)3007 is_gimple_mem_ref_addr (tree t)
3008 {
3009 return (is_gimple_reg (t)
3010 || TREE_CODE (t) == INTEGER_CST
3011 || (TREE_CODE (t) == ADDR_EXPR
3012 && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
3013 || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
3014 }
3015
3016
3017 /* Given a memory reference expression T, return its base address.
3018 The base address of a memory reference expression is the main
3019 object being referenced. For instance, the base address for
3020 'array[i].fld[j]' is 'array'. You can think of this as stripping
3021 away the offset part from a memory address.
3022
3023 This function calls handled_component_p to strip away all the inner
3024 parts of the memory reference until it reaches the base object. */
3025
3026 tree
get_base_address(tree t)3027 get_base_address (tree t)
3028 {
3029 while (handled_component_p (t))
3030 t = TREE_OPERAND (t, 0);
3031
3032 if ((TREE_CODE (t) == MEM_REF
3033 || TREE_CODE (t) == TARGET_MEM_REF)
3034 && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
3035 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
3036
3037 if (TREE_CODE (t) == SSA_NAME
3038 || DECL_P (t)
3039 || TREE_CODE (t) == STRING_CST
3040 || TREE_CODE (t) == CONSTRUCTOR
3041 || INDIRECT_REF_P (t)
3042 || TREE_CODE (t) == MEM_REF
3043 || TREE_CODE (t) == TARGET_MEM_REF)
3044 return t;
3045 else
3046 return NULL_TREE;
3047 }
3048
3049 void
recalculate_side_effects(tree t)3050 recalculate_side_effects (tree t)
3051 {
3052 enum tree_code code = TREE_CODE (t);
3053 int len = TREE_OPERAND_LENGTH (t);
3054 int i;
3055
3056 switch (TREE_CODE_CLASS (code))
3057 {
3058 case tcc_expression:
3059 switch (code)
3060 {
3061 case INIT_EXPR:
3062 case MODIFY_EXPR:
3063 case VA_ARG_EXPR:
3064 case PREDECREMENT_EXPR:
3065 case PREINCREMENT_EXPR:
3066 case POSTDECREMENT_EXPR:
3067 case POSTINCREMENT_EXPR:
3068 /* All of these have side-effects, no matter what their
3069 operands are. */
3070 return;
3071
3072 default:
3073 break;
3074 }
3075 /* Fall through. */
3076
3077 case tcc_comparison: /* a comparison expression */
3078 case tcc_unary: /* a unary arithmetic expression */
3079 case tcc_binary: /* a binary arithmetic expression */
3080 case tcc_reference: /* a reference */
3081 case tcc_vl_exp: /* a function call */
3082 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
3083 for (i = 0; i < len; ++i)
3084 {
3085 tree op = TREE_OPERAND (t, i);
3086 if (op && TREE_SIDE_EFFECTS (op))
3087 TREE_SIDE_EFFECTS (t) = 1;
3088 }
3089 break;
3090
3091 case tcc_constant:
3092 /* No side-effects. */
3093 return;
3094
3095 default:
3096 gcc_unreachable ();
3097 }
3098 }
3099
3100 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
3101 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
3102 we failed to create one. */
3103
3104 tree
canonicalize_cond_expr_cond(tree t)3105 canonicalize_cond_expr_cond (tree t)
3106 {
3107 /* Strip conversions around boolean operations. */
3108 if (CONVERT_EXPR_P (t)
3109 && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
3110 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
3111 == BOOLEAN_TYPE))
3112 t = TREE_OPERAND (t, 0);
3113
3114 /* For !x use x == 0. */
3115 if (TREE_CODE (t) == TRUTH_NOT_EXPR)
3116 {
3117 tree top0 = TREE_OPERAND (t, 0);
3118 t = build2 (EQ_EXPR, TREE_TYPE (t),
3119 top0, build_int_cst (TREE_TYPE (top0), 0));
3120 }
3121 /* For cmp ? 1 : 0 use cmp. */
3122 else if (TREE_CODE (t) == COND_EXPR
3123 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
3124 && integer_onep (TREE_OPERAND (t, 1))
3125 && integer_zerop (TREE_OPERAND (t, 2)))
3126 {
3127 tree top0 = TREE_OPERAND (t, 0);
3128 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
3129 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
3130 }
3131
3132 if (is_gimple_condexpr (t))
3133 return t;
3134
3135 return NULL_TREE;
3136 }
3137
3138 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
3139 the positions marked by the set ARGS_TO_SKIP. */
3140
3141 gimple
gimple_call_copy_skip_args(gimple stmt,bitmap args_to_skip)3142 gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
3143 {
3144 int i;
3145 int nargs = gimple_call_num_args (stmt);
3146 VEC(tree, heap) *vargs = VEC_alloc (tree, heap, nargs);
3147 gimple new_stmt;
3148
3149 for (i = 0; i < nargs; i++)
3150 if (!bitmap_bit_p (args_to_skip, i))
3151 VEC_quick_push (tree, vargs, gimple_call_arg (stmt, i));
3152
3153 if (gimple_call_internal_p (stmt))
3154 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
3155 vargs);
3156 else
3157 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
3158 VEC_free (tree, heap, vargs);
3159 if (gimple_call_lhs (stmt))
3160 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
3161
3162 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
3163 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
3164
3165 gimple_set_block (new_stmt, gimple_block (stmt));
3166 if (gimple_has_location (stmt))
3167 gimple_set_location (new_stmt, gimple_location (stmt));
3168 gimple_call_copy_flags (new_stmt, stmt);
3169 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
3170
3171 gimple_set_modified (new_stmt, true);
3172
3173 return new_stmt;
3174 }
3175
3176
3177 enum gtc_mode { GTC_MERGE = 0, GTC_DIAG = 1 };
3178
3179 static hashval_t gimple_type_hash (const void *);
3180
3181 /* Structure used to maintain a cache of some type pairs compared by
3182 gimple_types_compatible_p when comparing aggregate types. There are
3183 three possible values for SAME_P:
3184
3185 -2: The pair (T1, T2) has just been inserted in the table.
3186 0: T1 and T2 are different types.
3187 1: T1 and T2 are the same type.
3188
3189 The two elements in the SAME_P array are indexed by the comparison
3190 mode gtc_mode. */
3191
3192 struct type_pair_d
3193 {
3194 unsigned int uid1;
3195 unsigned int uid2;
3196 signed char same_p[2];
3197 };
3198 typedef struct type_pair_d *type_pair_t;
3199 DEF_VEC_P(type_pair_t);
3200 DEF_VEC_ALLOC_P(type_pair_t,heap);
3201
3202 #define GIMPLE_TYPE_PAIR_SIZE 16381
3203 struct type_pair_d *type_pair_cache;
3204
3205
3206 /* Lookup the pair of types T1 and T2 in *VISITED_P. Insert a new
3207 entry if none existed. */
3208
3209 static inline type_pair_t
lookup_type_pair(tree t1,tree t2)3210 lookup_type_pair (tree t1, tree t2)
3211 {
3212 unsigned int index;
3213 unsigned int uid1, uid2;
3214
3215 if (type_pair_cache == NULL)
3216 type_pair_cache = XCNEWVEC (struct type_pair_d, GIMPLE_TYPE_PAIR_SIZE);
3217
3218 if (TYPE_UID (t1) < TYPE_UID (t2))
3219 {
3220 uid1 = TYPE_UID (t1);
3221 uid2 = TYPE_UID (t2);
3222 }
3223 else
3224 {
3225 uid1 = TYPE_UID (t2);
3226 uid2 = TYPE_UID (t1);
3227 }
3228 gcc_checking_assert (uid1 != uid2);
3229
3230 /* iterative_hash_hashval_t imply an function calls.
3231 We know that UIDS are in limited range. */
3232 index = ((((unsigned HOST_WIDE_INT)uid1 << HOST_BITS_PER_WIDE_INT / 2) + uid2)
3233 % GIMPLE_TYPE_PAIR_SIZE);
3234 if (type_pair_cache [index].uid1 == uid1
3235 && type_pair_cache [index].uid2 == uid2)
3236 return &type_pair_cache[index];
3237
3238 type_pair_cache [index].uid1 = uid1;
3239 type_pair_cache [index].uid2 = uid2;
3240 type_pair_cache [index].same_p[0] = -2;
3241 type_pair_cache [index].same_p[1] = -2;
3242
3243 return &type_pair_cache[index];
3244 }
3245
3246 /* Per pointer state for the SCC finding. The on_sccstack flag
3247 is not strictly required, it is true when there is no hash value
3248 recorded for the type and false otherwise. But querying that
3249 is slower. */
3250
3251 struct sccs
3252 {
3253 unsigned int dfsnum;
3254 unsigned int low;
3255 bool on_sccstack;
3256 union {
3257 hashval_t hash;
3258 signed char same_p;
3259 } u;
3260 };
3261
3262 static unsigned int next_dfs_num;
3263 static unsigned int gtc_next_dfs_num;
3264
3265
3266 /* GIMPLE type merging cache. A direct-mapped cache based on TYPE_UID. */
3267
3268 typedef struct GTY(()) gimple_type_leader_entry_s {
3269 tree type;
3270 tree leader;
3271 } gimple_type_leader_entry;
3272
3273 #define GIMPLE_TYPE_LEADER_SIZE 16381
3274 static GTY((deletable, length("GIMPLE_TYPE_LEADER_SIZE")))
3275 gimple_type_leader_entry *gimple_type_leader;
3276
3277 /* Lookup an existing leader for T and return it or NULL_TREE, if
3278 there is none in the cache. */
3279
3280 static inline tree
gimple_lookup_type_leader(tree t)3281 gimple_lookup_type_leader (tree t)
3282 {
3283 gimple_type_leader_entry *leader;
3284
3285 if (!gimple_type_leader)
3286 return NULL_TREE;
3287
3288 leader = &gimple_type_leader[TYPE_UID (t) % GIMPLE_TYPE_LEADER_SIZE];
3289 if (leader->type != t)
3290 return NULL_TREE;
3291
3292 return leader->leader;
3293 }
3294
3295 /* Return true if T1 and T2 have the same name. If FOR_COMPLETION_P is
3296 true then if any type has no name return false, otherwise return
3297 true if both types have no names. */
3298
3299 static bool
compare_type_names_p(tree t1,tree t2)3300 compare_type_names_p (tree t1, tree t2)
3301 {
3302 tree name1 = TYPE_NAME (t1);
3303 tree name2 = TYPE_NAME (t2);
3304
3305 if ((name1 != NULL_TREE) != (name2 != NULL_TREE))
3306 return false;
3307
3308 if (name1 == NULL_TREE)
3309 return true;
3310
3311 /* Either both should be a TYPE_DECL or both an IDENTIFIER_NODE. */
3312 if (TREE_CODE (name1) != TREE_CODE (name2))
3313 return false;
3314
3315 if (TREE_CODE (name1) == TYPE_DECL)
3316 name1 = DECL_NAME (name1);
3317 gcc_checking_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE);
3318
3319 if (TREE_CODE (name2) == TYPE_DECL)
3320 name2 = DECL_NAME (name2);
3321 gcc_checking_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE);
3322
3323 /* Identifiers can be compared with pointer equality rather
3324 than a string comparison. */
3325 if (name1 == name2)
3326 return true;
3327
3328 return false;
3329 }
3330
3331 /* Return true if the field decls F1 and F2 are at the same offset.
3332
3333 This is intended to be used on GIMPLE types only. */
3334
3335 bool
gimple_compare_field_offset(tree f1,tree f2)3336 gimple_compare_field_offset (tree f1, tree f2)
3337 {
3338 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
3339 {
3340 tree offset1 = DECL_FIELD_OFFSET (f1);
3341 tree offset2 = DECL_FIELD_OFFSET (f2);
3342 return ((offset1 == offset2
3343 /* Once gimplification is done, self-referential offsets are
3344 instantiated as operand #2 of the COMPONENT_REF built for
3345 each access and reset. Therefore, they are not relevant
3346 anymore and fields are interchangeable provided that they
3347 represent the same access. */
3348 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
3349 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
3350 && (DECL_SIZE (f1) == DECL_SIZE (f2)
3351 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
3352 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
3353 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
3354 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
3355 || operand_equal_p (offset1, offset2, 0))
3356 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
3357 DECL_FIELD_BIT_OFFSET (f2)));
3358 }
3359
3360 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
3361 should be, so handle differing ones specially by decomposing
3362 the offset into a byte and bit offset manually. */
3363 if (host_integerp (DECL_FIELD_OFFSET (f1), 0)
3364 && host_integerp (DECL_FIELD_OFFSET (f2), 0))
3365 {
3366 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
3367 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
3368 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
3369 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
3370 + bit_offset1 / BITS_PER_UNIT);
3371 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
3372 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
3373 + bit_offset2 / BITS_PER_UNIT);
3374 if (byte_offset1 != byte_offset2)
3375 return false;
3376 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
3377 }
3378
3379 return false;
3380 }
3381
3382 static bool
3383 gimple_types_compatible_p_1 (tree, tree, type_pair_t,
3384 VEC(type_pair_t, heap) **,
3385 struct pointer_map_t *, struct obstack *);
3386
3387 /* DFS visit the edge from the callers type pair with state *STATE to
3388 the pair T1, T2 while operating in FOR_MERGING_P mode.
3389 Update the merging status if it is not part of the SCC containing the
3390 callers pair and return it.
3391 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
3392
3393 static bool
gtc_visit(tree t1,tree t2,struct sccs * state,VEC (type_pair_t,heap)** sccstack,struct pointer_map_t * sccstate,struct obstack * sccstate_obstack)3394 gtc_visit (tree t1, tree t2,
3395 struct sccs *state,
3396 VEC(type_pair_t, heap) **sccstack,
3397 struct pointer_map_t *sccstate,
3398 struct obstack *sccstate_obstack)
3399 {
3400 struct sccs *cstate = NULL;
3401 type_pair_t p;
3402 void **slot;
3403 tree leader1, leader2;
3404
3405 /* Check first for the obvious case of pointer identity. */
3406 if (t1 == t2)
3407 return true;
3408
3409 /* Check that we have two types to compare. */
3410 if (t1 == NULL_TREE || t2 == NULL_TREE)
3411 return false;
3412
3413 /* Can't be the same type if the types don't have the same code. */
3414 if (TREE_CODE (t1) != TREE_CODE (t2))
3415 return false;
3416
3417 /* Can't be the same type if they have different CV qualifiers. */
3418 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
3419 return false;
3420
3421 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2))
3422 return false;
3423
3424 /* Void types and nullptr types are always the same. */
3425 if (TREE_CODE (t1) == VOID_TYPE
3426 || TREE_CODE (t1) == NULLPTR_TYPE)
3427 return true;
3428
3429 /* Can't be the same type if they have different alignment or mode. */
3430 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
3431 || TYPE_MODE (t1) != TYPE_MODE (t2))
3432 return false;
3433
3434 /* Do some simple checks before doing three hashtable queries. */
3435 if (INTEGRAL_TYPE_P (t1)
3436 || SCALAR_FLOAT_TYPE_P (t1)
3437 || FIXED_POINT_TYPE_P (t1)
3438 || TREE_CODE (t1) == VECTOR_TYPE
3439 || TREE_CODE (t1) == COMPLEX_TYPE
3440 || TREE_CODE (t1) == OFFSET_TYPE
3441 || POINTER_TYPE_P (t1))
3442 {
3443 /* Can't be the same type if they have different sign or precision. */
3444 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
3445 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
3446 return false;
3447
3448 if (TREE_CODE (t1) == INTEGER_TYPE
3449 && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
3450 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
3451 return false;
3452
3453 /* That's all we need to check for float and fixed-point types. */
3454 if (SCALAR_FLOAT_TYPE_P (t1)
3455 || FIXED_POINT_TYPE_P (t1))
3456 return true;
3457
3458 /* For other types fall thru to more complex checks. */
3459 }
3460
3461 /* If the types have been previously registered and found equal
3462 they still are. */
3463 leader1 = gimple_lookup_type_leader (t1);
3464 leader2 = gimple_lookup_type_leader (t2);
3465 if (leader1 == t2
3466 || t1 == leader2
3467 || (leader1 && leader1 == leader2))
3468 return true;
3469
3470 /* If the hash values of t1 and t2 are different the types can't
3471 possibly be the same. This helps keeping the type-pair hashtable
3472 small, only tracking comparisons for hash collisions. */
3473 if (gimple_type_hash (t1) != gimple_type_hash (t2))
3474 return false;
3475
3476 /* Allocate a new cache entry for this comparison. */
3477 p = lookup_type_pair (t1, t2);
3478 if (p->same_p[GTC_MERGE] == 0 || p->same_p[GTC_MERGE] == 1)
3479 {
3480 /* We have already decided whether T1 and T2 are the
3481 same, return the cached result. */
3482 return p->same_p[GTC_MERGE] == 1;
3483 }
3484
3485 if ((slot = pointer_map_contains (sccstate, p)) != NULL)
3486 cstate = (struct sccs *)*slot;
3487 /* Not yet visited. DFS recurse. */
3488 if (!cstate)
3489 {
3490 gimple_types_compatible_p_1 (t1, t2, p,
3491 sccstack, sccstate, sccstate_obstack);
3492 cstate = (struct sccs *)* pointer_map_contains (sccstate, p);
3493 state->low = MIN (state->low, cstate->low);
3494 }
3495 /* If the type is still on the SCC stack adjust the parents low. */
3496 if (cstate->dfsnum < state->dfsnum
3497 && cstate->on_sccstack)
3498 state->low = MIN (cstate->dfsnum, state->low);
3499
3500 /* Return the current lattice value. We start with an equality
3501 assumption so types part of a SCC will be optimistically
3502 treated equal unless proven otherwise. */
3503 return cstate->u.same_p;
3504 }
3505
3506 /* Worker for gimple_types_compatible.
3507 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
3508
3509 static bool
gimple_types_compatible_p_1(tree t1,tree t2,type_pair_t p,VEC (type_pair_t,heap)** sccstack,struct pointer_map_t * sccstate,struct obstack * sccstate_obstack)3510 gimple_types_compatible_p_1 (tree t1, tree t2, type_pair_t p,
3511 VEC(type_pair_t, heap) **sccstack,
3512 struct pointer_map_t *sccstate,
3513 struct obstack *sccstate_obstack)
3514 {
3515 struct sccs *state;
3516
3517 gcc_assert (p->same_p[GTC_MERGE] == -2);
3518
3519 state = XOBNEW (sccstate_obstack, struct sccs);
3520 *pointer_map_insert (sccstate, p) = state;
3521
3522 VEC_safe_push (type_pair_t, heap, *sccstack, p);
3523 state->dfsnum = gtc_next_dfs_num++;
3524 state->low = state->dfsnum;
3525 state->on_sccstack = true;
3526 /* Start with an equality assumption. As we DFS recurse into child
3527 SCCs this assumption may get revisited. */
3528 state->u.same_p = 1;
3529
3530 /* The struct tags shall compare equal. */
3531 if (!compare_type_names_p (t1, t2))
3532 goto different_types;
3533
3534 /* We may not merge typedef types to the same type in different
3535 contexts. */
3536 if (TYPE_NAME (t1)
3537 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
3538 && DECL_CONTEXT (TYPE_NAME (t1))
3539 && TYPE_P (DECL_CONTEXT (TYPE_NAME (t1))))
3540 {
3541 if (!gtc_visit (DECL_CONTEXT (TYPE_NAME (t1)),
3542 DECL_CONTEXT (TYPE_NAME (t2)),
3543 state, sccstack, sccstate, sccstate_obstack))
3544 goto different_types;
3545 }
3546
3547 /* If their attributes are not the same they can't be the same type. */
3548 if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
3549 goto different_types;
3550
3551 /* Do type-specific comparisons. */
3552 switch (TREE_CODE (t1))
3553 {
3554 case VECTOR_TYPE:
3555 case COMPLEX_TYPE:
3556 if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2),
3557 state, sccstack, sccstate, sccstate_obstack))
3558 goto different_types;
3559 goto same_types;
3560
3561 case ARRAY_TYPE:
3562 /* Array types are the same if the element types are the same and
3563 the number of elements are the same. */
3564 if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2),
3565 state, sccstack, sccstate, sccstate_obstack)
3566 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
3567 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
3568 goto different_types;
3569 else
3570 {
3571 tree i1 = TYPE_DOMAIN (t1);
3572 tree i2 = TYPE_DOMAIN (t2);
3573
3574 /* For an incomplete external array, the type domain can be
3575 NULL_TREE. Check this condition also. */
3576 if (i1 == NULL_TREE && i2 == NULL_TREE)
3577 goto same_types;
3578 else if (i1 == NULL_TREE || i2 == NULL_TREE)
3579 goto different_types;
3580 else
3581 {
3582 tree min1 = TYPE_MIN_VALUE (i1);
3583 tree min2 = TYPE_MIN_VALUE (i2);
3584 tree max1 = TYPE_MAX_VALUE (i1);
3585 tree max2 = TYPE_MAX_VALUE (i2);
3586
3587 /* The minimum/maximum values have to be the same. */
3588 if ((min1 == min2
3589 || (min1 && min2
3590 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
3591 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
3592 || operand_equal_p (min1, min2, 0))))
3593 && (max1 == max2
3594 || (max1 && max2
3595 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
3596 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
3597 || operand_equal_p (max1, max2, 0)))))
3598 goto same_types;
3599 else
3600 goto different_types;
3601 }
3602 }
3603
3604 case METHOD_TYPE:
3605 /* Method types should belong to the same class. */
3606 if (!gtc_visit (TYPE_METHOD_BASETYPE (t1), TYPE_METHOD_BASETYPE (t2),
3607 state, sccstack, sccstate, sccstate_obstack))
3608 goto different_types;
3609
3610 /* Fallthru */
3611
3612 case FUNCTION_TYPE:
3613 /* Function types are the same if the return type and arguments types
3614 are the same. */
3615 if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2),
3616 state, sccstack, sccstate, sccstate_obstack))
3617 goto different_types;
3618
3619 if (!comp_type_attributes (t1, t2))
3620 goto different_types;
3621
3622 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
3623 goto same_types;
3624 else
3625 {
3626 tree parms1, parms2;
3627
3628 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
3629 parms1 && parms2;
3630 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
3631 {
3632 if (!gtc_visit (TREE_VALUE (parms1), TREE_VALUE (parms2),
3633 state, sccstack, sccstate, sccstate_obstack))
3634 goto different_types;
3635 }
3636
3637 if (parms1 || parms2)
3638 goto different_types;
3639
3640 goto same_types;
3641 }
3642
3643 case OFFSET_TYPE:
3644 {
3645 if (!gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2),
3646 state, sccstack, sccstate, sccstate_obstack)
3647 || !gtc_visit (TYPE_OFFSET_BASETYPE (t1),
3648 TYPE_OFFSET_BASETYPE (t2),
3649 state, sccstack, sccstate, sccstate_obstack))
3650 goto different_types;
3651
3652 goto same_types;
3653 }
3654
3655 case POINTER_TYPE:
3656 case REFERENCE_TYPE:
3657 {
3658 /* If the two pointers have different ref-all attributes,
3659 they can't be the same type. */
3660 if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
3661 goto different_types;
3662
3663 /* Otherwise, pointer and reference types are the same if the
3664 pointed-to types are the same. */
3665 if (gtc_visit (TREE_TYPE (t1), TREE_TYPE (t2),
3666 state, sccstack, sccstate, sccstate_obstack))
3667 goto same_types;
3668
3669 goto different_types;
3670 }
3671
3672 case INTEGER_TYPE:
3673 case BOOLEAN_TYPE:
3674 {
3675 tree min1 = TYPE_MIN_VALUE (t1);
3676 tree max1 = TYPE_MAX_VALUE (t1);
3677 tree min2 = TYPE_MIN_VALUE (t2);
3678 tree max2 = TYPE_MAX_VALUE (t2);
3679 bool min_equal_p = false;
3680 bool max_equal_p = false;
3681
3682 /* If either type has a minimum value, the other type must
3683 have the same. */
3684 if (min1 == NULL_TREE && min2 == NULL_TREE)
3685 min_equal_p = true;
3686 else if (min1 && min2 && operand_equal_p (min1, min2, 0))
3687 min_equal_p = true;
3688
3689 /* Likewise, if either type has a maximum value, the other
3690 type must have the same. */
3691 if (max1 == NULL_TREE && max2 == NULL_TREE)
3692 max_equal_p = true;
3693 else if (max1 && max2 && operand_equal_p (max1, max2, 0))
3694 max_equal_p = true;
3695
3696 if (!min_equal_p || !max_equal_p)
3697 goto different_types;
3698
3699 goto same_types;
3700 }
3701
3702 case ENUMERAL_TYPE:
3703 {
3704 /* FIXME lto, we cannot check bounds on enumeral types because
3705 different front ends will produce different values.
3706 In C, enumeral types are integers, while in C++ each element
3707 will have its own symbolic value. We should decide how enums
3708 are to be represented in GIMPLE and have each front end lower
3709 to that. */
3710 tree v1, v2;
3711
3712 /* For enumeral types, all the values must be the same. */
3713 if (TYPE_VALUES (t1) == TYPE_VALUES (t2))
3714 goto same_types;
3715
3716 for (v1 = TYPE_VALUES (t1), v2 = TYPE_VALUES (t2);
3717 v1 && v2;
3718 v1 = TREE_CHAIN (v1), v2 = TREE_CHAIN (v2))
3719 {
3720 tree c1 = TREE_VALUE (v1);
3721 tree c2 = TREE_VALUE (v2);
3722
3723 if (TREE_CODE (c1) == CONST_DECL)
3724 c1 = DECL_INITIAL (c1);
3725
3726 if (TREE_CODE (c2) == CONST_DECL)
3727 c2 = DECL_INITIAL (c2);
3728
3729 if (tree_int_cst_equal (c1, c2) != 1)
3730 goto different_types;
3731
3732 if (TREE_PURPOSE (v1) != TREE_PURPOSE (v2))
3733 goto different_types;
3734 }
3735
3736 /* If one enumeration has more values than the other, they
3737 are not the same. */
3738 if (v1 || v2)
3739 goto different_types;
3740
3741 goto same_types;
3742 }
3743
3744 case RECORD_TYPE:
3745 case UNION_TYPE:
3746 case QUAL_UNION_TYPE:
3747 {
3748 tree f1, f2;
3749
3750 /* For aggregate types, all the fields must be the same. */
3751 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
3752 f1 && f2;
3753 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
3754 {
3755 /* Different field kinds are not compatible. */
3756 if (TREE_CODE (f1) != TREE_CODE (f2))
3757 goto different_types;
3758 /* Field decls must have the same name and offset. */
3759 if (TREE_CODE (f1) == FIELD_DECL
3760 && (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
3761 || !gimple_compare_field_offset (f1, f2)))
3762 goto different_types;
3763 /* All entities should have the same name and type. */
3764 if (DECL_NAME (f1) != DECL_NAME (f2)
3765 || !gtc_visit (TREE_TYPE (f1), TREE_TYPE (f2),
3766 state, sccstack, sccstate, sccstate_obstack))
3767 goto different_types;
3768 }
3769
3770 /* If one aggregate has more fields than the other, they
3771 are not the same. */
3772 if (f1 || f2)
3773 goto different_types;
3774
3775 goto same_types;
3776 }
3777
3778 default:
3779 gcc_unreachable ();
3780 }
3781
3782 /* Common exit path for types that are not compatible. */
3783 different_types:
3784 state->u.same_p = 0;
3785 goto pop;
3786
3787 /* Common exit path for types that are compatible. */
3788 same_types:
3789 gcc_assert (state->u.same_p == 1);
3790
3791 pop:
3792 if (state->low == state->dfsnum)
3793 {
3794 type_pair_t x;
3795
3796 /* Pop off the SCC and set its cache values to the final
3797 comparison result. */
3798 do
3799 {
3800 struct sccs *cstate;
3801 x = VEC_pop (type_pair_t, *sccstack);
3802 cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
3803 cstate->on_sccstack = false;
3804 x->same_p[GTC_MERGE] = state->u.same_p;
3805 }
3806 while (x != p);
3807 }
3808
3809 return state->u.same_p;
3810 }
3811
3812 /* Return true iff T1 and T2 are structurally identical. When
3813 FOR_MERGING_P is true the an incomplete type and a complete type
3814 are considered different, otherwise they are considered compatible. */
3815
3816 static bool
gimple_types_compatible_p(tree t1,tree t2)3817 gimple_types_compatible_p (tree t1, tree t2)
3818 {
3819 VEC(type_pair_t, heap) *sccstack = NULL;
3820 struct pointer_map_t *sccstate;
3821 struct obstack sccstate_obstack;
3822 type_pair_t p = NULL;
3823 bool res;
3824 tree leader1, leader2;
3825
3826 /* Before starting to set up the SCC machinery handle simple cases. */
3827
3828 /* Check first for the obvious case of pointer identity. */
3829 if (t1 == t2)
3830 return true;
3831
3832 /* Check that we have two types to compare. */
3833 if (t1 == NULL_TREE || t2 == NULL_TREE)
3834 return false;
3835
3836 /* Can't be the same type if the types don't have the same code. */
3837 if (TREE_CODE (t1) != TREE_CODE (t2))
3838 return false;
3839
3840 /* Can't be the same type if they have different CV qualifiers. */
3841 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
3842 return false;
3843
3844 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2))
3845 return false;
3846
3847 /* Void types and nullptr types are always the same. */
3848 if (TREE_CODE (t1) == VOID_TYPE
3849 || TREE_CODE (t1) == NULLPTR_TYPE)
3850 return true;
3851
3852 /* Can't be the same type if they have different alignment or mode. */
3853 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
3854 || TYPE_MODE (t1) != TYPE_MODE (t2))
3855 return false;
3856
3857 /* Do some simple checks before doing three hashtable queries. */
3858 if (INTEGRAL_TYPE_P (t1)
3859 || SCALAR_FLOAT_TYPE_P (t1)
3860 || FIXED_POINT_TYPE_P (t1)
3861 || TREE_CODE (t1) == VECTOR_TYPE
3862 || TREE_CODE (t1) == COMPLEX_TYPE
3863 || TREE_CODE (t1) == OFFSET_TYPE
3864 || POINTER_TYPE_P (t1))
3865 {
3866 /* Can't be the same type if they have different sign or precision. */
3867 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
3868 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
3869 return false;
3870
3871 if (TREE_CODE (t1) == INTEGER_TYPE
3872 && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
3873 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
3874 return false;
3875
3876 /* That's all we need to check for float and fixed-point types. */
3877 if (SCALAR_FLOAT_TYPE_P (t1)
3878 || FIXED_POINT_TYPE_P (t1))
3879 return true;
3880
3881 /* For other types fall thru to more complex checks. */
3882 }
3883
3884 /* If the types have been previously registered and found equal
3885 they still are. */
3886 leader1 = gimple_lookup_type_leader (t1);
3887 leader2 = gimple_lookup_type_leader (t2);
3888 if (leader1 == t2
3889 || t1 == leader2
3890 || (leader1 && leader1 == leader2))
3891 return true;
3892
3893 /* If the hash values of t1 and t2 are different the types can't
3894 possibly be the same. This helps keeping the type-pair hashtable
3895 small, only tracking comparisons for hash collisions. */
3896 if (gimple_type_hash (t1) != gimple_type_hash (t2))
3897 return false;
3898
3899 /* If we've visited this type pair before (in the case of aggregates
3900 with self-referential types), and we made a decision, return it. */
3901 p = lookup_type_pair (t1, t2);
3902 if (p->same_p[GTC_MERGE] == 0 || p->same_p[GTC_MERGE] == 1)
3903 {
3904 /* We have already decided whether T1 and T2 are the
3905 same, return the cached result. */
3906 return p->same_p[GTC_MERGE] == 1;
3907 }
3908
3909 /* Now set up the SCC machinery for the comparison. */
3910 gtc_next_dfs_num = 1;
3911 sccstate = pointer_map_create ();
3912 gcc_obstack_init (&sccstate_obstack);
3913 res = gimple_types_compatible_p_1 (t1, t2, p,
3914 &sccstack, sccstate, &sccstate_obstack);
3915 VEC_free (type_pair_t, heap, sccstack);
3916 pointer_map_destroy (sccstate);
3917 obstack_free (&sccstate_obstack, NULL);
3918
3919 return res;
3920 }
3921
3922
3923 static hashval_t
3924 iterative_hash_gimple_type (tree, hashval_t, VEC(tree, heap) **,
3925 struct pointer_map_t *, struct obstack *);
3926
3927 /* DFS visit the edge from the callers type with state *STATE to T.
3928 Update the callers type hash V with the hash for T if it is not part
3929 of the SCC containing the callers type and return it.
3930 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
3931
3932 static hashval_t
visit(tree t,struct sccs * state,hashval_t v,VEC (tree,heap)** sccstack,struct pointer_map_t * sccstate,struct obstack * sccstate_obstack)3933 visit (tree t, struct sccs *state, hashval_t v,
3934 VEC (tree, heap) **sccstack,
3935 struct pointer_map_t *sccstate,
3936 struct obstack *sccstate_obstack)
3937 {
3938 struct sccs *cstate = NULL;
3939 struct tree_int_map m;
3940 void **slot;
3941
3942 /* If there is a hash value recorded for this type then it can't
3943 possibly be part of our parent SCC. Simply mix in its hash. */
3944 m.base.from = t;
3945 if ((slot = htab_find_slot (type_hash_cache, &m, NO_INSERT))
3946 && *slot)
3947 return iterative_hash_hashval_t (((struct tree_int_map *) *slot)->to, v);
3948
3949 if ((slot = pointer_map_contains (sccstate, t)) != NULL)
3950 cstate = (struct sccs *)*slot;
3951 if (!cstate)
3952 {
3953 hashval_t tem;
3954 /* Not yet visited. DFS recurse. */
3955 tem = iterative_hash_gimple_type (t, v,
3956 sccstack, sccstate, sccstate_obstack);
3957 if (!cstate)
3958 cstate = (struct sccs *)* pointer_map_contains (sccstate, t);
3959 state->low = MIN (state->low, cstate->low);
3960 /* If the type is no longer on the SCC stack and thus is not part
3961 of the parents SCC mix in its hash value. Otherwise we will
3962 ignore the type for hashing purposes and return the unaltered
3963 hash value. */
3964 if (!cstate->on_sccstack)
3965 return tem;
3966 }
3967 if (cstate->dfsnum < state->dfsnum
3968 && cstate->on_sccstack)
3969 state->low = MIN (cstate->dfsnum, state->low);
3970
3971 /* We are part of our parents SCC, skip this type during hashing
3972 and return the unaltered hash value. */
3973 return v;
3974 }
3975
3976 /* Hash NAME with the previous hash value V and return it. */
3977
3978 static hashval_t
iterative_hash_name(tree name,hashval_t v)3979 iterative_hash_name (tree name, hashval_t v)
3980 {
3981 if (!name)
3982 return v;
3983 v = iterative_hash_hashval_t (TREE_CODE (name), v);
3984 if (TREE_CODE (name) == TYPE_DECL)
3985 name = DECL_NAME (name);
3986 if (!name)
3987 return v;
3988 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3989 return iterative_hash_object (IDENTIFIER_HASH_VALUE (name), v);
3990 }
3991
3992 /* A type, hashvalue pair for sorting SCC members. */
3993
3994 struct type_hash_pair {
3995 tree type;
3996 hashval_t hash;
3997 };
3998
3999 /* Compare two type, hashvalue pairs. */
4000
4001 static int
type_hash_pair_compare(const void * p1_,const void * p2_)4002 type_hash_pair_compare (const void *p1_, const void *p2_)
4003 {
4004 const struct type_hash_pair *p1 = (const struct type_hash_pair *) p1_;
4005 const struct type_hash_pair *p2 = (const struct type_hash_pair *) p2_;
4006 if (p1->hash < p2->hash)
4007 return -1;
4008 else if (p1->hash > p2->hash)
4009 return 1;
4010 return 0;
4011 }
4012
4013 /* Returning a hash value for gimple type TYPE combined with VAL.
4014 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.
4015
4016 To hash a type we end up hashing in types that are reachable.
4017 Through pointers we can end up with cycles which messes up the
4018 required property that we need to compute the same hash value
4019 for structurally equivalent types. To avoid this we have to
4020 hash all types in a cycle (the SCC) in a commutative way. The
4021 easiest way is to not mix in the hashes of the SCC members at
4022 all. To make this work we have to delay setting the hash
4023 values of the SCC until it is complete. */
4024
4025 static hashval_t
iterative_hash_gimple_type(tree type,hashval_t val,VEC (tree,heap)** sccstack,struct pointer_map_t * sccstate,struct obstack * sccstate_obstack)4026 iterative_hash_gimple_type (tree type, hashval_t val,
4027 VEC(tree, heap) **sccstack,
4028 struct pointer_map_t *sccstate,
4029 struct obstack *sccstate_obstack)
4030 {
4031 hashval_t v;
4032 void **slot;
4033 struct sccs *state;
4034
4035 /* Not visited during this DFS walk. */
4036 gcc_checking_assert (!pointer_map_contains (sccstate, type));
4037 state = XOBNEW (sccstate_obstack, struct sccs);
4038 *pointer_map_insert (sccstate, type) = state;
4039
4040 VEC_safe_push (tree, heap, *sccstack, type);
4041 state->dfsnum = next_dfs_num++;
4042 state->low = state->dfsnum;
4043 state->on_sccstack = true;
4044
4045 /* Combine a few common features of types so that types are grouped into
4046 smaller sets; when searching for existing matching types to merge,
4047 only existing types having the same features as the new type will be
4048 checked. */
4049 v = iterative_hash_name (TYPE_NAME (type), 0);
4050 if (TYPE_NAME (type)
4051 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4052 && DECL_CONTEXT (TYPE_NAME (type))
4053 && TYPE_P (DECL_CONTEXT (TYPE_NAME (type))))
4054 v = visit (DECL_CONTEXT (TYPE_NAME (type)), state, v,
4055 sccstack, sccstate, sccstate_obstack);
4056 v = iterative_hash_hashval_t (TREE_CODE (type), v);
4057 v = iterative_hash_hashval_t (TYPE_QUALS (type), v);
4058 v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
4059
4060 /* Do not hash the types size as this will cause differences in
4061 hash values for the complete vs. the incomplete type variant. */
4062
4063 /* Incorporate common features of numerical types. */
4064 if (INTEGRAL_TYPE_P (type)
4065 || SCALAR_FLOAT_TYPE_P (type)
4066 || FIXED_POINT_TYPE_P (type))
4067 {
4068 v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
4069 v = iterative_hash_hashval_t (TYPE_MODE (type), v);
4070 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
4071 }
4072
4073 /* For pointer and reference types, fold in information about the type
4074 pointed to. */
4075 if (POINTER_TYPE_P (type))
4076 v = visit (TREE_TYPE (type), state, v,
4077 sccstack, sccstate, sccstate_obstack);
4078
4079 /* For integer types hash the types min/max values and the string flag. */
4080 if (TREE_CODE (type) == INTEGER_TYPE)
4081 {
4082 /* OMP lowering can introduce error_mark_node in place of
4083 random local decls in types. */
4084 if (TYPE_MIN_VALUE (type) != error_mark_node)
4085 v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
4086 if (TYPE_MAX_VALUE (type) != error_mark_node)
4087 v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
4088 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
4089 }
4090
4091 /* For array types hash the domain and the string flag. */
4092 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
4093 {
4094 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
4095 v = visit (TYPE_DOMAIN (type), state, v,
4096 sccstack, sccstate, sccstate_obstack);
4097 }
4098
4099 /* Recurse for aggregates with a single element type. */
4100 if (TREE_CODE (type) == ARRAY_TYPE
4101 || TREE_CODE (type) == COMPLEX_TYPE
4102 || TREE_CODE (type) == VECTOR_TYPE)
4103 v = visit (TREE_TYPE (type), state, v,
4104 sccstack, sccstate, sccstate_obstack);
4105
4106 /* Incorporate function return and argument types. */
4107 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
4108 {
4109 unsigned na;
4110 tree p;
4111
4112 /* For method types also incorporate their parent class. */
4113 if (TREE_CODE (type) == METHOD_TYPE)
4114 v = visit (TYPE_METHOD_BASETYPE (type), state, v,
4115 sccstack, sccstate, sccstate_obstack);
4116
4117 /* Check result and argument types. */
4118 v = visit (TREE_TYPE (type), state, v,
4119 sccstack, sccstate, sccstate_obstack);
4120 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
4121 {
4122 v = visit (TREE_VALUE (p), state, v,
4123 sccstack, sccstate, sccstate_obstack);
4124 na++;
4125 }
4126
4127 v = iterative_hash_hashval_t (na, v);
4128 }
4129
4130 if (RECORD_OR_UNION_TYPE_P (type))
4131 {
4132 unsigned nf;
4133 tree f;
4134
4135 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
4136 {
4137 v = iterative_hash_name (DECL_NAME (f), v);
4138 v = visit (TREE_TYPE (f), state, v,
4139 sccstack, sccstate, sccstate_obstack);
4140 nf++;
4141 }
4142
4143 v = iterative_hash_hashval_t (nf, v);
4144 }
4145
4146 /* Record hash for us. */
4147 state->u.hash = v;
4148
4149 /* See if we found an SCC. */
4150 if (state->low == state->dfsnum)
4151 {
4152 tree x;
4153 struct tree_int_map *m;
4154
4155 /* Pop off the SCC and set its hash values. */
4156 x = VEC_pop (tree, *sccstack);
4157 /* Optimize SCC size one. */
4158 if (x == type)
4159 {
4160 state->on_sccstack = false;
4161 m = ggc_alloc_cleared_tree_int_map ();
4162 m->base.from = x;
4163 m->to = v;
4164 slot = htab_find_slot (type_hash_cache, m, INSERT);
4165 gcc_assert (!*slot);
4166 *slot = (void *) m;
4167 }
4168 else
4169 {
4170 struct sccs *cstate;
4171 unsigned first, i, size, j;
4172 struct type_hash_pair *pairs;
4173 /* Pop off the SCC and build an array of type, hash pairs. */
4174 first = VEC_length (tree, *sccstack) - 1;
4175 while (VEC_index (tree, *sccstack, first) != type)
4176 --first;
4177 size = VEC_length (tree, *sccstack) - first + 1;
4178 pairs = XALLOCAVEC (struct type_hash_pair, size);
4179 i = 0;
4180 cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
4181 cstate->on_sccstack = false;
4182 pairs[i].type = x;
4183 pairs[i].hash = cstate->u.hash;
4184 do
4185 {
4186 x = VEC_pop (tree, *sccstack);
4187 cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
4188 cstate->on_sccstack = false;
4189 ++i;
4190 pairs[i].type = x;
4191 pairs[i].hash = cstate->u.hash;
4192 }
4193 while (x != type);
4194 gcc_assert (i + 1 == size);
4195 /* Sort the arrays of type, hash pairs so that when we mix in
4196 all members of the SCC the hash value becomes independent on
4197 the order we visited the SCC. Disregard hashes equal to
4198 the hash of the type we mix into because we cannot guarantee
4199 a stable sort for those across different TUs. */
4200 qsort (pairs, size, sizeof (struct type_hash_pair),
4201 type_hash_pair_compare);
4202 for (i = 0; i < size; ++i)
4203 {
4204 hashval_t hash;
4205 m = ggc_alloc_cleared_tree_int_map ();
4206 m->base.from = pairs[i].type;
4207 hash = pairs[i].hash;
4208 /* Skip same hashes. */
4209 for (j = i + 1; j < size && pairs[j].hash == pairs[i].hash; ++j)
4210 ;
4211 for (; j < size; ++j)
4212 hash = iterative_hash_hashval_t (pairs[j].hash, hash);
4213 for (j = 0; pairs[j].hash != pairs[i].hash; ++j)
4214 hash = iterative_hash_hashval_t (pairs[j].hash, hash);
4215 m->to = hash;
4216 if (pairs[i].type == type)
4217 v = hash;
4218 slot = htab_find_slot (type_hash_cache, m, INSERT);
4219 gcc_assert (!*slot);
4220 *slot = (void *) m;
4221 }
4222 }
4223 }
4224
4225 return iterative_hash_hashval_t (v, val);
4226 }
4227
4228
4229 /* Returns a hash value for P (assumed to be a type). The hash value
4230 is computed using some distinguishing features of the type. Note
4231 that we cannot use pointer hashing here as we may be dealing with
4232 two distinct instances of the same type.
4233
4234 This function should produce the same hash value for two compatible
4235 types according to gimple_types_compatible_p. */
4236
4237 static hashval_t
gimple_type_hash(const void * p)4238 gimple_type_hash (const void *p)
4239 {
4240 const_tree t = (const_tree) p;
4241 VEC(tree, heap) *sccstack = NULL;
4242 struct pointer_map_t *sccstate;
4243 struct obstack sccstate_obstack;
4244 hashval_t val;
4245 void **slot;
4246 struct tree_int_map m;
4247
4248 if (type_hash_cache == NULL)
4249 type_hash_cache = htab_create_ggc (512, tree_int_map_hash,
4250 tree_int_map_eq, NULL);
4251
4252 m.base.from = CONST_CAST_TREE (t);
4253 if ((slot = htab_find_slot (type_hash_cache, &m, NO_INSERT))
4254 && *slot)
4255 return iterative_hash_hashval_t (((struct tree_int_map *) *slot)->to, 0);
4256
4257 /* Perform a DFS walk and pre-hash all reachable types. */
4258 next_dfs_num = 1;
4259 sccstate = pointer_map_create ();
4260 gcc_obstack_init (&sccstate_obstack);
4261 val = iterative_hash_gimple_type (CONST_CAST_TREE (t), 0,
4262 &sccstack, sccstate, &sccstate_obstack);
4263 VEC_free (tree, heap, sccstack);
4264 pointer_map_destroy (sccstate);
4265 obstack_free (&sccstate_obstack, NULL);
4266
4267 return val;
4268 }
4269
4270 /* Returning a hash value for gimple type TYPE combined with VAL.
4271
4272 The hash value returned is equal for types considered compatible
4273 by gimple_canonical_types_compatible_p. */
4274
4275 static hashval_t
iterative_hash_canonical_type(tree type,hashval_t val)4276 iterative_hash_canonical_type (tree type, hashval_t val)
4277 {
4278 hashval_t v;
4279 void **slot;
4280 struct tree_int_map *mp, m;
4281
4282 m.base.from = type;
4283 if ((slot = htab_find_slot (canonical_type_hash_cache, &m, INSERT))
4284 && *slot)
4285 return iterative_hash_hashval_t (((struct tree_int_map *) *slot)->to, val);
4286
4287 /* Combine a few common features of types so that types are grouped into
4288 smaller sets; when searching for existing matching types to merge,
4289 only existing types having the same features as the new type will be
4290 checked. */
4291 v = iterative_hash_hashval_t (TREE_CODE (type), 0);
4292 v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
4293 v = iterative_hash_hashval_t (TYPE_ALIGN (type), v);
4294 v = iterative_hash_hashval_t (TYPE_MODE (type), v);
4295
4296 /* Incorporate common features of numerical types. */
4297 if (INTEGRAL_TYPE_P (type)
4298 || SCALAR_FLOAT_TYPE_P (type)
4299 || FIXED_POINT_TYPE_P (type)
4300 || TREE_CODE (type) == VECTOR_TYPE
4301 || TREE_CODE (type) == COMPLEX_TYPE
4302 || TREE_CODE (type) == OFFSET_TYPE
4303 || POINTER_TYPE_P (type))
4304 {
4305 v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
4306 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
4307 }
4308
4309 /* For pointer and reference types, fold in information about the type
4310 pointed to but do not recurse to the pointed-to type. */
4311 if (POINTER_TYPE_P (type))
4312 {
4313 v = iterative_hash_hashval_t (TYPE_REF_CAN_ALIAS_ALL (type), v);
4314 v = iterative_hash_hashval_t (TYPE_ADDR_SPACE (TREE_TYPE (type)), v);
4315 v = iterative_hash_hashval_t (TYPE_RESTRICT (type), v);
4316 v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
4317 }
4318
4319 /* For integer types hash the sizetype and the string flag. */
4320 if (TREE_CODE (type) == INTEGER_TYPE)
4321 {
4322 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
4323 v = iterative_hash_hashval_t (TYPE_IS_SIZETYPE (type), v);
4324 }
4325
4326 /* For array types hash the domain bounds and the string flag. */
4327 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
4328 {
4329 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
4330 /* OMP lowering can introduce error_mark_node in place of
4331 random local decls in types. */
4332 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
4333 v = iterative_hash_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), v);
4334 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
4335 v = iterative_hash_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), v);
4336 }
4337
4338 /* Recurse for aggregates with a single element type. */
4339 if (TREE_CODE (type) == ARRAY_TYPE
4340 || TREE_CODE (type) == COMPLEX_TYPE
4341 || TREE_CODE (type) == VECTOR_TYPE)
4342 v = iterative_hash_canonical_type (TREE_TYPE (type), v);
4343
4344 /* Incorporate function return and argument types. */
4345 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
4346 {
4347 unsigned na;
4348 tree p;
4349
4350 /* For method types also incorporate their parent class. */
4351 if (TREE_CODE (type) == METHOD_TYPE)
4352 v = iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type), v);
4353
4354 v = iterative_hash_canonical_type (TREE_TYPE (type), v);
4355
4356 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
4357 {
4358 v = iterative_hash_canonical_type (TREE_VALUE (p), v);
4359 na++;
4360 }
4361
4362 v = iterative_hash_hashval_t (na, v);
4363 }
4364
4365 if (RECORD_OR_UNION_TYPE_P (type))
4366 {
4367 unsigned nf;
4368 tree f;
4369
4370 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
4371 if (TREE_CODE (f) == FIELD_DECL)
4372 {
4373 v = iterative_hash_canonical_type (TREE_TYPE (f), v);
4374 nf++;
4375 }
4376
4377 v = iterative_hash_hashval_t (nf, v);
4378 }
4379
4380 /* Cache the just computed hash value. */
4381 mp = ggc_alloc_cleared_tree_int_map ();
4382 mp->base.from = type;
4383 mp->to = v;
4384 *slot = (void *) mp;
4385
4386 return iterative_hash_hashval_t (v, val);
4387 }
4388
4389 static hashval_t
gimple_canonical_type_hash(const void * p)4390 gimple_canonical_type_hash (const void *p)
4391 {
4392 if (canonical_type_hash_cache == NULL)
4393 canonical_type_hash_cache = htab_create_ggc (512, tree_int_map_hash,
4394 tree_int_map_eq, NULL);
4395
4396 return iterative_hash_canonical_type (CONST_CAST_TREE ((const_tree) p), 0);
4397 }
4398
4399
4400 /* Returns nonzero if P1 and P2 are equal. */
4401
4402 static int
gimple_type_eq(const void * p1,const void * p2)4403 gimple_type_eq (const void *p1, const void *p2)
4404 {
4405 const_tree t1 = (const_tree) p1;
4406 const_tree t2 = (const_tree) p2;
4407 return gimple_types_compatible_p (CONST_CAST_TREE (t1),
4408 CONST_CAST_TREE (t2));
4409 }
4410
4411
4412 /* Worker for gimple_register_type.
4413 Register type T in the global type table gimple_types.
4414 When REGISTERING_MV is false first recurse for the main variant of T. */
4415
4416 static tree
gimple_register_type_1(tree t,bool registering_mv)4417 gimple_register_type_1 (tree t, bool registering_mv)
4418 {
4419 void **slot;
4420 gimple_type_leader_entry *leader;
4421
4422 /* If we registered this type before return the cached result. */
4423 leader = &gimple_type_leader[TYPE_UID (t) % GIMPLE_TYPE_LEADER_SIZE];
4424 if (leader->type == t)
4425 return leader->leader;
4426
4427 /* Always register the main variant first. This is important so we
4428 pick up the non-typedef variants as canonical, otherwise we'll end
4429 up taking typedef ids for structure tags during comparison.
4430 It also makes sure that main variants will be merged to main variants.
4431 As we are operating on a possibly partially fixed up type graph
4432 do not bother to recurse more than once, otherwise we may end up
4433 walking in circles.
4434 If we are registering a main variant it will either remain its
4435 own main variant or it will be merged to something else in which
4436 case we do not care for the main variant leader. */
4437 if (!registering_mv
4438 && TYPE_MAIN_VARIANT (t) != t)
4439 gimple_register_type_1 (TYPE_MAIN_VARIANT (t), true);
4440
4441 /* See if we already have an equivalent type registered. */
4442 slot = htab_find_slot (gimple_types, t, INSERT);
4443 if (*slot
4444 && *(tree *)slot != t)
4445 {
4446 tree new_type = (tree) *((tree *) slot);
4447 leader->type = t;
4448 leader->leader = new_type;
4449 return new_type;
4450 }
4451
4452 /* If not, insert it to the cache and the hash. */
4453 leader->type = t;
4454 leader->leader = t;
4455 *slot = (void *) t;
4456 return t;
4457 }
4458
4459 /* Register type T in the global type table gimple_types.
4460 If another type T', compatible with T, already existed in
4461 gimple_types then return T', otherwise return T. This is used by
4462 LTO to merge identical types read from different TUs. */
4463
4464 tree
gimple_register_type(tree t)4465 gimple_register_type (tree t)
4466 {
4467 gcc_assert (TYPE_P (t));
4468
4469 if (!gimple_type_leader)
4470 gimple_type_leader = ggc_alloc_cleared_vec_gimple_type_leader_entry_s
4471 (GIMPLE_TYPE_LEADER_SIZE);
4472
4473 if (gimple_types == NULL)
4474 gimple_types = htab_create_ggc (16381, gimple_type_hash, gimple_type_eq, 0);
4475
4476 return gimple_register_type_1 (t, false);
4477 }
4478
4479 /* The TYPE_CANONICAL merging machinery. It should closely resemble
4480 the middle-end types_compatible_p function. It needs to avoid
4481 claiming types are different for types that should be treated
4482 the same with respect to TBAA. Canonical types are also used
4483 for IL consistency checks via the useless_type_conversion_p
4484 predicate which does not handle all type kinds itself but falls
4485 back to pointer-comparison of TYPE_CANONICAL for aggregates
4486 for example. */
4487
4488 /* Return true iff T1 and T2 are structurally identical for what
4489 TBAA is concerned. */
4490
4491 static bool
gimple_canonical_types_compatible_p(tree t1,tree t2)4492 gimple_canonical_types_compatible_p (tree t1, tree t2)
4493 {
4494 /* Before starting to set up the SCC machinery handle simple cases. */
4495
4496 /* Check first for the obvious case of pointer identity. */
4497 if (t1 == t2)
4498 return true;
4499
4500 /* Check that we have two types to compare. */
4501 if (t1 == NULL_TREE || t2 == NULL_TREE)
4502 return false;
4503
4504 /* If the types have been previously registered and found equal
4505 they still are. */
4506 if (TYPE_CANONICAL (t1)
4507 && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
4508 return true;
4509
4510 /* Can't be the same type if the types don't have the same code. */
4511 if (TREE_CODE (t1) != TREE_CODE (t2))
4512 return false;
4513
4514 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2))
4515 return false;
4516
4517 /* Qualifiers do not matter for canonical type comparison purposes. */
4518
4519 /* Void types and nullptr types are always the same. */
4520 if (TREE_CODE (t1) == VOID_TYPE
4521 || TREE_CODE (t1) == NULLPTR_TYPE)
4522 return true;
4523
4524 /* Can't be the same type if they have different alignment, or mode. */
4525 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
4526 || TYPE_MODE (t1) != TYPE_MODE (t2))
4527 return false;
4528
4529 /* Non-aggregate types can be handled cheaply. */
4530 if (INTEGRAL_TYPE_P (t1)
4531 || SCALAR_FLOAT_TYPE_P (t1)
4532 || FIXED_POINT_TYPE_P (t1)
4533 || TREE_CODE (t1) == VECTOR_TYPE
4534 || TREE_CODE (t1) == COMPLEX_TYPE
4535 || TREE_CODE (t1) == OFFSET_TYPE
4536 || POINTER_TYPE_P (t1))
4537 {
4538 /* Can't be the same type if they have different sign or precision. */
4539 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
4540 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
4541 return false;
4542
4543 if (TREE_CODE (t1) == INTEGER_TYPE
4544 && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
4545 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
4546 return false;
4547
4548 /* For canonical type comparisons we do not want to build SCCs
4549 so we cannot compare pointed-to types. But we can, for now,
4550 require the same pointed-to type kind and match what
4551 useless_type_conversion_p would do. */
4552 if (POINTER_TYPE_P (t1))
4553 {
4554 /* If the two pointers have different ref-all attributes,
4555 they can't be the same type. */
4556 if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
4557 return false;
4558
4559 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
4560 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
4561 return false;
4562
4563 if (TYPE_RESTRICT (t1) != TYPE_RESTRICT (t2))
4564 return false;
4565
4566 if (TREE_CODE (TREE_TYPE (t1)) != TREE_CODE (TREE_TYPE (t2)))
4567 return false;
4568 }
4569
4570 /* Tail-recurse to components. */
4571 if (TREE_CODE (t1) == VECTOR_TYPE
4572 || TREE_CODE (t1) == COMPLEX_TYPE)
4573 return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
4574 TREE_TYPE (t2));
4575
4576 return true;
4577 }
4578
4579 /* If their attributes are not the same they can't be the same type. */
4580 if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
4581 return false;
4582
4583 /* Do type-specific comparisons. */
4584 switch (TREE_CODE (t1))
4585 {
4586 case ARRAY_TYPE:
4587 /* Array types are the same if the element types are the same and
4588 the number of elements are the same. */
4589 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
4590 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
4591 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
4592 return false;
4593 else
4594 {
4595 tree i1 = TYPE_DOMAIN (t1);
4596 tree i2 = TYPE_DOMAIN (t2);
4597
4598 /* For an incomplete external array, the type domain can be
4599 NULL_TREE. Check this condition also. */
4600 if (i1 == NULL_TREE && i2 == NULL_TREE)
4601 return true;
4602 else if (i1 == NULL_TREE || i2 == NULL_TREE)
4603 return false;
4604 else
4605 {
4606 tree min1 = TYPE_MIN_VALUE (i1);
4607 tree min2 = TYPE_MIN_VALUE (i2);
4608 tree max1 = TYPE_MAX_VALUE (i1);
4609 tree max2 = TYPE_MAX_VALUE (i2);
4610
4611 /* The minimum/maximum values have to be the same. */
4612 if ((min1 == min2
4613 || (min1 && min2
4614 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
4615 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
4616 || operand_equal_p (min1, min2, 0))))
4617 && (max1 == max2
4618 || (max1 && max2
4619 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
4620 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
4621 || operand_equal_p (max1, max2, 0)))))
4622 return true;
4623 else
4624 return false;
4625 }
4626 }
4627
4628 case METHOD_TYPE:
4629 /* Method types should belong to the same class. */
4630 if (!gimple_canonical_types_compatible_p
4631 (TYPE_METHOD_BASETYPE (t1), TYPE_METHOD_BASETYPE (t2)))
4632 return false;
4633
4634 /* Fallthru */
4635
4636 case FUNCTION_TYPE:
4637 /* Function types are the same if the return type and arguments types
4638 are the same. */
4639 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
4640 return false;
4641
4642 if (!comp_type_attributes (t1, t2))
4643 return false;
4644
4645 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
4646 return true;
4647 else
4648 {
4649 tree parms1, parms2;
4650
4651 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
4652 parms1 && parms2;
4653 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
4654 {
4655 if (!gimple_canonical_types_compatible_p
4656 (TREE_VALUE (parms1), TREE_VALUE (parms2)))
4657 return false;
4658 }
4659
4660 if (parms1 || parms2)
4661 return false;
4662
4663 return true;
4664 }
4665
4666 case RECORD_TYPE:
4667 case UNION_TYPE:
4668 case QUAL_UNION_TYPE:
4669 {
4670 tree f1, f2;
4671
4672 /* For aggregate types, all the fields must be the same. */
4673 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
4674 f1 || f2;
4675 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
4676 {
4677 /* Skip non-fields. */
4678 while (f1 && TREE_CODE (f1) != FIELD_DECL)
4679 f1 = TREE_CHAIN (f1);
4680 while (f2 && TREE_CODE (f2) != FIELD_DECL)
4681 f2 = TREE_CHAIN (f2);
4682 if (!f1 || !f2)
4683 break;
4684 /* The fields must have the same name, offset and type. */
4685 if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
4686 || !gimple_compare_field_offset (f1, f2)
4687 || !gimple_canonical_types_compatible_p
4688 (TREE_TYPE (f1), TREE_TYPE (f2)))
4689 return false;
4690 }
4691
4692 /* If one aggregate has more fields than the other, they
4693 are not the same. */
4694 if (f1 || f2)
4695 return false;
4696
4697 return true;
4698 }
4699
4700 default:
4701 gcc_unreachable ();
4702 }
4703 }
4704
4705
4706 /* Returns nonzero if P1 and P2 are equal. */
4707
4708 static int
gimple_canonical_type_eq(const void * p1,const void * p2)4709 gimple_canonical_type_eq (const void *p1, const void *p2)
4710 {
4711 const_tree t1 = (const_tree) p1;
4712 const_tree t2 = (const_tree) p2;
4713 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1),
4714 CONST_CAST_TREE (t2));
4715 }
4716
4717 /* Register type T in the global type table gimple_types.
4718 If another type T', compatible with T, already existed in
4719 gimple_types then return T', otherwise return T. This is used by
4720 LTO to merge identical types read from different TUs.
4721
4722 ??? This merging does not exactly match how the tree.c middle-end
4723 functions will assign TYPE_CANONICAL when new types are created
4724 during optimization (which at least happens for pointer and array
4725 types). */
4726
4727 tree
gimple_register_canonical_type(tree t)4728 gimple_register_canonical_type (tree t)
4729 {
4730 void **slot;
4731
4732 gcc_assert (TYPE_P (t));
4733
4734 if (TYPE_CANONICAL (t))
4735 return TYPE_CANONICAL (t);
4736
4737 if (gimple_canonical_types == NULL)
4738 gimple_canonical_types = htab_create_ggc (16381, gimple_canonical_type_hash,
4739 gimple_canonical_type_eq, 0);
4740
4741 slot = htab_find_slot (gimple_canonical_types, t, INSERT);
4742 if (*slot
4743 && *(tree *)slot != t)
4744 {
4745 tree new_type = (tree) *((tree *) slot);
4746
4747 TYPE_CANONICAL (t) = new_type;
4748 t = new_type;
4749 }
4750 else
4751 {
4752 TYPE_CANONICAL (t) = t;
4753 *slot = (void *) t;
4754 }
4755
4756 return t;
4757 }
4758
4759
4760 /* Show statistics on references to the global type table gimple_types. */
4761
4762 void
print_gimple_types_stats(void)4763 print_gimple_types_stats (void)
4764 {
4765 if (gimple_types)
4766 fprintf (stderr, "GIMPLE type table: size %ld, %ld elements, "
4767 "%ld searches, %ld collisions (ratio: %f)\n",
4768 (long) htab_size (gimple_types),
4769 (long) htab_elements (gimple_types),
4770 (long) gimple_types->searches,
4771 (long) gimple_types->collisions,
4772 htab_collisions (gimple_types));
4773 else
4774 fprintf (stderr, "GIMPLE type table is empty\n");
4775 if (type_hash_cache)
4776 fprintf (stderr, "GIMPLE type hash table: size %ld, %ld elements, "
4777 "%ld searches, %ld collisions (ratio: %f)\n",
4778 (long) htab_size (type_hash_cache),
4779 (long) htab_elements (type_hash_cache),
4780 (long) type_hash_cache->searches,
4781 (long) type_hash_cache->collisions,
4782 htab_collisions (type_hash_cache));
4783 else
4784 fprintf (stderr, "GIMPLE type hash table is empty\n");
4785 if (gimple_canonical_types)
4786 fprintf (stderr, "GIMPLE canonical type table: size %ld, %ld elements, "
4787 "%ld searches, %ld collisions (ratio: %f)\n",
4788 (long) htab_size (gimple_canonical_types),
4789 (long) htab_elements (gimple_canonical_types),
4790 (long) gimple_canonical_types->searches,
4791 (long) gimple_canonical_types->collisions,
4792 htab_collisions (gimple_canonical_types));
4793 else
4794 fprintf (stderr, "GIMPLE canonical type table is empty\n");
4795 if (canonical_type_hash_cache)
4796 fprintf (stderr, "GIMPLE canonical type hash table: size %ld, %ld elements, "
4797 "%ld searches, %ld collisions (ratio: %f)\n",
4798 (long) htab_size (canonical_type_hash_cache),
4799 (long) htab_elements (canonical_type_hash_cache),
4800 (long) canonical_type_hash_cache->searches,
4801 (long) canonical_type_hash_cache->collisions,
4802 htab_collisions (canonical_type_hash_cache));
4803 else
4804 fprintf (stderr, "GIMPLE canonical type hash table is empty\n");
4805 }
4806
4807 /* Free the gimple type hashtables used for LTO type merging. */
4808
4809 void
free_gimple_type_tables(void)4810 free_gimple_type_tables (void)
4811 {
4812 /* Last chance to print stats for the tables. */
4813 if (flag_lto_report)
4814 print_gimple_types_stats ();
4815
4816 if (gimple_types)
4817 {
4818 htab_delete (gimple_types);
4819 gimple_types = NULL;
4820 }
4821 if (gimple_canonical_types)
4822 {
4823 htab_delete (gimple_canonical_types);
4824 gimple_canonical_types = NULL;
4825 }
4826 if (type_hash_cache)
4827 {
4828 htab_delete (type_hash_cache);
4829 type_hash_cache = NULL;
4830 }
4831 if (canonical_type_hash_cache)
4832 {
4833 htab_delete (canonical_type_hash_cache);
4834 canonical_type_hash_cache = NULL;
4835 }
4836 if (type_pair_cache)
4837 {
4838 free (type_pair_cache);
4839 type_pair_cache = NULL;
4840 }
4841 gimple_type_leader = NULL;
4842 }
4843
4844
4845 /* Return a type the same as TYPE except unsigned or
4846 signed according to UNSIGNEDP. */
4847
4848 static tree
gimple_signed_or_unsigned_type(bool unsignedp,tree type)4849 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
4850 {
4851 tree type1;
4852
4853 type1 = TYPE_MAIN_VARIANT (type);
4854 if (type1 == signed_char_type_node
4855 || type1 == char_type_node
4856 || type1 == unsigned_char_type_node)
4857 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4858 if (type1 == integer_type_node || type1 == unsigned_type_node)
4859 return unsignedp ? unsigned_type_node : integer_type_node;
4860 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
4861 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4862 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
4863 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4864 if (type1 == long_long_integer_type_node
4865 || type1 == long_long_unsigned_type_node)
4866 return unsignedp
4867 ? long_long_unsigned_type_node
4868 : long_long_integer_type_node;
4869 if (int128_integer_type_node && (type1 == int128_integer_type_node || type1 == int128_unsigned_type_node))
4870 return unsignedp
4871 ? int128_unsigned_type_node
4872 : int128_integer_type_node;
4873 #if HOST_BITS_PER_WIDE_INT >= 64
4874 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
4875 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
4876 #endif
4877 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
4878 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
4879 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
4880 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
4881 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
4882 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
4883 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
4884 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
4885
4886 #define GIMPLE_FIXED_TYPES(NAME) \
4887 if (type1 == short_ ## NAME ## _type_node \
4888 || type1 == unsigned_short_ ## NAME ## _type_node) \
4889 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
4890 : short_ ## NAME ## _type_node; \
4891 if (type1 == NAME ## _type_node \
4892 || type1 == unsigned_ ## NAME ## _type_node) \
4893 return unsignedp ? unsigned_ ## NAME ## _type_node \
4894 : NAME ## _type_node; \
4895 if (type1 == long_ ## NAME ## _type_node \
4896 || type1 == unsigned_long_ ## NAME ## _type_node) \
4897 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
4898 : long_ ## NAME ## _type_node; \
4899 if (type1 == long_long_ ## NAME ## _type_node \
4900 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
4901 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
4902 : long_long_ ## NAME ## _type_node;
4903
4904 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
4905 if (type1 == NAME ## _type_node \
4906 || type1 == u ## NAME ## _type_node) \
4907 return unsignedp ? u ## NAME ## _type_node \
4908 : NAME ## _type_node;
4909
4910 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
4911 if (type1 == sat_ ## short_ ## NAME ## _type_node \
4912 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
4913 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
4914 : sat_ ## short_ ## NAME ## _type_node; \
4915 if (type1 == sat_ ## NAME ## _type_node \
4916 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
4917 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
4918 : sat_ ## NAME ## _type_node; \
4919 if (type1 == sat_ ## long_ ## NAME ## _type_node \
4920 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
4921 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
4922 : sat_ ## long_ ## NAME ## _type_node; \
4923 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
4924 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
4925 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
4926 : sat_ ## long_long_ ## NAME ## _type_node;
4927
4928 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
4929 if (type1 == sat_ ## NAME ## _type_node \
4930 || type1 == sat_ ## u ## NAME ## _type_node) \
4931 return unsignedp ? sat_ ## u ## NAME ## _type_node \
4932 : sat_ ## NAME ## _type_node;
4933
4934 GIMPLE_FIXED_TYPES (fract);
4935 GIMPLE_FIXED_TYPES_SAT (fract);
4936 GIMPLE_FIXED_TYPES (accum);
4937 GIMPLE_FIXED_TYPES_SAT (accum);
4938
4939 GIMPLE_FIXED_MODE_TYPES (qq);
4940 GIMPLE_FIXED_MODE_TYPES (hq);
4941 GIMPLE_FIXED_MODE_TYPES (sq);
4942 GIMPLE_FIXED_MODE_TYPES (dq);
4943 GIMPLE_FIXED_MODE_TYPES (tq);
4944 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
4945 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
4946 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
4947 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
4948 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
4949 GIMPLE_FIXED_MODE_TYPES (ha);
4950 GIMPLE_FIXED_MODE_TYPES (sa);
4951 GIMPLE_FIXED_MODE_TYPES (da);
4952 GIMPLE_FIXED_MODE_TYPES (ta);
4953 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
4954 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
4955 GIMPLE_FIXED_MODE_TYPES_SAT (da);
4956 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
4957
4958 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
4959 the precision; they have precision set to match their range, but
4960 may use a wider mode to match an ABI. If we change modes, we may
4961 wind up with bad conversions. For INTEGER_TYPEs in C, must check
4962 the precision as well, so as to yield correct results for
4963 bit-field types. C++ does not have these separate bit-field
4964 types, and producing a signed or unsigned variant of an
4965 ENUMERAL_TYPE may cause other problems as well. */
4966 if (!INTEGRAL_TYPE_P (type)
4967 || TYPE_UNSIGNED (type) == unsignedp)
4968 return type;
4969
4970 #define TYPE_OK(node) \
4971 (TYPE_MODE (type) == TYPE_MODE (node) \
4972 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
4973 if (TYPE_OK (signed_char_type_node))
4974 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4975 if (TYPE_OK (integer_type_node))
4976 return unsignedp ? unsigned_type_node : integer_type_node;
4977 if (TYPE_OK (short_integer_type_node))
4978 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4979 if (TYPE_OK (long_integer_type_node))
4980 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4981 if (TYPE_OK (long_long_integer_type_node))
4982 return (unsignedp
4983 ? long_long_unsigned_type_node
4984 : long_long_integer_type_node);
4985 if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
4986 return (unsignedp
4987 ? int128_unsigned_type_node
4988 : int128_integer_type_node);
4989
4990 #if HOST_BITS_PER_WIDE_INT >= 64
4991 if (TYPE_OK (intTI_type_node))
4992 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
4993 #endif
4994 if (TYPE_OK (intDI_type_node))
4995 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
4996 if (TYPE_OK (intSI_type_node))
4997 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
4998 if (TYPE_OK (intHI_type_node))
4999 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
5000 if (TYPE_OK (intQI_type_node))
5001 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
5002
5003 #undef GIMPLE_FIXED_TYPES
5004 #undef GIMPLE_FIXED_MODE_TYPES
5005 #undef GIMPLE_FIXED_TYPES_SAT
5006 #undef GIMPLE_FIXED_MODE_TYPES_SAT
5007 #undef TYPE_OK
5008
5009 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
5010 }
5011
5012
5013 /* Return an unsigned type the same as TYPE in other respects. */
5014
5015 tree
gimple_unsigned_type(tree type)5016 gimple_unsigned_type (tree type)
5017 {
5018 return gimple_signed_or_unsigned_type (true, type);
5019 }
5020
5021
5022 /* Return a signed type the same as TYPE in other respects. */
5023
5024 tree
gimple_signed_type(tree type)5025 gimple_signed_type (tree type)
5026 {
5027 return gimple_signed_or_unsigned_type (false, type);
5028 }
5029
5030
5031 /* Return the typed-based alias set for T, which may be an expression
5032 or a type. Return -1 if we don't do anything special. */
5033
5034 alias_set_type
gimple_get_alias_set(tree t)5035 gimple_get_alias_set (tree t)
5036 {
5037 tree u;
5038
5039 /* Permit type-punning when accessing a union, provided the access
5040 is directly through the union. For example, this code does not
5041 permit taking the address of a union member and then storing
5042 through it. Even the type-punning allowed here is a GCC
5043 extension, albeit a common and useful one; the C standard says
5044 that such accesses have implementation-defined behavior. */
5045 for (u = t;
5046 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
5047 u = TREE_OPERAND (u, 0))
5048 if (TREE_CODE (u) == COMPONENT_REF
5049 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
5050 return 0;
5051
5052 /* That's all the expressions we handle specially. */
5053 if (!TYPE_P (t))
5054 return -1;
5055
5056 /* For convenience, follow the C standard when dealing with
5057 character types. Any object may be accessed via an lvalue that
5058 has character type. */
5059 if (t == char_type_node
5060 || t == signed_char_type_node
5061 || t == unsigned_char_type_node)
5062 return 0;
5063
5064 /* Allow aliasing between signed and unsigned variants of the same
5065 type. We treat the signed variant as canonical. */
5066 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
5067 {
5068 tree t1 = gimple_signed_type (t);
5069
5070 /* t1 == t can happen for boolean nodes which are always unsigned. */
5071 if (t1 != t)
5072 return get_alias_set (t1);
5073 }
5074
5075 return -1;
5076 }
5077
5078
5079 /* Data structure used to count the number of dereferences to PTR
5080 inside an expression. */
5081 struct count_ptr_d
5082 {
5083 tree ptr;
5084 unsigned num_stores;
5085 unsigned num_loads;
5086 };
5087
5088 /* Helper for count_uses_and_derefs. Called by walk_tree to look for
5089 (ALIGN/MISALIGNED_)INDIRECT_REF nodes for the pointer passed in DATA. */
5090
5091 static tree
count_ptr_derefs(tree * tp,int * walk_subtrees,void * data)5092 count_ptr_derefs (tree *tp, int *walk_subtrees, void *data)
5093 {
5094 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
5095 struct count_ptr_d *count_p = (struct count_ptr_d *) wi_p->info;
5096
5097 /* Do not walk inside ADDR_EXPR nodes. In the expression &ptr->fld,
5098 pointer 'ptr' is *not* dereferenced, it is simply used to compute
5099 the address of 'fld' as 'ptr + offsetof(fld)'. */
5100 if (TREE_CODE (*tp) == ADDR_EXPR)
5101 {
5102 *walk_subtrees = 0;
5103 return NULL_TREE;
5104 }
5105
5106 if (TREE_CODE (*tp) == MEM_REF && TREE_OPERAND (*tp, 0) == count_p->ptr)
5107 {
5108 if (wi_p->is_lhs)
5109 count_p->num_stores++;
5110 else
5111 count_p->num_loads++;
5112 }
5113
5114 return NULL_TREE;
5115 }
5116
5117 /* Count the number of direct and indirect uses for pointer PTR in
5118 statement STMT. The number of direct uses is stored in
5119 *NUM_USES_P. Indirect references are counted separately depending
5120 on whether they are store or load operations. The counts are
5121 stored in *NUM_STORES_P and *NUM_LOADS_P. */
5122
5123 void
count_uses_and_derefs(tree ptr,gimple stmt,unsigned * num_uses_p,unsigned * num_loads_p,unsigned * num_stores_p)5124 count_uses_and_derefs (tree ptr, gimple stmt, unsigned *num_uses_p,
5125 unsigned *num_loads_p, unsigned *num_stores_p)
5126 {
5127 ssa_op_iter i;
5128 tree use;
5129
5130 *num_uses_p = 0;
5131 *num_loads_p = 0;
5132 *num_stores_p = 0;
5133
5134 /* Find out the total number of uses of PTR in STMT. */
5135 FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
5136 if (use == ptr)
5137 (*num_uses_p)++;
5138
5139 /* Now count the number of indirect references to PTR. This is
5140 truly awful, but we don't have much choice. There are no parent
5141 pointers inside INDIRECT_REFs, so an expression like
5142 '*x_1 = foo (x_1, *x_1)' needs to be traversed piece by piece to
5143 find all the indirect and direct uses of x_1 inside. The only
5144 shortcut we can take is the fact that GIMPLE only allows
5145 INDIRECT_REFs inside the expressions below. */
5146 if (is_gimple_assign (stmt)
5147 || gimple_code (stmt) == GIMPLE_RETURN
5148 || gimple_code (stmt) == GIMPLE_ASM
5149 || is_gimple_call (stmt))
5150 {
5151 struct walk_stmt_info wi;
5152 struct count_ptr_d count;
5153
5154 count.ptr = ptr;
5155 count.num_stores = 0;
5156 count.num_loads = 0;
5157
5158 memset (&wi, 0, sizeof (wi));
5159 wi.info = &count;
5160 walk_gimple_op (stmt, count_ptr_derefs, &wi);
5161
5162 *num_stores_p = count.num_stores;
5163 *num_loads_p = count.num_loads;
5164 }
5165
5166 gcc_assert (*num_uses_p >= *num_loads_p + *num_stores_p);
5167 }
5168
5169 /* From a tree operand OP return the base of a load or store operation
5170 or NULL_TREE if OP is not a load or a store. */
5171
5172 static tree
get_base_loadstore(tree op)5173 get_base_loadstore (tree op)
5174 {
5175 while (handled_component_p (op))
5176 op = TREE_OPERAND (op, 0);
5177 if (DECL_P (op)
5178 || INDIRECT_REF_P (op)
5179 || TREE_CODE (op) == MEM_REF
5180 || TREE_CODE (op) == TARGET_MEM_REF)
5181 return op;
5182 return NULL_TREE;
5183 }
5184
5185 /* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
5186 VISIT_ADDR if non-NULL on loads, store and address-taken operands
5187 passing the STMT, the base of the operand and DATA to it. The base
5188 will be either a decl, an indirect reference (including TARGET_MEM_REF)
5189 or the argument of an address expression.
5190 Returns the results of these callbacks or'ed. */
5191
5192 bool
walk_stmt_load_store_addr_ops(gimple stmt,void * data,bool (* visit_load)(gimple,tree,void *),bool (* visit_store)(gimple,tree,void *),bool (* visit_addr)(gimple,tree,void *))5193 walk_stmt_load_store_addr_ops (gimple stmt, void *data,
5194 bool (*visit_load)(gimple, tree, void *),
5195 bool (*visit_store)(gimple, tree, void *),
5196 bool (*visit_addr)(gimple, tree, void *))
5197 {
5198 bool ret = false;
5199 unsigned i;
5200 if (gimple_assign_single_p (stmt))
5201 {
5202 tree lhs, rhs;
5203 if (visit_store)
5204 {
5205 lhs = get_base_loadstore (gimple_assign_lhs (stmt));
5206 if (lhs)
5207 ret |= visit_store (stmt, lhs, data);
5208 }
5209 rhs = gimple_assign_rhs1 (stmt);
5210 while (handled_component_p (rhs))
5211 rhs = TREE_OPERAND (rhs, 0);
5212 if (visit_addr)
5213 {
5214 if (TREE_CODE (rhs) == ADDR_EXPR)
5215 ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
5216 else if (TREE_CODE (rhs) == TARGET_MEM_REF
5217 && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
5218 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
5219 else if (TREE_CODE (rhs) == OBJ_TYPE_REF
5220 && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
5221 ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
5222 0), data);
5223 else if (TREE_CODE (rhs) == CONSTRUCTOR)
5224 {
5225 unsigned int ix;
5226 tree val;
5227
5228 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), ix, val)
5229 if (TREE_CODE (val) == ADDR_EXPR)
5230 ret |= visit_addr (stmt, TREE_OPERAND (val, 0), data);
5231 else if (TREE_CODE (val) == OBJ_TYPE_REF
5232 && TREE_CODE (OBJ_TYPE_REF_OBJECT (val)) == ADDR_EXPR)
5233 ret |= visit_addr (stmt,
5234 TREE_OPERAND (OBJ_TYPE_REF_OBJECT (val),
5235 0), data);
5236 }
5237 lhs = gimple_assign_lhs (stmt);
5238 if (TREE_CODE (lhs) == TARGET_MEM_REF
5239 && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
5240 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), data);
5241 }
5242 if (visit_load)
5243 {
5244 rhs = get_base_loadstore (rhs);
5245 if (rhs)
5246 ret |= visit_load (stmt, rhs, data);
5247 }
5248 }
5249 else if (visit_addr
5250 && (is_gimple_assign (stmt)
5251 || gimple_code (stmt) == GIMPLE_COND))
5252 {
5253 for (i = 0; i < gimple_num_ops (stmt); ++i)
5254 {
5255 tree op = gimple_op (stmt, i);
5256 if (op == NULL_TREE)
5257 ;
5258 else if (TREE_CODE (op) == ADDR_EXPR)
5259 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
5260 /* COND_EXPR and VCOND_EXPR rhs1 argument is a comparison
5261 tree with two operands. */
5262 else if (i == 1 && COMPARISON_CLASS_P (op))
5263 {
5264 if (TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
5265 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 0),
5266 0), data);
5267 if (TREE_CODE (TREE_OPERAND (op, 1)) == ADDR_EXPR)
5268 ret |= visit_addr (stmt, TREE_OPERAND (TREE_OPERAND (op, 1),
5269 0), data);
5270 }
5271 }
5272 }
5273 else if (is_gimple_call (stmt))
5274 {
5275 if (visit_store)
5276 {
5277 tree lhs = gimple_call_lhs (stmt);
5278 if (lhs)
5279 {
5280 lhs = get_base_loadstore (lhs);
5281 if (lhs)
5282 ret |= visit_store (stmt, lhs, data);
5283 }
5284 }
5285 if (visit_load || visit_addr)
5286 for (i = 0; i < gimple_call_num_args (stmt); ++i)
5287 {
5288 tree rhs = gimple_call_arg (stmt, i);
5289 if (visit_addr
5290 && TREE_CODE (rhs) == ADDR_EXPR)
5291 ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
5292 else if (visit_load)
5293 {
5294 rhs = get_base_loadstore (rhs);
5295 if (rhs)
5296 ret |= visit_load (stmt, rhs, data);
5297 }
5298 }
5299 if (visit_addr
5300 && gimple_call_chain (stmt)
5301 && TREE_CODE (gimple_call_chain (stmt)) == ADDR_EXPR)
5302 ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (stmt), 0),
5303 data);
5304 if (visit_addr
5305 && gimple_call_return_slot_opt_p (stmt)
5306 && gimple_call_lhs (stmt) != NULL_TREE
5307 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
5308 ret |= visit_addr (stmt, gimple_call_lhs (stmt), data);
5309 }
5310 else if (gimple_code (stmt) == GIMPLE_ASM)
5311 {
5312 unsigned noutputs;
5313 const char *constraint;
5314 const char **oconstraints;
5315 bool allows_mem, allows_reg, is_inout;
5316 noutputs = gimple_asm_noutputs (stmt);
5317 oconstraints = XALLOCAVEC (const char *, noutputs);
5318 if (visit_store || visit_addr)
5319 for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
5320 {
5321 tree link = gimple_asm_output_op (stmt, i);
5322 tree op = get_base_loadstore (TREE_VALUE (link));
5323 if (op && visit_store)
5324 ret |= visit_store (stmt, op, data);
5325 if (visit_addr)
5326 {
5327 constraint = TREE_STRING_POINTER
5328 (TREE_VALUE (TREE_PURPOSE (link)));
5329 oconstraints[i] = constraint;
5330 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
5331 &allows_reg, &is_inout);
5332 if (op && !allows_reg && allows_mem)
5333 ret |= visit_addr (stmt, op, data);
5334 }
5335 }
5336 if (visit_load || visit_addr)
5337 for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
5338 {
5339 tree link = gimple_asm_input_op (stmt, i);
5340 tree op = TREE_VALUE (link);
5341 if (visit_addr
5342 && TREE_CODE (op) == ADDR_EXPR)
5343 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
5344 else if (visit_load || visit_addr)
5345 {
5346 op = get_base_loadstore (op);
5347 if (op)
5348 {
5349 if (visit_load)
5350 ret |= visit_load (stmt, op, data);
5351 if (visit_addr)
5352 {
5353 constraint = TREE_STRING_POINTER
5354 (TREE_VALUE (TREE_PURPOSE (link)));
5355 parse_input_constraint (&constraint, 0, 0, noutputs,
5356 0, oconstraints,
5357 &allows_mem, &allows_reg);
5358 if (!allows_reg && allows_mem)
5359 ret |= visit_addr (stmt, op, data);
5360 }
5361 }
5362 }
5363 }
5364 }
5365 else if (gimple_code (stmt) == GIMPLE_RETURN)
5366 {
5367 tree op = gimple_return_retval (stmt);
5368 if (op)
5369 {
5370 if (visit_addr
5371 && TREE_CODE (op) == ADDR_EXPR)
5372 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
5373 else if (visit_load)
5374 {
5375 op = get_base_loadstore (op);
5376 if (op)
5377 ret |= visit_load (stmt, op, data);
5378 }
5379 }
5380 }
5381 else if (visit_addr
5382 && gimple_code (stmt) == GIMPLE_PHI)
5383 {
5384 for (i = 0; i < gimple_phi_num_args (stmt); ++i)
5385 {
5386 tree op = PHI_ARG_DEF (stmt, i);
5387 if (TREE_CODE (op) == ADDR_EXPR)
5388 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
5389 }
5390 }
5391
5392 return ret;
5393 }
5394
5395 /* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
5396 should make a faster clone for this case. */
5397
5398 bool
walk_stmt_load_store_ops(gimple stmt,void * data,bool (* visit_load)(gimple,tree,void *),bool (* visit_store)(gimple,tree,void *))5399 walk_stmt_load_store_ops (gimple stmt, void *data,
5400 bool (*visit_load)(gimple, tree, void *),
5401 bool (*visit_store)(gimple, tree, void *))
5402 {
5403 return walk_stmt_load_store_addr_ops (stmt, data,
5404 visit_load, visit_store, NULL);
5405 }
5406
5407 /* Helper for gimple_ior_addresses_taken_1. */
5408
5409 static bool
gimple_ior_addresses_taken_1(gimple stmt ATTRIBUTE_UNUSED,tree addr,void * data)5410 gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
5411 tree addr, void *data)
5412 {
5413 bitmap addresses_taken = (bitmap)data;
5414 addr = get_base_address (addr);
5415 if (addr
5416 && DECL_P (addr))
5417 {
5418 bitmap_set_bit (addresses_taken, DECL_UID (addr));
5419 return true;
5420 }
5421 return false;
5422 }
5423
5424 /* Set the bit for the uid of all decls that have their address taken
5425 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
5426 were any in this stmt. */
5427
5428 bool
gimple_ior_addresses_taken(bitmap addresses_taken,gimple stmt)5429 gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
5430 {
5431 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
5432 gimple_ior_addresses_taken_1);
5433 }
5434
5435
5436 /* Return a printable name for symbol DECL. */
5437
5438 const char *
gimple_decl_printable_name(tree decl,int verbosity)5439 gimple_decl_printable_name (tree decl, int verbosity)
5440 {
5441 if (!DECL_NAME (decl))
5442 return NULL;
5443
5444 if (DECL_ASSEMBLER_NAME_SET_P (decl))
5445 {
5446 const char *str, *mangled_str;
5447 int dmgl_opts = DMGL_NO_OPTS;
5448
5449 if (verbosity >= 2)
5450 {
5451 dmgl_opts = DMGL_VERBOSE
5452 | DMGL_ANSI
5453 | DMGL_GNU_V3
5454 | DMGL_RET_POSTFIX;
5455 if (TREE_CODE (decl) == FUNCTION_DECL)
5456 dmgl_opts |= DMGL_PARAMS;
5457 }
5458
5459 mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5460 str = cplus_demangle_v3 (mangled_str, dmgl_opts);
5461 return (str) ? str : mangled_str;
5462 }
5463
5464 return IDENTIFIER_POINTER (DECL_NAME (decl));
5465 }
5466
5467 /* Return true when STMTs arguments match those of FNDECL. */
5468
5469 static bool
validate_call(gimple stmt,tree fndecl)5470 validate_call (gimple stmt, tree fndecl)
5471 {
5472 tree arg, targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5473 unsigned nargs = gimple_call_num_args (stmt);
5474 unsigned i;
5475 for (i = 0; i < nargs; ++i)
5476 {
5477 /* Variadic args follow. */
5478 if (!targs)
5479 return true;
5480 arg = gimple_call_arg (stmt, i);
5481 if (INTEGRAL_TYPE_P (TREE_TYPE (arg))
5482 && INTEGRAL_TYPE_P (TREE_VALUE (targs)))
5483 ;
5484 else if (POINTER_TYPE_P (TREE_TYPE (arg))
5485 && POINTER_TYPE_P (TREE_VALUE (targs)))
5486 ;
5487 else if (TREE_CODE (TREE_TYPE (arg))
5488 != TREE_CODE (TREE_VALUE (targs)))
5489 return false;
5490 targs = TREE_CHAIN (targs);
5491 }
5492 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
5493 return false;
5494 return true;
5495 }
5496
5497 /* Return true when STMT is builtins call to CLASS. */
5498
5499 bool
gimple_call_builtin_class_p(gimple stmt,enum built_in_class klass)5500 gimple_call_builtin_class_p (gimple stmt, enum built_in_class klass)
5501 {
5502 tree fndecl;
5503 if (is_gimple_call (stmt)
5504 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
5505 && DECL_BUILT_IN_CLASS (fndecl) == klass)
5506 return validate_call (stmt, fndecl);
5507 return false;
5508 }
5509
5510 /* Return true when STMT is builtins call to CODE of CLASS. */
5511
5512 bool
gimple_call_builtin_p(gimple stmt,enum built_in_function code)5513 gimple_call_builtin_p (gimple stmt, enum built_in_function code)
5514 {
5515 tree fndecl;
5516 if (is_gimple_call (stmt)
5517 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
5518 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5519 && DECL_FUNCTION_CODE (fndecl) == code)
5520 return validate_call (stmt, fndecl);
5521 return false;
5522 }
5523
5524 /* Return true if STMT clobbers memory. STMT is required to be a
5525 GIMPLE_ASM. */
5526
5527 bool
gimple_asm_clobbers_memory_p(const_gimple stmt)5528 gimple_asm_clobbers_memory_p (const_gimple stmt)
5529 {
5530 unsigned i;
5531
5532 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
5533 {
5534 tree op = gimple_asm_clobber_op (stmt, i);
5535 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
5536 return true;
5537 }
5538
5539 return false;
5540 }
5541 #include "gt-gimple.h"
5542