1 /* Gimple IR support functions.
3 Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
33 #include "diagnostic.h"
34 #include "tree-flow.h"
35 #include "value-prof.h"
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 htab_t gimple_types;
45 static struct pointer_map_t *type_hash_cache;
47 /* Global type comparison cache. */
48 static htab_t gtc_visited;
49 static struct obstack gtc_ob;
51 /* All the tuples have their operand vector (if present) at the very bottom
52 of the structure. Therefore, the offset required to find the
53 operands vector the size of the structure minus the size of the 1
54 element tree array at the end (see gimple_ops). */
55 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
56 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
57 EXPORTED_CONST size_t gimple_ops_offset_[] = {
58 #include "gsstruct.def"
62 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT),
63 static const size_t gsstruct_code_size[] = {
64 #include "gsstruct.def"
68 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
69 const char *const gimple_code_name[] = {
74 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
75 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
80 #ifdef GATHER_STATISTICS
83 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
84 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
86 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
87 static const char * const gimple_alloc_kind_names[] = {
95 #endif /* GATHER_STATISTICS */
97 /* A cache of gimple_seq objects. Sequences are created and destroyed
98 fairly often during gimplification. */
99 static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
101 /* Private API manipulation functions shared only with some
103 extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
104 extern void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
106 /* Gimple tuple constructors.
107 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
108 be passed a NULL to start with an empty sequence. */
110 /* Set the code for statement G to CODE. */
113 gimple_set_code (gimple g, enum gimple_code code)
115 g->gsbase.code = code;
118 /* Return the number of bytes needed to hold a GIMPLE statement with
122 gimple_size (enum gimple_code code)
124 return gsstruct_code_size[gss_for_code (code)];
127 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
131 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
136 size = gimple_size (code);
138 size += sizeof (tree) * (num_ops - 1);
140 #ifdef GATHER_STATISTICS
142 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
143 gimple_alloc_counts[(int) kind]++;
144 gimple_alloc_sizes[(int) kind] += size;
148 stmt = (gimple) ggc_alloc_cleared_stat (size PASS_MEM_STAT);
149 gimple_set_code (stmt, code);
150 gimple_set_num_ops (stmt, num_ops);
152 /* Do not call gimple_set_modified here as it has other side
153 effects and this tuple is still not completely built. */
154 stmt->gsbase.modified = 1;
159 /* Set SUBCODE to be the code of the expression computed by statement G. */
162 gimple_set_subcode (gimple g, unsigned subcode)
164 /* We only have 16 bits for the RHS code. Assert that we are not
166 gcc_assert (subcode < (1 << 16));
167 g->gsbase.subcode = subcode;
172 /* Build a tuple with operands. CODE is the statement to build (which
173 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the sub-code
174 for the new tuple. NUM_OPS is the number of operands to allocate. */
176 #define gimple_build_with_ops(c, s, n) \
177 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
180 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
181 unsigned num_ops MEM_STAT_DECL)
183 gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
184 gimple_set_subcode (s, subcode);
190 /* Build a GIMPLE_RETURN statement returning RETVAL. */
193 gimple_build_return (tree retval)
195 gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
197 gimple_return_set_retval (s, retval);
201 /* Reset alias information on call S. */
204 gimple_call_reset_alias_info (gimple s)
206 if (gimple_call_flags (s) & ECF_CONST)
207 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
209 pt_solution_reset (gimple_call_use_set (s));
210 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
211 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
213 pt_solution_reset (gimple_call_clobber_set (s));
216 /* Helper for gimple_build_call, gimple_build_call_vec and
217 gimple_build_call_from_tree. Build the basic components of a
218 GIMPLE_CALL statement to function FN with NARGS arguments. */
221 gimple_build_call_1 (tree fn, unsigned nargs)
223 gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
224 if (TREE_CODE (fn) == FUNCTION_DECL)
225 fn = build_fold_addr_expr (fn);
226 gimple_set_op (s, 1, fn);
227 gimple_call_reset_alias_info (s);
232 /* Build a GIMPLE_CALL statement to function FN with the arguments
233 specified in vector ARGS. */
236 gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
239 unsigned nargs = VEC_length (tree, args);
240 gimple call = gimple_build_call_1 (fn, nargs);
242 for (i = 0; i < nargs; i++)
243 gimple_call_set_arg (call, i, VEC_index (tree, args, i));
249 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
250 arguments. The ... are the arguments. */
253 gimple_build_call (tree fn, unsigned nargs, ...)
259 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
261 call = gimple_build_call_1 (fn, nargs);
263 va_start (ap, nargs);
264 for (i = 0; i < nargs; i++)
265 gimple_call_set_arg (call, i, va_arg (ap, tree));
272 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
273 assumed to be in GIMPLE form already. Minimal checking is done of
277 gimple_build_call_from_tree (tree t)
281 tree fndecl = get_callee_fndecl (t);
283 gcc_assert (TREE_CODE (t) == CALL_EXPR);
285 nargs = call_expr_nargs (t);
286 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
288 for (i = 0; i < nargs; i++)
289 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
291 gimple_set_block (call, TREE_BLOCK (t));
293 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
294 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
295 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
296 gimple_call_set_cannot_inline (call, CALL_CANNOT_INLINE_P (t));
297 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
298 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
299 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
300 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
301 gimple_set_no_warning (call, TREE_NO_WARNING (t));
307 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
308 *OP1_P and *OP2_P respectively. */
311 extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
314 enum gimple_rhs_class grhs_class;
316 *subcode_p = TREE_CODE (expr);
317 grhs_class = get_gimple_rhs_class (*subcode_p);
319 if (grhs_class == GIMPLE_BINARY_RHS)
321 *op1_p = TREE_OPERAND (expr, 0);
322 *op2_p = TREE_OPERAND (expr, 1);
324 else if (grhs_class == GIMPLE_UNARY_RHS)
326 *op1_p = TREE_OPERAND (expr, 0);
329 else if (grhs_class == GIMPLE_SINGLE_RHS)
339 /* Build a GIMPLE_ASSIGN statement.
341 LHS of the assignment.
342 RHS of the assignment which can be unary or binary. */
345 gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
347 enum tree_code subcode;
350 extract_ops_from_tree (rhs, &subcode, &op1, &op2);
351 return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2
356 /* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
357 OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
358 GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
361 gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
362 tree op2 MEM_STAT_DECL)
367 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
369 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
371 p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
373 gimple_assign_set_lhs (p, lhs);
374 gimple_assign_set_rhs1 (p, op1);
377 gcc_assert (num_ops > 2);
378 gimple_assign_set_rhs2 (p, op2);
385 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
387 DST/SRC are the destination and source respectively. You can pass
388 ungimplified trees in DST or SRC, in which case they will be
389 converted to a gimple operand if necessary.
391 This function returns the newly created GIMPLE_ASSIGN tuple. */
394 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
396 tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
397 gimplify_and_add (t, seq_p);
399 return gimple_seq_last_stmt (*seq_p);
403 /* Build a GIMPLE_COND statement.
405 PRED is the condition used to compare LHS and the RHS.
406 T_LABEL is the label to jump to if the condition is true.
407 F_LABEL is the label to jump to otherwise. */
410 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
411 tree t_label, tree f_label)
415 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
416 p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
417 gimple_cond_set_lhs (p, lhs);
418 gimple_cond_set_rhs (p, rhs);
419 gimple_cond_set_true_label (p, t_label);
420 gimple_cond_set_false_label (p, f_label);
425 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
428 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
429 tree *lhs_p, tree *rhs_p)
431 location_t loc = EXPR_LOCATION (cond);
432 gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
433 || TREE_CODE (cond) == TRUTH_NOT_EXPR
434 || is_gimple_min_invariant (cond)
435 || SSA_VAR_P (cond));
437 extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
439 /* Canonicalize conditionals of the form 'if (!VAL)'. */
440 if (*code_p == TRUTH_NOT_EXPR)
443 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
444 *rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
446 /* Canonicalize conditionals of the form 'if (VAL)' */
447 else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
450 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
451 *rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
456 /* Build a GIMPLE_COND statement from the conditional expression tree
457 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
460 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
465 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
466 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
469 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
470 boolean expression tree COND. */
473 gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
478 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
479 gimple_cond_set_condition (stmt, code, lhs, rhs);
482 /* Build a GIMPLE_LABEL statement for LABEL. */
485 gimple_build_label (tree label)
487 gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
488 gimple_label_set_label (p, label);
492 /* Build a GIMPLE_GOTO statement to label DEST. */
495 gimple_build_goto (tree dest)
497 gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
498 gimple_goto_set_dest (p, dest);
503 /* Build a GIMPLE_NOP statement. */
506 gimple_build_nop (void)
508 return gimple_alloc (GIMPLE_NOP, 0);
512 /* Build a GIMPLE_BIND statement.
513 VARS are the variables in BODY.
514 BLOCK is the containing block. */
517 gimple_build_bind (tree vars, gimple_seq body, tree block)
519 gimple p = gimple_alloc (GIMPLE_BIND, 0);
520 gimple_bind_set_vars (p, vars);
522 gimple_bind_set_body (p, body);
524 gimple_bind_set_block (p, block);
528 /* Helper function to set the simple fields of a asm stmt.
530 STRING is a pointer to a string that is the asm blocks assembly code.
531 NINPUT is the number of register inputs.
532 NOUTPUT is the number of register outputs.
533 NCLOBBERS is the number of clobbered registers.
537 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
538 unsigned nclobbers, unsigned nlabels)
541 int size = strlen (string);
543 /* ASMs with labels cannot have outputs. This should have been
544 enforced by the front end. */
545 gcc_assert (nlabels == 0 || noutputs == 0);
547 p = gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
548 ninputs + noutputs + nclobbers + nlabels);
550 p->gimple_asm.ni = ninputs;
551 p->gimple_asm.no = noutputs;
552 p->gimple_asm.nc = nclobbers;
553 p->gimple_asm.nl = nlabels;
554 p->gimple_asm.string = ggc_alloc_string (string, size);
556 #ifdef GATHER_STATISTICS
557 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
563 /* Build a GIMPLE_ASM statement.
565 STRING is the assembly code.
566 NINPUT is the number of register inputs.
567 NOUTPUT is the number of register outputs.
568 NCLOBBERS is the number of clobbered registers.
569 INPUTS is a vector of the input register parameters.
570 OUTPUTS is a vector of the output register parameters.
571 CLOBBERS is a vector of the clobbered register parameters.
572 LABELS is a vector of destination labels. */
575 gimple_build_asm_vec (const char *string, VEC(tree,gc)* inputs,
576 VEC(tree,gc)* outputs, VEC(tree,gc)* clobbers,
577 VEC(tree,gc)* labels)
582 p = gimple_build_asm_1 (string,
583 VEC_length (tree, inputs),
584 VEC_length (tree, outputs),
585 VEC_length (tree, clobbers),
586 VEC_length (tree, labels));
588 for (i = 0; i < VEC_length (tree, inputs); i++)
589 gimple_asm_set_input_op (p, i, VEC_index (tree, inputs, i));
591 for (i = 0; i < VEC_length (tree, outputs); i++)
592 gimple_asm_set_output_op (p, i, VEC_index (tree, outputs, i));
594 for (i = 0; i < VEC_length (tree, clobbers); i++)
595 gimple_asm_set_clobber_op (p, i, VEC_index (tree, clobbers, i));
597 for (i = 0; i < VEC_length (tree, labels); i++)
598 gimple_asm_set_label_op (p, i, VEC_index (tree, labels, i));
603 /* Build a GIMPLE_CATCH statement.
605 TYPES are the catch types.
606 HANDLER is the exception handler. */
609 gimple_build_catch (tree types, gimple_seq handler)
611 gimple p = gimple_alloc (GIMPLE_CATCH, 0);
612 gimple_catch_set_types (p, types);
614 gimple_catch_set_handler (p, handler);
619 /* Build a GIMPLE_EH_FILTER statement.
621 TYPES are the filter's types.
622 FAILURE is the filter's failure action. */
625 gimple_build_eh_filter (tree types, gimple_seq failure)
627 gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
628 gimple_eh_filter_set_types (p, types);
630 gimple_eh_filter_set_failure (p, failure);
635 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
638 gimple_build_eh_must_not_throw (tree decl)
640 gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
642 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
643 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
644 gimple_eh_must_not_throw_set_fndecl (p, decl);
649 /* Build a GIMPLE_TRY statement.
651 EVAL is the expression to evaluate.
652 CLEANUP is the cleanup expression.
653 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
654 whether this is a try/catch or a try/finally respectively. */
657 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
658 enum gimple_try_flags kind)
662 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
663 p = gimple_alloc (GIMPLE_TRY, 0);
664 gimple_set_subcode (p, kind);
666 gimple_try_set_eval (p, eval);
668 gimple_try_set_cleanup (p, cleanup);
673 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
675 CLEANUP is the cleanup expression. */
678 gimple_build_wce (gimple_seq cleanup)
680 gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
682 gimple_wce_set_cleanup (p, cleanup);
688 /* Build a GIMPLE_RESX statement. */
691 gimple_build_resx (int region)
693 gimple p = gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0);
694 p->gimple_eh_ctrl.region = region;
699 /* The helper for constructing a gimple switch statement.
700 INDEX is the switch's index.
701 NLABELS is the number of labels in the switch excluding the default.
702 DEFAULT_LABEL is the default label for the switch statement. */
705 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
707 /* nlabels + 1 default label + 1 index. */
708 gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
709 1 + (default_label != NULL) + nlabels);
710 gimple_switch_set_index (p, index);
712 gimple_switch_set_default_label (p, default_label);
717 /* Build a GIMPLE_SWITCH statement.
719 INDEX is the switch's index.
720 NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL.
721 ... are the labels excluding the default. */
724 gimple_build_switch (unsigned nlabels, tree index, tree default_label, ...)
728 gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
730 /* Store the rest of the labels. */
731 va_start (al, default_label);
732 offset = (default_label != NULL);
733 for (i = 0; i < nlabels; i++)
734 gimple_switch_set_label (p, i + offset, va_arg (al, tree));
741 /* Build a GIMPLE_SWITCH statement.
743 INDEX is the switch's index.
744 DEFAULT_LABEL is the default label
745 ARGS is a vector of labels excluding the default. */
748 gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
750 unsigned i, offset, nlabels = VEC_length (tree, args);
751 gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
753 /* Copy the labels from the vector to the switch statement. */
754 offset = (default_label != NULL);
755 for (i = 0; i < nlabels; i++)
756 gimple_switch_set_label (p, i + offset, VEC_index (tree, args, i));
761 /* Build a GIMPLE_EH_DISPATCH statement. */
764 gimple_build_eh_dispatch (int region)
766 gimple p = gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0);
767 p->gimple_eh_ctrl.region = region;
771 /* Build a new GIMPLE_DEBUG_BIND statement.
773 VAR is bound to VALUE; block and location are taken from STMT. */
776 gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
778 gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
779 (unsigned)GIMPLE_DEBUG_BIND, 2
782 gimple_debug_bind_set_var (p, var);
783 gimple_debug_bind_set_value (p, value);
786 gimple_set_block (p, gimple_block (stmt));
787 gimple_set_location (p, gimple_location (stmt));
794 /* Build a GIMPLE_OMP_CRITICAL statement.
796 BODY is the sequence of statements for which only one thread can execute.
797 NAME is optional identifier for this critical block. */
800 gimple_build_omp_critical (gimple_seq body, tree name)
802 gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
803 gimple_omp_critical_set_name (p, name);
805 gimple_omp_set_body (p, body);
810 /* Build a GIMPLE_OMP_FOR statement.
812 BODY is sequence of statements inside the for loop.
813 CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
814 lastprivate, reductions, ordered, schedule, and nowait.
815 COLLAPSE is the collapse count.
816 PRE_BODY is the sequence of statements that are loop invariant. */
819 gimple_build_omp_for (gimple_seq body, tree clauses, size_t collapse,
822 gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
824 gimple_omp_set_body (p, body);
825 gimple_omp_for_set_clauses (p, clauses);
826 p->gimple_omp_for.collapse = collapse;
827 p->gimple_omp_for.iter = GGC_CNEWVEC (struct gimple_omp_for_iter, collapse);
829 gimple_omp_for_set_pre_body (p, pre_body);
835 /* Build a GIMPLE_OMP_PARALLEL statement.
837 BODY is sequence of statements which are executed in parallel.
838 CLAUSES, are the OMP parallel construct's clauses.
839 CHILD_FN is the function created for the parallel threads to execute.
840 DATA_ARG are the shared data argument(s). */
843 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
846 gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
848 gimple_omp_set_body (p, body);
849 gimple_omp_parallel_set_clauses (p, clauses);
850 gimple_omp_parallel_set_child_fn (p, child_fn);
851 gimple_omp_parallel_set_data_arg (p, data_arg);
857 /* Build a GIMPLE_OMP_TASK statement.
859 BODY is sequence of statements which are executed by the explicit task.
860 CLAUSES, are the OMP parallel construct's clauses.
861 CHILD_FN is the function created for the parallel threads to execute.
862 DATA_ARG are the shared data argument(s).
863 COPY_FN is the optional function for firstprivate initialization.
864 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
867 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
868 tree data_arg, tree copy_fn, tree arg_size,
871 gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
873 gimple_omp_set_body (p, body);
874 gimple_omp_task_set_clauses (p, clauses);
875 gimple_omp_task_set_child_fn (p, child_fn);
876 gimple_omp_task_set_data_arg (p, data_arg);
877 gimple_omp_task_set_copy_fn (p, copy_fn);
878 gimple_omp_task_set_arg_size (p, arg_size);
879 gimple_omp_task_set_arg_align (p, arg_align);
885 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
887 BODY is the sequence of statements in the section. */
890 gimple_build_omp_section (gimple_seq body)
892 gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
894 gimple_omp_set_body (p, body);
900 /* Build a GIMPLE_OMP_MASTER statement.
902 BODY is the sequence of statements to be executed by just the master. */
905 gimple_build_omp_master (gimple_seq body)
907 gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
909 gimple_omp_set_body (p, body);
915 /* Build a GIMPLE_OMP_CONTINUE statement.
917 CONTROL_DEF is the definition of the control variable.
918 CONTROL_USE is the use of the control variable. */
921 gimple_build_omp_continue (tree control_def, tree control_use)
923 gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
924 gimple_omp_continue_set_control_def (p, control_def);
925 gimple_omp_continue_set_control_use (p, control_use);
929 /* Build a GIMPLE_OMP_ORDERED statement.
931 BODY is the sequence of statements inside a loop that will executed in
935 gimple_build_omp_ordered (gimple_seq body)
937 gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
939 gimple_omp_set_body (p, body);
945 /* Build a GIMPLE_OMP_RETURN statement.
946 WAIT_P is true if this is a non-waiting return. */
949 gimple_build_omp_return (bool wait_p)
951 gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
953 gimple_omp_return_set_nowait (p);
959 /* Build a GIMPLE_OMP_SECTIONS statement.
961 BODY is a sequence of section statements.
962 CLAUSES are any of the OMP sections contsruct's clauses: private,
963 firstprivate, lastprivate, reduction, and nowait. */
966 gimple_build_omp_sections (gimple_seq body, tree clauses)
968 gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
970 gimple_omp_set_body (p, body);
971 gimple_omp_sections_set_clauses (p, clauses);
977 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
980 gimple_build_omp_sections_switch (void)
982 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
986 /* Build a GIMPLE_OMP_SINGLE statement.
988 BODY is the sequence of statements that will be executed once.
989 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
990 copyprivate, nowait. */
993 gimple_build_omp_single (gimple_seq body, tree clauses)
995 gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
997 gimple_omp_set_body (p, body);
998 gimple_omp_single_set_clauses (p, clauses);
1004 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1007 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1009 gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
1010 gimple_omp_atomic_load_set_lhs (p, lhs);
1011 gimple_omp_atomic_load_set_rhs (p, rhs);
1015 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1017 VAL is the value we are storing. */
1020 gimple_build_omp_atomic_store (tree val)
1022 gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
1023 gimple_omp_atomic_store_set_val (p, val);
1027 /* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
1028 predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
1031 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
1033 gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
1034 /* Ensure all the predictors fit into the lower bits of the subcode. */
1035 gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
1036 gimple_predict_set_predictor (p, predictor);
1037 gimple_predict_set_outcome (p, outcome);
1041 #if defined ENABLE_GIMPLE_CHECKING
1042 /* Complain of a gimple type mismatch and die. */
1045 gimple_check_failed (const_gimple gs, const char *file, int line,
1046 const char *function, enum gimple_code code,
1047 enum tree_code subcode)
1049 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1050 gimple_code_name[code],
1051 tree_code_name[subcode],
1052 gimple_code_name[gimple_code (gs)],
1053 gs->gsbase.subcode > 0
1054 ? tree_code_name[gs->gsbase.subcode]
1056 function, trim_filename (file), line);
1058 #endif /* ENABLE_GIMPLE_CHECKING */
1061 /* Allocate a new GIMPLE sequence in GC memory and return it. If
1062 there are free sequences in GIMPLE_SEQ_CACHE return one of those
1066 gimple_seq_alloc (void)
1068 gimple_seq seq = gimple_seq_cache;
1071 gimple_seq_cache = gimple_seq_cache->next_free;
1072 gcc_assert (gimple_seq_cache != seq);
1073 memset (seq, 0, sizeof (*seq));
1077 seq = (gimple_seq) ggc_alloc_cleared (sizeof (*seq));
1078 #ifdef GATHER_STATISTICS
1079 gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
1080 gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
1087 /* Return SEQ to the free pool of GIMPLE sequences. */
1090 gimple_seq_free (gimple_seq seq)
1095 gcc_assert (gimple_seq_first (seq) == NULL);
1096 gcc_assert (gimple_seq_last (seq) == NULL);
1098 /* If this triggers, it's a sign that the same list is being freed
1100 gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
1102 /* Add SEQ to the pool of free sequences. */
1103 seq->next_free = gimple_seq_cache;
1104 gimple_seq_cache = seq;
1108 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1109 *SEQ_P is NULL, a new sequence is allocated. */
1112 gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
1114 gimple_stmt_iterator si;
1120 *seq_p = gimple_seq_alloc ();
1122 si = gsi_last (*seq_p);
1123 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1127 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1128 NULL, a new sequence is allocated. */
1131 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1133 gimple_stmt_iterator si;
1139 *dst_p = gimple_seq_alloc ();
1141 si = gsi_last (*dst_p);
1142 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1146 /* Helper function of empty_body_p. Return true if STMT is an empty
1150 empty_stmt_p (gimple stmt)
1152 if (gimple_code (stmt) == GIMPLE_NOP)
1154 if (gimple_code (stmt) == GIMPLE_BIND)
1155 return empty_body_p (gimple_bind_body (stmt));
1160 /* Return true if BODY contains nothing but empty statements. */
1163 empty_body_p (gimple_seq body)
1165 gimple_stmt_iterator i;
1167 if (gimple_seq_empty_p (body))
1169 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1170 if (!empty_stmt_p (gsi_stmt (i))
1171 && !is_gimple_debug (gsi_stmt (i)))
1178 /* Perform a deep copy of sequence SRC and return the result. */
1181 gimple_seq_copy (gimple_seq src)
1183 gimple_stmt_iterator gsi;
1184 gimple_seq new_seq = gimple_seq_alloc ();
1187 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1189 stmt = gimple_copy (gsi_stmt (gsi));
1190 gimple_seq_add_stmt (&new_seq, stmt);
1197 /* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
1198 on each one. WI is as in walk_gimple_stmt.
1200 If walk_gimple_stmt returns non-NULL, the walk is stopped, the
1201 value is stored in WI->CALLBACK_RESULT and the statement that
1202 produced the value is returned.
1204 Otherwise, all the statements are walked and NULL returned. */
1207 walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
1208 walk_tree_fn callback_op, struct walk_stmt_info *wi)
1210 gimple_stmt_iterator gsi;
1212 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
1214 tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
1217 /* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
1220 wi->callback_result = ret;
1221 return gsi_stmt (gsi);
1226 wi->callback_result = NULL_TREE;
1232 /* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
1235 walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
1236 struct walk_stmt_info *wi)
1240 const char **oconstraints;
1242 const char *constraint;
1243 bool allows_mem, allows_reg, is_inout;
1245 noutputs = gimple_asm_noutputs (stmt);
1246 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
1251 for (i = 0; i < noutputs; i++)
1253 op = gimple_asm_output_op (stmt, i);
1254 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1255 oconstraints[i] = constraint;
1256 parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
1259 wi->val_only = (allows_reg || !allows_mem);
1260 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1265 n = gimple_asm_ninputs (stmt);
1266 for (i = 0; i < n; i++)
1268 op = gimple_asm_input_op (stmt, i);
1269 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
1270 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1271 oconstraints, &allows_mem, &allows_reg);
1274 wi->val_only = (allows_reg || !allows_mem);
1275 /* Although input "m" is not really a LHS, we need a lvalue. */
1276 wi->is_lhs = !wi->val_only;
1278 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1286 wi->val_only = true;
1289 n = gimple_asm_nlabels (stmt);
1290 for (i = 0; i < n; i++)
1292 op = gimple_asm_label_op (stmt, i);
1293 ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
1302 /* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
1303 STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
1305 CALLBACK_OP is called on each operand of STMT via walk_tree.
1306 Additional parameters to walk_tree must be stored in WI. For each operand
1307 OP, walk_tree is called as:
1309 walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
1311 If CALLBACK_OP returns non-NULL for an operand, the remaining
1312 operands are not scanned.
1314 The return value is that returned by the last call to walk_tree, or
1315 NULL_TREE if no CALLBACK_OP is specified. */
1318 walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
1319 struct walk_stmt_info *wi)
1321 struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
1323 tree ret = NULL_TREE;
1325 switch (gimple_code (stmt))
1328 /* Walk the RHS operands. If the LHS is of a non-renamable type or
1329 is a register variable, we may use a COMPONENT_REF on the RHS. */
1332 tree lhs = gimple_assign_lhs (stmt);
1334 = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
1335 || !gimple_assign_single_p (stmt);
1338 for (i = 1; i < gimple_num_ops (stmt); i++)
1340 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
1346 /* Walk the LHS. If the RHS is appropriate for a memory, we
1347 may use a COMPONENT_REF on the LHS. */
1350 /* If the RHS has more than 1 operand, it is not appropriate
1352 wi->val_only = !is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
1353 || !gimple_assign_single_p (stmt);
1357 ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
1363 wi->val_only = true;
1372 ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
1376 ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
1380 for (i = 0; i < gimple_call_num_args (stmt); i++)
1382 ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
1391 ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
1400 ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
1406 case GIMPLE_EH_FILTER:
1407 ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
1414 ret = walk_gimple_asm (stmt, callback_op, wi);
1419 case GIMPLE_OMP_CONTINUE:
1420 ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
1421 callback_op, wi, pset);
1425 ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
1426 callback_op, wi, pset);
1431 case GIMPLE_OMP_CRITICAL:
1432 ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
1438 case GIMPLE_OMP_FOR:
1439 ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
1443 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1445 ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
1449 ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
1453 ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
1457 ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
1464 case GIMPLE_OMP_PARALLEL:
1465 ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
1469 ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
1473 ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
1479 case GIMPLE_OMP_TASK:
1480 ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
1484 ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
1488 ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
1492 ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
1496 ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
1500 ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
1506 case GIMPLE_OMP_SECTIONS:
1507 ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
1512 ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
1519 case GIMPLE_OMP_SINGLE:
1520 ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
1526 case GIMPLE_OMP_ATOMIC_LOAD:
1527 ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
1532 ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
1538 case GIMPLE_OMP_ATOMIC_STORE:
1539 ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
1545 /* Tuples that do not have operands. */
1548 case GIMPLE_OMP_RETURN:
1549 case GIMPLE_PREDICT:
1554 enum gimple_statement_structure_enum gss;
1555 gss = gimple_statement_structure (stmt);
1556 if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
1557 for (i = 0; i < gimple_num_ops (stmt); i++)
1559 ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
1571 /* Walk the current statement in GSI (optionally using traversal state
1572 stored in WI). If WI is NULL, no state is kept during traversal.
1573 The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
1574 that it has handled all the operands of the statement, its return
1575 value is returned. Otherwise, the return value from CALLBACK_STMT
1576 is discarded and its operands are scanned.
1578 If CALLBACK_STMT is NULL or it didn't handle the operands,
1579 CALLBACK_OP is called on each operand of the statement via
1580 walk_gimple_op. If walk_gimple_op returns non-NULL for any
1581 operand, the remaining operands are not scanned. In this case, the
1582 return value from CALLBACK_OP is returned.
1584 In any other case, NULL_TREE is returned. */
1587 walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
1588 walk_tree_fn callback_op, struct walk_stmt_info *wi)
1592 gimple stmt = gsi_stmt (*gsi);
1597 if (wi && wi->want_locations && gimple_has_location (stmt))
1598 input_location = gimple_location (stmt);
1602 /* Invoke the statement callback. Return if the callback handled
1603 all of STMT operands by itself. */
1606 bool handled_ops = false;
1607 tree_ret = callback_stmt (gsi, &handled_ops, wi);
1611 /* If CALLBACK_STMT did not handle operands, it should not have
1612 a value to return. */
1613 gcc_assert (tree_ret == NULL);
1615 /* Re-read stmt in case the callback changed it. */
1616 stmt = gsi_stmt (*gsi);
1619 /* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
1622 tree_ret = walk_gimple_op (stmt, callback_op, wi);
1627 /* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
1628 switch (gimple_code (stmt))
1631 ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
1634 return wi->callback_result;
1638 ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
1641 return wi->callback_result;
1644 case GIMPLE_EH_FILTER:
1645 ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
1648 return wi->callback_result;
1652 ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
1655 return wi->callback_result;
1657 ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
1660 return wi->callback_result;
1663 case GIMPLE_OMP_FOR:
1664 ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
1667 return wi->callback_result;
1670 case GIMPLE_OMP_CRITICAL:
1671 case GIMPLE_OMP_MASTER:
1672 case GIMPLE_OMP_ORDERED:
1673 case GIMPLE_OMP_SECTION:
1674 case GIMPLE_OMP_PARALLEL:
1675 case GIMPLE_OMP_TASK:
1676 case GIMPLE_OMP_SECTIONS:
1677 case GIMPLE_OMP_SINGLE:
1678 ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt, callback_op,
1681 return wi->callback_result;
1684 case GIMPLE_WITH_CLEANUP_EXPR:
1685 ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
1688 return wi->callback_result;
1692 gcc_assert (!gimple_has_substatements (stmt));
1700 /* Set sequence SEQ to be the GIMPLE body for function FN. */
1703 gimple_set_body (tree fndecl, gimple_seq seq)
1705 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1708 /* If FNDECL still does not have a function structure associated
1709 with it, then it does not make sense for it to receive a
1711 gcc_assert (seq == NULL);
1714 fn->gimple_body = seq;
1718 /* Return the body of GIMPLE statements for function FN. */
1721 gimple_body (tree fndecl)
1723 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1724 return fn ? fn->gimple_body : NULL;
1727 /* Return true when FNDECL has Gimple body either in unlowered
1730 gimple_has_body_p (tree fndecl)
1732 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
1733 return (gimple_body (fndecl) || (fn && fn->cfg));
1736 /* Detect flags from a GIMPLE_CALL. This is just like
1737 call_expr_flags, but for gimple tuples. */
1740 gimple_call_flags (const_gimple stmt)
1743 tree decl = gimple_call_fndecl (stmt);
1747 flags = flags_from_decl_or_type (decl);
1750 t = TREE_TYPE (gimple_call_fn (stmt));
1751 if (t && TREE_CODE (t) == POINTER_TYPE)
1752 flags = flags_from_decl_or_type (TREE_TYPE (t));
1757 if (stmt->gsbase.subcode & GF_CALL_NOTHROW)
1758 flags |= ECF_NOTHROW;
1763 /* Detects argument flags for argument number ARG on call STMT. */
1766 gimple_call_arg_flags (const_gimple stmt, unsigned arg)
1768 tree type = TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt)));
1769 tree attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1773 attr = TREE_VALUE (TREE_VALUE (attr));
1774 if (1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1777 switch (TREE_STRING_POINTER (attr)[1 + arg])
1784 return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1787 return EAF_NOCLOBBER | EAF_NOESCAPE;
1790 return EAF_DIRECT | EAF_NOESCAPE;
1793 return EAF_NOESCAPE;
1801 /* Detects return flags for the call STMT. */
1804 gimple_call_return_flags (const_gimple stmt)
1807 tree attr = NULL_TREE;
1809 if (gimple_call_flags (stmt) & ECF_MALLOC)
1812 type = TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt)));
1813 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1817 attr = TREE_VALUE (TREE_VALUE (attr));
1818 if (TREE_STRING_LENGTH (attr) < 1)
1821 switch (TREE_STRING_POINTER (attr)[0])
1827 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1838 /* Return true if GS is a copy assignment. */
1841 gimple_assign_copy_p (gimple gs)
1843 return gimple_code (gs) == GIMPLE_ASSIGN
1844 && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1845 == GIMPLE_SINGLE_RHS
1846 && is_gimple_val (gimple_op (gs, 1));
1850 /* Return true if GS is a SSA_NAME copy assignment. */
1853 gimple_assign_ssa_name_copy_p (gimple gs)
1855 return (gimple_code (gs) == GIMPLE_ASSIGN
1856 && (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1857 == GIMPLE_SINGLE_RHS)
1858 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1859 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1863 /* Return true if GS is an assignment with a singleton RHS, i.e.,
1864 there is no operator associated with the assignment itself.
1865 Unlike gimple_assign_copy_p, this predicate returns true for
1866 any RHS operand, including those that perform an operation
1867 and do not have the semantics of a copy, such as COND_EXPR. */
1870 gimple_assign_single_p (gimple gs)
1872 return (gimple_code (gs) == GIMPLE_ASSIGN
1873 && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
1874 == GIMPLE_SINGLE_RHS);
1877 /* Return true if GS is an assignment with a unary RHS, but the
1878 operator has no effect on the assigned value. The logic is adapted
1879 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1880 instances in which STRIP_NOPS was previously applied to the RHS of
1883 NOTE: In the use cases that led to the creation of this function
1884 and of gimple_assign_single_p, it is typical to test for either
1885 condition and to proceed in the same manner. In each case, the
1886 assigned value is represented by the single RHS operand of the
1887 assignment. I suspect there may be cases where gimple_assign_copy_p,
1888 gimple_assign_single_p, or equivalent logic is used where a similar
1889 treatment of unary NOPs is appropriate. */
1892 gimple_assign_unary_nop_p (gimple gs)
1894 return (gimple_code (gs) == GIMPLE_ASSIGN
1895 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1896 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1897 && gimple_assign_rhs1 (gs) != error_mark_node
1898 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1899 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1902 /* Set BB to be the basic block holding G. */
1905 gimple_set_bb (gimple stmt, basic_block bb)
1907 stmt->gsbase.bb = bb;
1909 /* If the statement is a label, add the label to block-to-labels map
1910 so that we can speed up edge creation for GIMPLE_GOTOs. */
1911 if (cfun->cfg && gimple_code (stmt) == GIMPLE_LABEL)
1916 t = gimple_label_label (stmt);
1917 uid = LABEL_DECL_UID (t);
1920 unsigned old_len = VEC_length (basic_block, label_to_block_map);
1921 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1922 if (old_len <= (unsigned) uid)
1924 unsigned new_len = 3 * uid / 2 + 1;
1926 VEC_safe_grow_cleared (basic_block, gc, label_to_block_map,
1931 VEC_replace (basic_block, label_to_block_map, uid, bb);
1936 /* Modify the RHS of the assignment pointed-to by GSI using the
1937 operands in the expression tree EXPR.
1939 NOTE: The statement pointed-to by GSI may be reallocated if it
1940 did not have enough operand slots.
1942 This function is useful to convert an existing tree expression into
1943 the flat representation used for the RHS of a GIMPLE assignment.
1944 It will reallocate memory as needed to expand or shrink the number
1945 of operand slots needed to represent EXPR.
1947 NOTE: If you find yourself building a tree and then calling this
1948 function, you are most certainly doing it the slow way. It is much
1949 better to build a new assignment or to use the function
1950 gimple_assign_set_rhs_with_ops, which does not require an
1951 expression tree to be built. */
1954 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1956 enum tree_code subcode;
1959 extract_ops_from_tree (expr, &subcode, &op1, &op2);
1960 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2);
1964 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1965 operands OP1 and OP2.
1967 NOTE: The statement pointed-to by GSI may be reallocated if it
1968 did not have enough operand slots. */
1971 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1974 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1975 gimple stmt = gsi_stmt (*gsi);
1977 /* If the new CODE needs more operands, allocate a new statement. */
1978 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1980 tree lhs = gimple_assign_lhs (stmt);
1981 gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1982 memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1983 gsi_replace (gsi, new_stmt, true);
1986 /* The LHS needs to be reset as this also changes the SSA name
1988 gimple_assign_set_lhs (stmt, lhs);
1991 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1992 gimple_set_subcode (stmt, code);
1993 gimple_assign_set_rhs1 (stmt, op1);
1994 if (new_rhs_ops > 1)
1995 gimple_assign_set_rhs2 (stmt, op2);
1999 /* Return the LHS of a statement that performs an assignment,
2000 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
2001 for a call to a function that returns no value, or for a
2002 statement other than an assignment or a call. */
2005 gimple_get_lhs (const_gimple stmt)
2007 enum gimple_code code = gimple_code (stmt);
2009 if (code == GIMPLE_ASSIGN)
2010 return gimple_assign_lhs (stmt);
2011 else if (code == GIMPLE_CALL)
2012 return gimple_call_lhs (stmt);
2018 /* Set the LHS of a statement that performs an assignment,
2019 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2022 gimple_set_lhs (gimple stmt, tree lhs)
2024 enum gimple_code code = gimple_code (stmt);
2026 if (code == GIMPLE_ASSIGN)
2027 gimple_assign_set_lhs (stmt, lhs);
2028 else if (code == GIMPLE_CALL)
2029 gimple_call_set_lhs (stmt, lhs);
2034 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
2035 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
2036 expression with a different value.
2038 This will update any annotations (say debug bind stmts) referring
2039 to the original LHS, so that they use the RHS instead. This is
2040 done even if NLHS and LHS are the same, for it is understood that
2041 the RHS will be modified afterwards, and NLHS will not be assigned
2042 an equivalent value.
2044 Adjusting any non-annotation uses of the LHS, if needed, is a
2045 responsibility of the caller.
2047 The effect of this call should be pretty much the same as that of
2048 inserting a copy of STMT before STMT, and then removing the
2049 original stmt, at which time gsi_remove() would have update
2050 annotations, but using this function saves all the inserting,
2051 copying and removing. */
2054 gimple_replace_lhs (gimple stmt, tree nlhs)
2056 if (MAY_HAVE_DEBUG_STMTS)
2058 tree lhs = gimple_get_lhs (stmt);
2060 gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
2062 insert_debug_temp_for_var_def (NULL, lhs);
2065 gimple_set_lhs (stmt, nlhs);
2068 /* Return a deep copy of statement STMT. All the operands from STMT
2069 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
2070 and VUSE operand arrays are set to empty in the new copy. */
2073 gimple_copy (gimple stmt)
2075 enum gimple_code code = gimple_code (stmt);
2076 unsigned num_ops = gimple_num_ops (stmt);
2077 gimple copy = gimple_alloc (code, num_ops);
2080 /* Shallow copy all the fields from STMT. */
2081 memcpy (copy, stmt, gimple_size (code));
2083 /* If STMT has sub-statements, deep-copy them as well. */
2084 if (gimple_has_substatements (stmt))
2089 switch (gimple_code (stmt))
2092 new_seq = gimple_seq_copy (gimple_bind_body (stmt));
2093 gimple_bind_set_body (copy, new_seq);
2094 gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
2095 gimple_bind_set_block (copy, gimple_bind_block (stmt));
2099 new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
2100 gimple_catch_set_handler (copy, new_seq);
2101 t = unshare_expr (gimple_catch_types (stmt));
2102 gimple_catch_set_types (copy, t);
2105 case GIMPLE_EH_FILTER:
2106 new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
2107 gimple_eh_filter_set_failure (copy, new_seq);
2108 t = unshare_expr (gimple_eh_filter_types (stmt));
2109 gimple_eh_filter_set_types (copy, t);
2113 new_seq = gimple_seq_copy (gimple_try_eval (stmt));
2114 gimple_try_set_eval (copy, new_seq);
2115 new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
2116 gimple_try_set_cleanup (copy, new_seq);
2119 case GIMPLE_OMP_FOR:
2120 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
2121 gimple_omp_for_set_pre_body (copy, new_seq);
2122 t = unshare_expr (gimple_omp_for_clauses (stmt));
2123 gimple_omp_for_set_clauses (copy, t);
2124 copy->gimple_omp_for.iter
2125 = GGC_NEWVEC (struct gimple_omp_for_iter,
2126 gimple_omp_for_collapse (stmt));
2127 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
2129 gimple_omp_for_set_cond (copy, i,
2130 gimple_omp_for_cond (stmt, i));
2131 gimple_omp_for_set_index (copy, i,
2132 gimple_omp_for_index (stmt, i));
2133 t = unshare_expr (gimple_omp_for_initial (stmt, i));
2134 gimple_omp_for_set_initial (copy, i, t);
2135 t = unshare_expr (gimple_omp_for_final (stmt, i));
2136 gimple_omp_for_set_final (copy, i, t);
2137 t = unshare_expr (gimple_omp_for_incr (stmt, i));
2138 gimple_omp_for_set_incr (copy, i, t);
2142 case GIMPLE_OMP_PARALLEL:
2143 t = unshare_expr (gimple_omp_parallel_clauses (stmt));
2144 gimple_omp_parallel_set_clauses (copy, t);
2145 t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
2146 gimple_omp_parallel_set_child_fn (copy, t);
2147 t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
2148 gimple_omp_parallel_set_data_arg (copy, t);
2151 case GIMPLE_OMP_TASK:
2152 t = unshare_expr (gimple_omp_task_clauses (stmt));
2153 gimple_omp_task_set_clauses (copy, t);
2154 t = unshare_expr (gimple_omp_task_child_fn (stmt));
2155 gimple_omp_task_set_child_fn (copy, t);
2156 t = unshare_expr (gimple_omp_task_data_arg (stmt));
2157 gimple_omp_task_set_data_arg (copy, t);
2158 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
2159 gimple_omp_task_set_copy_fn (copy, t);
2160 t = unshare_expr (gimple_omp_task_arg_size (stmt));
2161 gimple_omp_task_set_arg_size (copy, t);
2162 t = unshare_expr (gimple_omp_task_arg_align (stmt));
2163 gimple_omp_task_set_arg_align (copy, t);
2166 case GIMPLE_OMP_CRITICAL:
2167 t = unshare_expr (gimple_omp_critical_name (stmt));
2168 gimple_omp_critical_set_name (copy, t);
2171 case GIMPLE_OMP_SECTIONS:
2172 t = unshare_expr (gimple_omp_sections_clauses (stmt));
2173 gimple_omp_sections_set_clauses (copy, t);
2174 t = unshare_expr (gimple_omp_sections_control (stmt));
2175 gimple_omp_sections_set_control (copy, t);
2178 case GIMPLE_OMP_SINGLE:
2179 case GIMPLE_OMP_SECTION:
2180 case GIMPLE_OMP_MASTER:
2181 case GIMPLE_OMP_ORDERED:
2183 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2184 gimple_omp_set_body (copy, new_seq);
2187 case GIMPLE_WITH_CLEANUP_EXPR:
2188 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2189 gimple_wce_set_cleanup (copy, new_seq);
2197 /* Make copy of operands. */
2200 for (i = 0; i < num_ops; i++)
2201 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2203 /* Clear out SSA operand vectors on COPY. */
2204 if (gimple_has_ops (stmt))
2206 gimple_set_def_ops (copy, NULL);
2207 gimple_set_use_ops (copy, NULL);
2210 if (gimple_has_mem_ops (stmt))
2212 gimple_set_vdef (copy, gimple_vdef (stmt));
2213 gimple_set_vuse (copy, gimple_vuse (stmt));
2216 /* SSA operands need to be updated. */
2217 gimple_set_modified (copy, true);
2224 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2225 a MODIFIED field. */
2228 gimple_set_modified (gimple s, bool modifiedp)
2230 if (gimple_has_ops (s))
2232 s->gsbase.modified = (unsigned) modifiedp;
2236 && is_gimple_call (s)
2237 && gimple_call_noreturn_p (s))
2238 VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), s);
2243 /* Return true if statement S has side-effects. We consider a
2244 statement to have side effects if:
2246 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2247 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2250 gimple_has_side_effects (const_gimple s)
2254 if (is_gimple_debug (s))
2257 /* We don't have to scan the arguments to check for
2258 volatile arguments, though, at present, we still
2259 do a scan to check for TREE_SIDE_EFFECTS. */
2260 if (gimple_has_volatile_ops (s))
2263 if (is_gimple_call (s))
2265 unsigned nargs = gimple_call_num_args (s);
2267 if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
2269 else if (gimple_call_flags (s) & ECF_LOOPING_CONST_OR_PURE)
2270 /* An infinite loop is considered a side effect. */
2273 if (gimple_call_lhs (s)
2274 && TREE_SIDE_EFFECTS (gimple_call_lhs (s)))
2276 gcc_assert (gimple_has_volatile_ops (s));
2280 if (TREE_SIDE_EFFECTS (gimple_call_fn (s)))
2283 for (i = 0; i < nargs; i++)
2284 if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i)))
2286 gcc_assert (gimple_has_volatile_ops (s));
2294 for (i = 0; i < gimple_num_ops (s); i++)
2295 if (TREE_SIDE_EFFECTS (gimple_op (s, i)))
2297 gcc_assert (gimple_has_volatile_ops (s));
2305 /* Return true if the RHS of statement S has side effects.
2306 We may use it to determine if it is admissable to replace
2307 an assignment or call with a copy of a previously-computed
2308 value. In such cases, side-effects due the the LHS are
2312 gimple_rhs_has_side_effects (const_gimple s)
2316 if (is_gimple_call (s))
2318 unsigned nargs = gimple_call_num_args (s);
2320 if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
2323 /* We cannot use gimple_has_volatile_ops here,
2324 because we must ignore a volatile LHS. */
2325 if (TREE_SIDE_EFFECTS (gimple_call_fn (s))
2326 || TREE_THIS_VOLATILE (gimple_call_fn (s)))
2328 gcc_assert (gimple_has_volatile_ops (s));
2332 for (i = 0; i < nargs; i++)
2333 if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i))
2334 || TREE_THIS_VOLATILE (gimple_call_arg (s, i)))
2339 else if (is_gimple_assign (s))
2341 /* Skip the first operand, the LHS. */
2342 for (i = 1; i < gimple_num_ops (s); i++)
2343 if (TREE_SIDE_EFFECTS (gimple_op (s, i))
2344 || TREE_THIS_VOLATILE (gimple_op (s, i)))
2346 gcc_assert (gimple_has_volatile_ops (s));
2350 else if (is_gimple_debug (s))
2354 /* For statements without an LHS, examine all arguments. */
2355 for (i = 0; i < gimple_num_ops (s); i++)
2356 if (TREE_SIDE_EFFECTS (gimple_op (s, i))
2357 || TREE_THIS_VOLATILE (gimple_op (s, i)))
2359 gcc_assert (gimple_has_volatile_ops (s));
2368 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2369 Return true if S can trap. If INCLUDE_LHS is true and S is a
2370 GIMPLE_ASSIGN, the LHS of the assignment is also checked.
2371 Otherwise, only the RHS of the assignment is checked. */
2374 gimple_could_trap_p_1 (gimple s, bool include_lhs)
2377 tree t, div = NULL_TREE;
2380 start = (is_gimple_assign (s) && !include_lhs) ? 1 : 0;
2382 for (i = start; i < gimple_num_ops (s); i++)
2383 if (tree_could_trap_p (gimple_op (s, i)))
2386 switch (gimple_code (s))
2389 return gimple_asm_volatile_p (s);
2392 t = gimple_call_fndecl (s);
2393 /* Assume that calls to weak functions may trap. */
2394 if (!t || !DECL_P (t) || DECL_WEAK (t))
2399 t = gimple_expr_type (s);
2400 op = gimple_assign_rhs_code (s);
2401 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2402 div = gimple_assign_rhs2 (s);
2403 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2404 (INTEGRAL_TYPE_P (t)
2405 && TYPE_OVERFLOW_TRAPS (t)),
2417 /* Return true if statement S can trap. */
2420 gimple_could_trap_p (gimple s)
2422 return gimple_could_trap_p_1 (s, true);
2426 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2429 gimple_assign_rhs_could_trap_p (gimple s)
2431 gcc_assert (is_gimple_assign (s));
2432 return gimple_could_trap_p_1 (s, false);
2436 /* Print debugging information for gimple stmts generated. */
2439 dump_gimple_statistics (void)
2441 #ifdef GATHER_STATISTICS
2442 int i, total_tuples = 0, total_bytes = 0;
2444 fprintf (stderr, "\nGIMPLE statements\n");
2445 fprintf (stderr, "Kind Stmts Bytes\n");
2446 fprintf (stderr, "---------------------------------------\n");
2447 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2449 fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
2450 gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2451 total_tuples += gimple_alloc_counts[i];
2452 total_bytes += gimple_alloc_sizes[i];
2454 fprintf (stderr, "---------------------------------------\n");
2455 fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2456 fprintf (stderr, "---------------------------------------\n");
2458 fprintf (stderr, "No gimple statistics\n");
2463 /* Return the number of operands needed on the RHS of a GIMPLE
2464 assignment for an expression with tree code CODE. */
2467 get_gimple_rhs_num_ops (enum tree_code code)
2469 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2471 if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2473 else if (rhs_class == GIMPLE_BINARY_RHS)
2479 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2481 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2482 : ((TYPE) == tcc_binary \
2483 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2484 : ((TYPE) == tcc_constant \
2485 || (TYPE) == tcc_declaration \
2486 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2487 : ((SYM) == TRUTH_AND_EXPR \
2488 || (SYM) == TRUTH_OR_EXPR \
2489 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2490 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2491 : ((SYM) == COND_EXPR \
2492 || (SYM) == CONSTRUCTOR \
2493 || (SYM) == OBJ_TYPE_REF \
2494 || (SYM) == ASSERT_EXPR \
2495 || (SYM) == ADDR_EXPR \
2496 || (SYM) == WITH_SIZE_EXPR \
2497 || (SYM) == SSA_NAME \
2498 || (SYM) == POLYNOMIAL_CHREC \
2499 || (SYM) == DOT_PROD_EXPR \
2500 || (SYM) == VEC_COND_EXPR \
2501 || (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS \
2502 : GIMPLE_INVALID_RHS),
2503 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2505 const unsigned char gimple_rhs_class_table[] = {
2506 #include "all-tree.def"
2510 #undef END_OF_BASE_TREE_CODES
2512 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
2514 /* Validation of GIMPLE expressions. */
2516 /* Return true if OP is an acceptable tree node to be used as a GIMPLE
2520 is_gimple_operand (const_tree op)
2522 return op && get_gimple_rhs_class (TREE_CODE (op)) == GIMPLE_SINGLE_RHS;
2525 /* Returns true iff T is a valid RHS for an assignment to a renamed
2526 user -- or front-end generated artificial -- variable. */
2529 is_gimple_reg_rhs (tree t)
2531 return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
2534 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
2535 LHS, or for a call argument. */
2538 is_gimple_mem_rhs (tree t)
2540 /* If we're dealing with a renamable type, either source or dest must be
2541 a renamed variable. */
2542 if (is_gimple_reg_type (TREE_TYPE (t)))
2543 return is_gimple_val (t);
2545 return is_gimple_val (t) || is_gimple_lvalue (t);
2548 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
2551 is_gimple_lvalue (tree t)
2553 return (is_gimple_addressable (t)
2554 || TREE_CODE (t) == WITH_SIZE_EXPR
2555 /* These are complex lvalues, but don't have addresses, so they
2557 || TREE_CODE (t) == BIT_FIELD_REF);
2560 /* Return true if T is a GIMPLE condition. */
2563 is_gimple_condexpr (tree t)
2565 return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
2566 && !tree_could_trap_p (t)
2567 && is_gimple_val (TREE_OPERAND (t, 0))
2568 && is_gimple_val (TREE_OPERAND (t, 1))));
2571 /* Return true if T is something whose address can be taken. */
2574 is_gimple_addressable (tree t)
2576 return (is_gimple_id (t) || handled_component_p (t) || INDIRECT_REF_P (t));
2579 /* Return true if T is a valid gimple constant. */
2582 is_gimple_constant (const_tree t)
2584 switch (TREE_CODE (t))
2594 /* Vector constant constructors are gimple invariant. */
2596 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2597 return TREE_CONSTANT (t);
2606 /* Return true if T is a gimple address. */
2609 is_gimple_address (const_tree t)
2613 if (TREE_CODE (t) != ADDR_EXPR)
2616 op = TREE_OPERAND (t, 0);
2617 while (handled_component_p (op))
2619 if ((TREE_CODE (op) == ARRAY_REF
2620 || TREE_CODE (op) == ARRAY_RANGE_REF)
2621 && !is_gimple_val (TREE_OPERAND (op, 1)))
2624 op = TREE_OPERAND (op, 0);
2627 if (CONSTANT_CLASS_P (op) || INDIRECT_REF_P (op))
2630 switch (TREE_CODE (op))
2645 /* Strip out all handled components that produce invariant
2649 strip_invariant_refs (const_tree op)
2651 while (handled_component_p (op))
2653 switch (TREE_CODE (op))
2656 case ARRAY_RANGE_REF:
2657 if (!is_gimple_constant (TREE_OPERAND (op, 1))
2658 || TREE_OPERAND (op, 2) != NULL_TREE
2659 || TREE_OPERAND (op, 3) != NULL_TREE)
2664 if (TREE_OPERAND (op, 2) != NULL_TREE)
2670 op = TREE_OPERAND (op, 0);
2676 /* Return true if T is a gimple invariant address. */
2679 is_gimple_invariant_address (const_tree t)
2683 if (TREE_CODE (t) != ADDR_EXPR)
2686 op = strip_invariant_refs (TREE_OPERAND (t, 0));
2688 return op && (CONSTANT_CLASS_P (op) || decl_address_invariant_p (op));
2691 /* Return true if T is a gimple invariant address at IPA level
2692 (so addresses of variables on stack are not allowed). */
2695 is_gimple_ip_invariant_address (const_tree t)
2699 if (TREE_CODE (t) != ADDR_EXPR)
2702 op = strip_invariant_refs (TREE_OPERAND (t, 0));
2704 return op && (CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op));
2707 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
2708 form of function invariant. */
2711 is_gimple_min_invariant (const_tree t)
2713 if (TREE_CODE (t) == ADDR_EXPR)
2714 return is_gimple_invariant_address (t);
2716 return is_gimple_constant (t);
2719 /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
2720 form of gimple minimal invariant. */
2723 is_gimple_ip_invariant (const_tree t)
2725 if (TREE_CODE (t) == ADDR_EXPR)
2726 return is_gimple_ip_invariant_address (t);
2728 return is_gimple_constant (t);
2731 /* Return true if T looks like a valid GIMPLE statement. */
2734 is_gimple_stmt (tree t)
2736 const enum tree_code code = TREE_CODE (t);
2741 /* The only valid NOP_EXPR is the empty statement. */
2742 return IS_EMPTY_STMT (t);
2746 /* These are only valid if they're void. */
2747 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
2753 case CASE_LABEL_EXPR:
2754 case TRY_CATCH_EXPR:
2755 case TRY_FINALLY_EXPR:
2756 case EH_FILTER_EXPR:
2759 case STATEMENT_LIST:
2769 /* These are always void. */
2775 /* These are valid regardless of their type. */
2783 /* Return true if T is a variable. */
2786 is_gimple_variable (tree t)
2788 return (TREE_CODE (t) == VAR_DECL
2789 || TREE_CODE (t) == PARM_DECL
2790 || TREE_CODE (t) == RESULT_DECL
2791 || TREE_CODE (t) == SSA_NAME);
2794 /* Return true if T is a GIMPLE identifier (something with an address). */
2797 is_gimple_id (tree t)
2799 return (is_gimple_variable (t)
2800 || TREE_CODE (t) == FUNCTION_DECL
2801 || TREE_CODE (t) == LABEL_DECL
2802 || TREE_CODE (t) == CONST_DECL
2803 /* Allow string constants, since they are addressable. */
2804 || TREE_CODE (t) == STRING_CST);
2807 /* Return true if TYPE is a suitable type for a scalar register variable. */
2810 is_gimple_reg_type (tree type)
2812 return !AGGREGATE_TYPE_P (type);
2815 /* Return true if T is a non-aggregate register variable. */
2818 is_gimple_reg (tree t)
2820 if (TREE_CODE (t) == SSA_NAME)
2821 t = SSA_NAME_VAR (t);
2823 if (!is_gimple_variable (t))
2826 if (!is_gimple_reg_type (TREE_TYPE (t)))
2829 /* A volatile decl is not acceptable because we can't reuse it as
2830 needed. We need to copy it into a temp first. */
2831 if (TREE_THIS_VOLATILE (t))
2834 /* We define "registers" as things that can be renamed as needed,
2835 which with our infrastructure does not apply to memory. */
2836 if (needs_to_live_in_memory (t))
2839 /* Hard register variables are an interesting case. For those that
2840 are call-clobbered, we don't know where all the calls are, since
2841 we don't (want to) take into account which operations will turn
2842 into libcalls at the rtl level. For those that are call-saved,
2843 we don't currently model the fact that calls may in fact change
2844 global hard registers, nor do we examine ASM_CLOBBERS at the tree
2845 level, and so miss variable changes that might imply. All around,
2846 it seems safest to not do too much optimization with these at the
2847 tree level at all. We'll have to rely on the rtl optimizers to
2848 clean this up, as there we've got all the appropriate bits exposed. */
2849 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2852 /* Complex and vector values must have been put into SSA-like form.
2853 That is, no assignments to the individual components. */
2854 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
2855 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
2856 return DECL_GIMPLE_REG_P (t);
2862 /* Return true if T is a GIMPLE variable whose address is not needed. */
2865 is_gimple_non_addressable (tree t)
2867 if (TREE_CODE (t) == SSA_NAME)
2868 t = SSA_NAME_VAR (t);
2870 return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
2873 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
2876 is_gimple_val (tree t)
2878 /* Make loads from volatiles and memory vars explicit. */
2879 if (is_gimple_variable (t)
2880 && is_gimple_reg_type (TREE_TYPE (t))
2881 && !is_gimple_reg (t))
2884 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
2887 /* Similarly, but accept hard registers as inputs to asm statements. */
2890 is_gimple_asm_val (tree t)
2892 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2895 return is_gimple_val (t);
2898 /* Return true if T is a GIMPLE minimal lvalue. */
2901 is_gimple_min_lval (tree t)
2903 if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
2905 return (is_gimple_id (t) || TREE_CODE (t) == INDIRECT_REF);
2908 /* Return true if T is a typecast operation. */
2911 is_gimple_cast (tree t)
2913 return (CONVERT_EXPR_P (t)
2914 || TREE_CODE (t) == FIX_TRUNC_EXPR);
2917 /* Return true if T is a valid function operand of a CALL_EXPR. */
2920 is_gimple_call_addr (tree t)
2922 return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
2925 /* If T makes a function call, return the corresponding CALL_EXPR operand.
2926 Otherwise, return NULL_TREE. */
2929 get_call_expr_in (tree t)
2931 if (TREE_CODE (t) == MODIFY_EXPR)
2932 t = TREE_OPERAND (t, 1);
2933 if (TREE_CODE (t) == WITH_SIZE_EXPR)
2934 t = TREE_OPERAND (t, 0);
2935 if (TREE_CODE (t) == CALL_EXPR)
2941 /* Given a memory reference expression T, return its base address.
2942 The base address of a memory reference expression is the main
2943 object being referenced. For instance, the base address for
2944 'array[i].fld[j]' is 'array'. You can think of this as stripping
2945 away the offset part from a memory address.
2947 This function calls handled_component_p to strip away all the inner
2948 parts of the memory reference until it reaches the base object. */
2951 get_base_address (tree t)
2953 while (handled_component_p (t))
2954 t = TREE_OPERAND (t, 0);
2957 || TREE_CODE (t) == STRING_CST
2958 || TREE_CODE (t) == CONSTRUCTOR
2959 || INDIRECT_REF_P (t))
2966 recalculate_side_effects (tree t)
2968 enum tree_code code = TREE_CODE (t);
2969 int len = TREE_OPERAND_LENGTH (t);
2972 switch (TREE_CODE_CLASS (code))
2974 case tcc_expression:
2980 case PREDECREMENT_EXPR:
2981 case PREINCREMENT_EXPR:
2982 case POSTDECREMENT_EXPR:
2983 case POSTINCREMENT_EXPR:
2984 /* All of these have side-effects, no matter what their
2993 case tcc_comparison: /* a comparison expression */
2994 case tcc_unary: /* a unary arithmetic expression */
2995 case tcc_binary: /* a binary arithmetic expression */
2996 case tcc_reference: /* a reference */
2997 case tcc_vl_exp: /* a function call */
2998 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
2999 for (i = 0; i < len; ++i)
3001 tree op = TREE_OPERAND (t, i);
3002 if (op && TREE_SIDE_EFFECTS (op))
3003 TREE_SIDE_EFFECTS (t) = 1;
3008 /* No side-effects. */
3016 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
3017 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
3018 we failed to create one. */
3021 canonicalize_cond_expr_cond (tree t)
3023 /* Strip conversions around boolean operations. */
3024 if (CONVERT_EXPR_P (t)
3025 && truth_value_p (TREE_CODE (TREE_OPERAND (t, 0))))
3026 t = TREE_OPERAND (t, 0);
3028 /* For (bool)x use x != 0. */
3029 if (CONVERT_EXPR_P (t)
3030 && TREE_CODE (TREE_TYPE (t)) == BOOLEAN_TYPE)
3032 tree top0 = TREE_OPERAND (t, 0);
3033 t = build2 (NE_EXPR, TREE_TYPE (t),
3034 top0, build_int_cst (TREE_TYPE (top0), 0));
3036 /* For !x use x == 0. */
3037 else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
3039 tree top0 = TREE_OPERAND (t, 0);
3040 t = build2 (EQ_EXPR, TREE_TYPE (t),
3041 top0, build_int_cst (TREE_TYPE (top0), 0));
3043 /* For cmp ? 1 : 0 use cmp. */
3044 else if (TREE_CODE (t) == COND_EXPR
3045 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
3046 && integer_onep (TREE_OPERAND (t, 1))
3047 && integer_zerop (TREE_OPERAND (t, 2)))
3049 tree top0 = TREE_OPERAND (t, 0);
3050 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
3051 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
3054 if (is_gimple_condexpr (t))
3060 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
3061 the positions marked by the set ARGS_TO_SKIP. */
3064 gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
3067 tree fn = gimple_call_fn (stmt);
3068 int nargs = gimple_call_num_args (stmt);
3069 VEC(tree, heap) *vargs = VEC_alloc (tree, heap, nargs);
3072 for (i = 0; i < nargs; i++)
3073 if (!bitmap_bit_p (args_to_skip, i))
3074 VEC_quick_push (tree, vargs, gimple_call_arg (stmt, i));
3076 new_stmt = gimple_build_call_vec (fn, vargs);
3077 VEC_free (tree, heap, vargs);
3078 if (gimple_call_lhs (stmt))
3079 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
3081 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
3082 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
3084 gimple_set_block (new_stmt, gimple_block (stmt));
3085 if (gimple_has_location (stmt))
3086 gimple_set_location (new_stmt, gimple_location (stmt));
3088 /* Carry all the flags to the new GIMPLE_CALL. */
3089 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
3090 gimple_call_set_tail (new_stmt, gimple_call_tail_p (stmt));
3091 gimple_call_set_cannot_inline (new_stmt, gimple_call_cannot_inline_p (stmt));
3092 gimple_call_set_return_slot_opt (new_stmt, gimple_call_return_slot_opt_p (stmt));
3093 gimple_call_set_from_thunk (new_stmt, gimple_call_from_thunk_p (stmt));
3094 gimple_call_set_va_arg_pack (new_stmt, gimple_call_va_arg_pack_p (stmt));
3096 gimple_set_modified (new_stmt, true);
3102 static hashval_t gimple_type_hash (const void *);
3104 /* Structure used to maintain a cache of some type pairs compared by
3105 gimple_types_compatible_p when comparing aggregate types. There are
3106 four possible values for SAME_P:
3108 -2: The pair (T1, T2) has just been inserted in the table.
3109 -1: The pair (T1, T2) is currently being compared.
3110 0: T1 and T2 are different types.
3111 1: T1 and T2 are the same type.
3113 This table is only used when comparing aggregate types to avoid
3114 infinite recursion due to self-referential types. */
3121 typedef struct type_pair_d *type_pair_t;
3123 /* Return a hash value for the type pair pointed-to by P. */
3126 type_pair_hash (const void *p)
3128 const struct type_pair_d *pair = (const struct type_pair_d *) p;
3129 hashval_t val1 = pair->uid1;
3130 hashval_t val2 = pair->uid2;
3131 return (iterative_hash_hashval_t (val2, val1)
3132 ^ iterative_hash_hashval_t (val1, val2));
3135 /* Compare two type pairs pointed-to by P1 and P2. */
3138 type_pair_eq (const void *p1, const void *p2)
3140 const struct type_pair_d *pair1 = (const struct type_pair_d *) p1;
3141 const struct type_pair_d *pair2 = (const struct type_pair_d *) p2;
3142 return ((pair1->uid1 == pair2->uid1 && pair1->uid2 == pair2->uid2)
3143 || (pair1->uid1 == pair2->uid2 && pair1->uid2 == pair2->uid1));
3146 /* Lookup the pair of types T1 and T2 in *VISITED_P. Insert a new
3147 entry if none existed. */
3150 lookup_type_pair (tree t1, tree t2, htab_t *visited_p, struct obstack *ob_p)
3152 struct type_pair_d pair;
3156 if (*visited_p == NULL)
3158 *visited_p = htab_create (251, type_pair_hash, type_pair_eq, NULL);
3159 gcc_obstack_init (ob_p);
3162 pair.uid1 = TYPE_UID (t1);
3163 pair.uid2 = TYPE_UID (t2);
3164 slot = htab_find_slot (*visited_p, &pair, INSERT);
3167 p = *((type_pair_t *) slot);
3170 p = XOBNEW (ob_p, struct type_pair_d);
3171 p->uid1 = TYPE_UID (t1);
3172 p->uid2 = TYPE_UID (t2);
3181 /* Return true if T1 and T2 have the same name. If FOR_COMPLETION_P is
3182 true then if any type has no name return false, otherwise return
3183 true if both types have no names. */
3186 compare_type_names_p (tree t1, tree t2, bool for_completion_p)
3188 tree name1 = TYPE_NAME (t1);
3189 tree name2 = TYPE_NAME (t2);
3191 /* Consider anonymous types all unique for completion. */
3192 if (for_completion_p
3193 && (!name1 || !name2))
3196 if (name1 && TREE_CODE (name1) == TYPE_DECL)
3198 name1 = DECL_NAME (name1);
3199 if (for_completion_p
3203 gcc_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE);
3205 if (name2 && TREE_CODE (name2) == TYPE_DECL)
3207 name2 = DECL_NAME (name2);
3208 if (for_completion_p
3212 gcc_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE);
3214 /* Identifiers can be compared with pointer equality rather
3215 than a string comparison. */
3222 /* Return true if the field decls F1 and F2 are at the same offset.
3224 This is intended to be used on GIMPLE types only. In order to
3225 compare GENERIC types, use fields_compatible_p instead. */
3228 gimple_compare_field_offset (tree f1, tree f2)
3230 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
3232 tree offset1 = DECL_FIELD_OFFSET (f1);
3233 tree offset2 = DECL_FIELD_OFFSET (f2);
3234 return ((offset1 == offset2
3235 /* Once gimplification is done, self-referential offsets are
3236 instantiated as operand #2 of the COMPONENT_REF built for
3237 each access and reset. Therefore, they are not relevant
3238 anymore and fields are interchangeable provided that they
3239 represent the same access. */
3240 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
3241 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
3242 && (DECL_SIZE (f1) == DECL_SIZE (f2)
3243 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
3244 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
3245 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
3246 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
3247 || operand_equal_p (offset1, offset2, 0))
3248 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
3249 DECL_FIELD_BIT_OFFSET (f2)));
3252 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
3253 should be, so handle differing ones specially by decomposing
3254 the offset into a byte and bit offset manually. */
3255 if (host_integerp (DECL_FIELD_OFFSET (f1), 0)
3256 && host_integerp (DECL_FIELD_OFFSET (f2), 0))
3258 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
3259 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
3260 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
3261 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
3262 + bit_offset1 / BITS_PER_UNIT);
3263 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
3264 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
3265 + bit_offset2 / BITS_PER_UNIT);
3266 if (byte_offset1 != byte_offset2)
3268 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
3274 /* Return 1 iff T1 and T2 are structurally identical.
3275 Otherwise, return 0. */
3278 gimple_types_compatible_p (tree t1, tree t2)
3280 type_pair_t p = NULL;
3282 /* Check first for the obvious case of pointer identity. */
3286 /* Check that we have two types to compare. */
3287 if (t1 == NULL_TREE || t2 == NULL_TREE)
3290 /* Can't be the same type if the types don't have the same code. */
3291 if (TREE_CODE (t1) != TREE_CODE (t2))
3294 /* Can't be the same type if they have different CV qualifiers. */
3295 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
3298 /* Void types are always the same. */
3299 if (TREE_CODE (t1) == VOID_TYPE)
3302 /* For numerical types do some simple checks before doing three
3303 hashtable queries. */
3304 if (INTEGRAL_TYPE_P (t1)
3305 || SCALAR_FLOAT_TYPE_P (t1)
3306 || FIXED_POINT_TYPE_P (t1)
3307 || TREE_CODE (t1) == VECTOR_TYPE
3308 || TREE_CODE (t1) == COMPLEX_TYPE
3309 || TREE_CODE (t1) == OFFSET_TYPE)
3311 /* Can't be the same type if they have different alignment,
3312 sign, precision or mode. */
3313 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
3314 || TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
3315 || TYPE_MODE (t1) != TYPE_MODE (t2)
3316 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
3319 if (TREE_CODE (t1) == INTEGER_TYPE
3320 && (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
3321 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
3324 /* That's all we need to check for float and fixed-point types. */
3325 if (SCALAR_FLOAT_TYPE_P (t1)
3326 || FIXED_POINT_TYPE_P (t1))
3329 /* Perform cheap tail-recursion for vector and complex types. */
3330 if (TREE_CODE (t1) == VECTOR_TYPE
3331 || TREE_CODE (t1) == COMPLEX_TYPE)
3332 return gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2));
3334 /* For integral types fall thru to more complex checks. */
3337 /* If the hash values of t1 and t2 are different the types can't
3338 possibly be the same. This helps keeping the type-pair hashtable
3339 small, only tracking comparisons for hash collisions. */
3340 if (gimple_type_hash (t1) != gimple_type_hash (t2))
3343 /* If we've visited this type pair before (in the case of aggregates
3344 with self-referential types), and we made a decision, return it. */
3345 p = lookup_type_pair (t1, t2, >c_visited, >c_ob);
3346 if (p->same_p == 0 || p->same_p == 1)
3348 /* We have already decided whether T1 and T2 are the
3349 same, return the cached result. */
3350 return p->same_p == 1;
3352 else if (p->same_p == -1)
3354 /* We are currently comparing this pair of types, assume
3355 that they are the same and let the caller decide. */
3359 gcc_assert (p->same_p == -2);
3361 /* Mark the (T1, T2) comparison in progress. */
3364 /* If their attributes are not the same they can't be the same type. */
3365 if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
3366 goto different_types;
3368 /* Do type-specific comparisons. */
3369 switch (TREE_CODE (t1))
3372 /* Array types are the same if the element types are the same and
3373 the number of elements are the same. */
3374 if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
3375 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
3376 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
3377 goto different_types;
3380 tree i1 = TYPE_DOMAIN (t1);
3381 tree i2 = TYPE_DOMAIN (t2);
3383 /* For an incomplete external array, the type domain can be
3384 NULL_TREE. Check this condition also. */
3385 if (i1 == NULL_TREE && i2 == NULL_TREE)
3387 else if (i1 == NULL_TREE || i2 == NULL_TREE)
3388 goto different_types;
3389 /* If for a complete array type the possibly gimplified sizes
3390 are different the types are different. */
3391 else if (((TYPE_SIZE (i1) != NULL) ^ (TYPE_SIZE (i2) != NULL))
3394 && !operand_equal_p (TYPE_SIZE (i1), TYPE_SIZE (i2), 0)))
3395 goto different_types;
3398 tree min1 = TYPE_MIN_VALUE (i1);
3399 tree min2 = TYPE_MIN_VALUE (i2);
3400 tree max1 = TYPE_MAX_VALUE (i1);
3401 tree max2 = TYPE_MAX_VALUE (i2);
3403 /* The minimum/maximum values have to be the same. */
3406 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
3407 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
3408 || operand_equal_p (min1, min2, 0))))
3411 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
3412 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
3413 || operand_equal_p (max1, max2, 0)))))
3416 goto different_types;
3421 /* Method types should belong to the same class. */
3422 if (!gimple_types_compatible_p (TYPE_METHOD_BASETYPE (t1),
3423 TYPE_METHOD_BASETYPE (t2)))
3424 goto different_types;
3429 /* Function types are the same if the return type and arguments types
3431 if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3432 goto different_types;
3435 if (!targetm.comp_type_attributes (t1, t2))
3436 goto different_types;
3438 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
3442 tree parms1, parms2;
3444 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
3446 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
3448 if (!gimple_types_compatible_p (TREE_VALUE (parms1),
3449 TREE_VALUE (parms2)))
3450 goto different_types;
3453 if (parms1 || parms2)
3454 goto different_types;
3462 if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
3463 || !gimple_types_compatible_p (TYPE_OFFSET_BASETYPE (t1),
3464 TYPE_OFFSET_BASETYPE (t2)))
3465 goto different_types;
3471 case REFERENCE_TYPE:
3473 /* If the two pointers have different ref-all attributes,
3474 they can't be the same type. */
3475 if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
3476 goto different_types;
3478 /* If one pointer points to an incomplete type variant of
3479 the other pointed-to type they are the same. */
3480 if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2))
3481 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (t1))
3482 && (!COMPLETE_TYPE_P (TREE_TYPE (t1))
3483 || !COMPLETE_TYPE_P (TREE_TYPE (t2)))
3484 && TYPE_QUALS (TREE_TYPE (t1)) == TYPE_QUALS (TREE_TYPE (t2))
3485 && compare_type_names_p (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
3486 TYPE_MAIN_VARIANT (TREE_TYPE (t2)), true))
3488 /* Replace the pointed-to incomplete type with the
3490 ??? This simple name-based merging causes at least some
3491 of the ICEs in canonicalizing FIELD_DECLs during stmt
3492 read. For example in GCC we have two different struct deps
3493 and we mismatch the use in struct cpp_reader in sched-int.h
3494 vs. mkdeps.c. Of course the whole exercise is for TBAA
3495 with structs which contain pointers to incomplete types
3496 in one unit and to complete ones in another. So we
3497 probably should merge these types only with more context. */
3498 if (COMPLETE_TYPE_P (TREE_TYPE (t2)))
3499 TREE_TYPE (t1) = TREE_TYPE (t2);
3501 TREE_TYPE (t2) = TREE_TYPE (t1);
3505 /* Otherwise, pointer and reference types are the same if the
3506 pointed-to types are the same. */
3507 if (gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
3510 goto different_types;
3516 tree min1 = TYPE_MIN_VALUE (t1);
3517 tree max1 = TYPE_MAX_VALUE (t1);
3518 tree min2 = TYPE_MIN_VALUE (t2);
3519 tree max2 = TYPE_MAX_VALUE (t2);
3520 bool min_equal_p = false;
3521 bool max_equal_p = false;
3523 /* If either type has a minimum value, the other type must
3525 if (min1 == NULL_TREE && min2 == NULL_TREE)
3527 else if (min1 && min2 && operand_equal_p (min1, min2, 0))
3530 /* Likewise, if either type has a maximum value, the other
3531 type must have the same. */
3532 if (max1 == NULL_TREE && max2 == NULL_TREE)
3534 else if (max1 && max2 && operand_equal_p (max1, max2, 0))
3537 if (!min_equal_p || !max_equal_p)
3538 goto different_types;
3545 /* FIXME lto, we cannot check bounds on enumeral types because
3546 different front ends will produce different values.
3547 In C, enumeral types are integers, while in C++ each element
3548 will have its own symbolic value. We should decide how enums
3549 are to be represented in GIMPLE and have each front end lower
3553 /* For enumeral types, all the values must be the same. */
3554 if (TYPE_VALUES (t1) == TYPE_VALUES (t2))
3557 for (v1 = TYPE_VALUES (t1), v2 = TYPE_VALUES (t2);
3559 v1 = TREE_CHAIN (v1), v2 = TREE_CHAIN (v2))
3561 tree c1 = TREE_VALUE (v1);
3562 tree c2 = TREE_VALUE (v2);
3564 if (TREE_CODE (c1) == CONST_DECL)
3565 c1 = DECL_INITIAL (c1);
3567 if (TREE_CODE (c2) == CONST_DECL)
3568 c2 = DECL_INITIAL (c2);
3570 if (tree_int_cst_equal (c1, c2) != 1)
3571 goto different_types;
3574 /* If one enumeration has more values than the other, they
3575 are not the same. */
3577 goto different_types;
3584 case QUAL_UNION_TYPE:
3588 /* If one type requires structural equality checks and the
3589 other doesn't, do not merge the types. */
3590 if (TYPE_STRUCTURAL_EQUALITY_P (t1)
3591 != TYPE_STRUCTURAL_EQUALITY_P (t2))
3592 goto different_types;
3594 /* The struct tags shall compare equal. */
3595 if (!compare_type_names_p (TYPE_MAIN_VARIANT (t1),
3596 TYPE_MAIN_VARIANT (t2), false))
3597 goto different_types;
3599 /* For aggregate types, all the fields must be the same. */
3600 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
3602 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
3604 /* The fields must have the same name, offset and type. */
3605 if (DECL_NAME (f1) != DECL_NAME (f2)
3606 || DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
3607 || !gimple_compare_field_offset (f1, f2)
3608 || !gimple_types_compatible_p (TREE_TYPE (f1),
3610 goto different_types;
3613 /* If one aggregate has more fields than the other, they
3614 are not the same. */
3616 goto different_types;
3625 /* Common exit path for types that are not compatible. */
3630 /* Common exit path for types that are compatible. */
3639 /* Per pointer state for the SCC finding. The on_sccstack flag
3640 is not strictly required, it is true when there is no hash value
3641 recorded for the type and false otherwise. But querying that
3646 unsigned int dfsnum;
3652 static unsigned int next_dfs_num;
3655 iterative_hash_gimple_type (tree, hashval_t, VEC(tree, heap) **,
3656 struct pointer_map_t *, struct obstack *);
3658 /* DFS visit the edge from the callers type with state *STATE to T.
3659 Update the callers type hash V with the hash for T if it is not part
3660 of the SCC containing the callers type and return it.
3661 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
3664 visit (tree t, struct sccs *state, hashval_t v,
3665 VEC (tree, heap) **sccstack,
3666 struct pointer_map_t *sccstate,
3667 struct obstack *sccstate_obstack)
3669 struct sccs *cstate = NULL;
3672 /* If there is a hash value recorded for this type then it can't
3673 possibly be part of our parent SCC. Simply mix in its hash. */
3674 if ((slot = pointer_map_contains (type_hash_cache, t)))
3675 return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, v);
3677 if ((slot = pointer_map_contains (sccstate, t)) != NULL)
3678 cstate = (struct sccs *)*slot;
3682 /* Not yet visited. DFS recurse. */
3683 tem = iterative_hash_gimple_type (t, v,
3684 sccstack, sccstate, sccstate_obstack);
3686 cstate = (struct sccs *)* pointer_map_contains (sccstate, t);
3687 state->low = MIN (state->low, cstate->low);
3688 /* If the type is no longer on the SCC stack and thus is not part
3689 of the parents SCC mix in its hash value. Otherwise we will
3690 ignore the type for hashing purposes and return the unaltered
3692 if (!cstate->on_sccstack)
3695 if (cstate->dfsnum < state->dfsnum
3696 && cstate->on_sccstack)
3697 state->low = MIN (cstate->dfsnum, state->low);
3699 /* We are part of our parents SCC, skip this type during hashing
3700 and return the unaltered hash value. */
3704 /* Hash NAME with the previous hash value V and return it. */
3707 iterative_hash_name (tree name, hashval_t v)
3711 if (TREE_CODE (name) == TYPE_DECL)
3712 name = DECL_NAME (name);
3715 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3716 return iterative_hash_object (IDENTIFIER_HASH_VALUE (name), v);
3719 /* Returning a hash value for gimple type TYPE combined with VAL.
3720 SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.
3722 To hash a type we end up hashing in types that are reachable.
3723 Through pointers we can end up with cycles which messes up the
3724 required property that we need to compute the same hash value
3725 for structurally equivalent types. To avoid this we have to
3726 hash all types in a cycle (the SCC) in a commutative way. The
3727 easiest way is to not mix in the hashes of the SCC members at
3728 all. To make this work we have to delay setting the hash
3729 values of the SCC until it is complete. */
3732 iterative_hash_gimple_type (tree type, hashval_t val,
3733 VEC(tree, heap) **sccstack,
3734 struct pointer_map_t *sccstate,
3735 struct obstack *sccstate_obstack)
3741 #ifdef ENABLE_CHECKING
3742 /* Not visited during this DFS walk nor during previous walks. */
3743 gcc_assert (!pointer_map_contains (type_hash_cache, type)
3744 && !pointer_map_contains (sccstate, type));
3746 state = XOBNEW (sccstate_obstack, struct sccs);
3747 *pointer_map_insert (sccstate, type) = state;
3749 VEC_safe_push (tree, heap, *sccstack, type);
3750 state->dfsnum = next_dfs_num++;
3751 state->low = state->dfsnum;
3752 state->on_sccstack = true;
3754 /* Combine a few common features of types so that types are grouped into
3755 smaller sets; when searching for existing matching types to merge,
3756 only existing types having the same features as the new type will be
3758 v = iterative_hash_hashval_t (TREE_CODE (type), 0);
3759 v = iterative_hash_hashval_t (TYPE_QUALS (type), v);
3760 v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
3762 /* Do not hash the types size as this will cause differences in
3763 hash values for the complete vs. the incomplete type variant. */
3765 /* Incorporate common features of numerical types. */
3766 if (INTEGRAL_TYPE_P (type)
3767 || SCALAR_FLOAT_TYPE_P (type)
3768 || FIXED_POINT_TYPE_P (type))
3770 v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
3771 v = iterative_hash_hashval_t (TYPE_MODE (type), v);
3772 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
3775 /* For pointer and reference types, fold in information about the type
3776 pointed to but do not recurse into possibly incomplete types to
3777 avoid hash differences for complete vs. incomplete types. */
3778 if (POINTER_TYPE_P (type))
3780 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
3782 v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
3783 v = iterative_hash_name
3784 (TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
3787 v = visit (TREE_TYPE (type), state, v,
3788 sccstack, sccstate, sccstate_obstack);
3791 /* For integer types hash the types min/max values and the string flag. */
3792 if (TREE_CODE (type) == INTEGER_TYPE)
3794 /* OMP lowering can introduce error_mark_node in place of
3795 random local decls in types. */
3796 if (TYPE_MIN_VALUE (type) != error_mark_node)
3797 v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
3798 if (TYPE_MAX_VALUE (type) != error_mark_node)
3799 v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
3800 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
3803 /* For array types hash their domain and the string flag. */
3804 if (TREE_CODE (type) == ARRAY_TYPE
3805 && TYPE_DOMAIN (type))
3807 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
3808 v = visit (TYPE_DOMAIN (type), state, v,
3809 sccstack, sccstate, sccstate_obstack);
3812 /* Recurse for aggregates with a single element type. */
3813 if (TREE_CODE (type) == ARRAY_TYPE
3814 || TREE_CODE (type) == COMPLEX_TYPE
3815 || TREE_CODE (type) == VECTOR_TYPE)
3816 v = visit (TREE_TYPE (type), state, v,
3817 sccstack, sccstate, sccstate_obstack);
3819 /* Incorporate function return and argument types. */
3820 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
3825 /* For method types also incorporate their parent class. */
3826 if (TREE_CODE (type) == METHOD_TYPE)
3827 v = visit (TYPE_METHOD_BASETYPE (type), state, v,
3828 sccstack, sccstate, sccstate_obstack);
3830 v = visit (TREE_TYPE (type), state, v,
3831 sccstack, sccstate, sccstate_obstack);
3833 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
3835 v = visit (TREE_VALUE (p), state, v,
3836 sccstack, sccstate, sccstate_obstack);
3840 v = iterative_hash_hashval_t (na, v);
3843 if (TREE_CODE (type) == RECORD_TYPE
3844 || TREE_CODE (type) == UNION_TYPE
3845 || TREE_CODE (type) == QUAL_UNION_TYPE)
3850 v = iterative_hash_name (TYPE_NAME (TYPE_MAIN_VARIANT (type)), v);
3852 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
3854 v = iterative_hash_name (DECL_NAME (f), v);
3855 v = visit (TREE_TYPE (f), state, v,
3856 sccstack, sccstate, sccstate_obstack);
3860 v = iterative_hash_hashval_t (nf, v);
3863 /* Record hash for us. */
3866 /* See if we found an SCC. */
3867 if (state->low == state->dfsnum)
3871 /* Pop off the SCC and set its hash values. */
3874 struct sccs *cstate;
3875 x = VEC_pop (tree, *sccstack);
3876 gcc_assert (!pointer_map_contains (type_hash_cache, x));
3877 cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
3878 cstate->on_sccstack = false;
3879 slot = pointer_map_insert (type_hash_cache, x);
3880 *slot = (void *) (size_t) cstate->hash;
3885 return iterative_hash_hashval_t (v, val);
3889 /* Returns a hash value for P (assumed to be a type). The hash value
3890 is computed using some distinguishing features of the type. Note
3891 that we cannot use pointer hashing here as we may be dealing with
3892 two distinct instances of the same type.
3894 This function should produce the same hash value for two compatible
3895 types according to gimple_types_compatible_p. */
3898 gimple_type_hash (const void *p)
3900 const_tree t = (const_tree) p;
3901 VEC(tree, heap) *sccstack = NULL;
3902 struct pointer_map_t *sccstate;
3903 struct obstack sccstate_obstack;
3907 if (type_hash_cache == NULL)
3908 type_hash_cache = pointer_map_create ();
3910 if ((slot = pointer_map_contains (type_hash_cache, p)) != NULL)
3911 return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, 0);
3913 /* Perform a DFS walk and pre-hash all reachable types. */
3915 sccstate = pointer_map_create ();
3916 gcc_obstack_init (&sccstate_obstack);
3917 val = iterative_hash_gimple_type (CONST_CAST_TREE (t), 0,
3918 &sccstack, sccstate, &sccstate_obstack);
3919 VEC_free (tree, heap, sccstack);
3920 pointer_map_destroy (sccstate);
3921 obstack_free (&sccstate_obstack, NULL);
3927 /* Returns nonzero if P1 and P2 are equal. */
3930 gimple_type_eq (const void *p1, const void *p2)
3932 const_tree t1 = (const_tree) p1;
3933 const_tree t2 = (const_tree) p2;
3934 return gimple_types_compatible_p (CONST_CAST_TREE (t1), CONST_CAST_TREE (t2));
3938 /* Register type T in the global type table gimple_types.
3939 If another type T', compatible with T, already existed in
3940 gimple_types then return T', otherwise return T. This is used by
3941 LTO to merge identical types read from different TUs. */
3944 gimple_register_type (tree t)
3948 gcc_assert (TYPE_P (t));
3950 /* Always register the main variant first. This is important so we
3951 pick up the non-typedef variants as canonical, otherwise we'll end
3952 up taking typedef ids for structure tags during comparison. */
3953 if (TYPE_MAIN_VARIANT (t) != t)
3954 gimple_register_type (TYPE_MAIN_VARIANT (t));
3956 if (gimple_types == NULL)
3957 gimple_types = htab_create (16381, gimple_type_hash, gimple_type_eq, 0);
3959 slot = htab_find_slot (gimple_types, t, INSERT);
3961 && *(tree *)slot != t)
3963 tree new_type = (tree) *((tree *) slot);
3965 /* Do not merge types with different addressability. */
3966 gcc_assert (TREE_ADDRESSABLE (t) == TREE_ADDRESSABLE (new_type));
3968 /* If t is not its main variant then make t unreachable from its
3969 main variant list. Otherwise we'd queue up a lot of duplicates
3971 if (t != TYPE_MAIN_VARIANT (t))
3973 tree tem = TYPE_MAIN_VARIANT (t);
3974 while (tem && TYPE_NEXT_VARIANT (tem) != t)
3975 tem = TYPE_NEXT_VARIANT (tem);
3977 TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
3978 TYPE_NEXT_VARIANT (t) = NULL_TREE;
3981 /* If we are a pointer then remove us from the pointer-to or
3982 reference-to chain. Otherwise we'd queue up a lot of duplicates
3984 if (TREE_CODE (t) == POINTER_TYPE)
3986 if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
3987 TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
3990 tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
3991 while (tem && TYPE_NEXT_PTR_TO (tem) != t)
3992 tem = TYPE_NEXT_PTR_TO (tem);
3994 TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
3996 TYPE_NEXT_PTR_TO (t) = NULL_TREE;
3998 else if (TREE_CODE (t) == REFERENCE_TYPE)
4000 if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
4001 TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
4004 tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
4005 while (tem && TYPE_NEXT_REF_TO (tem) != t)
4006 tem = TYPE_NEXT_REF_TO (tem);
4008 TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
4010 TYPE_NEXT_REF_TO (t) = NULL_TREE;
4022 /* Show statistics on references to the global type table gimple_types. */
4025 print_gimple_types_stats (void)
4028 fprintf (stderr, "GIMPLE type table: size %ld, %ld elements, "
4029 "%ld searches, %ld collisions (ratio: %f)\n",
4030 (long) htab_size (gimple_types),
4031 (long) htab_elements (gimple_types),
4032 (long) gimple_types->searches,
4033 (long) gimple_types->collisions,
4034 htab_collisions (gimple_types));
4036 fprintf (stderr, "GIMPLE type table is empty\n");
4038 fprintf (stderr, "GIMPLE type comparison table: size %ld, %ld "
4039 "elements, %ld searches, %ld collisions (ratio: %f)\n",
4040 (long) htab_size (gtc_visited),
4041 (long) htab_elements (gtc_visited),
4042 (long) gtc_visited->searches,
4043 (long) gtc_visited->collisions,
4044 htab_collisions (gtc_visited));
4046 fprintf (stderr, "GIMPLE type comparison table is empty\n");
4049 /* Free the gimple type hashtables used for LTO type merging. */
4052 free_gimple_type_tables (void)
4054 /* Last chance to print stats for the tables. */
4055 if (flag_lto_report)
4056 print_gimple_types_stats ();
4060 htab_delete (gimple_types);
4061 gimple_types = NULL;
4063 if (type_hash_cache)
4065 pointer_map_destroy (type_hash_cache);
4066 type_hash_cache = NULL;
4070 htab_delete (gtc_visited);
4071 obstack_free (>c_ob, NULL);
4077 /* Return a type the same as TYPE except unsigned or
4078 signed according to UNSIGNEDP. */
4081 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
4085 type1 = TYPE_MAIN_VARIANT (type);
4086 if (type1 == signed_char_type_node
4087 || type1 == char_type_node
4088 || type1 == unsigned_char_type_node)
4089 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4090 if (type1 == integer_type_node || type1 == unsigned_type_node)
4091 return unsignedp ? unsigned_type_node : integer_type_node;
4092 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
4093 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4094 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
4095 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4096 if (type1 == long_long_integer_type_node
4097 || type1 == long_long_unsigned_type_node)
4099 ? long_long_unsigned_type_node
4100 : long_long_integer_type_node;
4101 #if HOST_BITS_PER_WIDE_INT >= 64
4102 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
4103 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
4105 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
4106 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
4107 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
4108 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
4109 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
4110 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
4111 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
4112 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
4114 #define GIMPLE_FIXED_TYPES(NAME) \
4115 if (type1 == short_ ## NAME ## _type_node \
4116 || type1 == unsigned_short_ ## NAME ## _type_node) \
4117 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
4118 : short_ ## NAME ## _type_node; \
4119 if (type1 == NAME ## _type_node \
4120 || type1 == unsigned_ ## NAME ## _type_node) \
4121 return unsignedp ? unsigned_ ## NAME ## _type_node \
4122 : NAME ## _type_node; \
4123 if (type1 == long_ ## NAME ## _type_node \
4124 || type1 == unsigned_long_ ## NAME ## _type_node) \
4125 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
4126 : long_ ## NAME ## _type_node; \
4127 if (type1 == long_long_ ## NAME ## _type_node \
4128 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
4129 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
4130 : long_long_ ## NAME ## _type_node;
4132 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
4133 if (type1 == NAME ## _type_node \
4134 || type1 == u ## NAME ## _type_node) \
4135 return unsignedp ? u ## NAME ## _type_node \
4136 : NAME ## _type_node;
4138 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
4139 if (type1 == sat_ ## short_ ## NAME ## _type_node \
4140 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
4141 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
4142 : sat_ ## short_ ## NAME ## _type_node; \
4143 if (type1 == sat_ ## NAME ## _type_node \
4144 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
4145 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
4146 : sat_ ## NAME ## _type_node; \
4147 if (type1 == sat_ ## long_ ## NAME ## _type_node \
4148 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
4149 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
4150 : sat_ ## long_ ## NAME ## _type_node; \
4151 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
4152 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
4153 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
4154 : sat_ ## long_long_ ## NAME ## _type_node;
4156 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
4157 if (type1 == sat_ ## NAME ## _type_node \
4158 || type1 == sat_ ## u ## NAME ## _type_node) \
4159 return unsignedp ? sat_ ## u ## NAME ## _type_node \
4160 : sat_ ## NAME ## _type_node;
4162 GIMPLE_FIXED_TYPES (fract);
4163 GIMPLE_FIXED_TYPES_SAT (fract);
4164 GIMPLE_FIXED_TYPES (accum);
4165 GIMPLE_FIXED_TYPES_SAT (accum);
4167 GIMPLE_FIXED_MODE_TYPES (qq);
4168 GIMPLE_FIXED_MODE_TYPES (hq);
4169 GIMPLE_FIXED_MODE_TYPES (sq);
4170 GIMPLE_FIXED_MODE_TYPES (dq);
4171 GIMPLE_FIXED_MODE_TYPES (tq);
4172 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
4173 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
4174 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
4175 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
4176 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
4177 GIMPLE_FIXED_MODE_TYPES (ha);
4178 GIMPLE_FIXED_MODE_TYPES (sa);
4179 GIMPLE_FIXED_MODE_TYPES (da);
4180 GIMPLE_FIXED_MODE_TYPES (ta);
4181 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
4182 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
4183 GIMPLE_FIXED_MODE_TYPES_SAT (da);
4184 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
4186 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
4187 the precision; they have precision set to match their range, but
4188 may use a wider mode to match an ABI. If we change modes, we may
4189 wind up with bad conversions. For INTEGER_TYPEs in C, must check
4190 the precision as well, so as to yield correct results for
4191 bit-field types. C++ does not have these separate bit-field
4192 types, and producing a signed or unsigned variant of an
4193 ENUMERAL_TYPE may cause other problems as well. */
4194 if (!INTEGRAL_TYPE_P (type)
4195 || TYPE_UNSIGNED (type) == unsignedp)
4198 #define TYPE_OK(node) \
4199 (TYPE_MODE (type) == TYPE_MODE (node) \
4200 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
4201 if (TYPE_OK (signed_char_type_node))
4202 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4203 if (TYPE_OK (integer_type_node))
4204 return unsignedp ? unsigned_type_node : integer_type_node;
4205 if (TYPE_OK (short_integer_type_node))
4206 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4207 if (TYPE_OK (long_integer_type_node))
4208 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4209 if (TYPE_OK (long_long_integer_type_node))
4211 ? long_long_unsigned_type_node
4212 : long_long_integer_type_node);
4214 #if HOST_BITS_PER_WIDE_INT >= 64
4215 if (TYPE_OK (intTI_type_node))
4216 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
4218 if (TYPE_OK (intDI_type_node))
4219 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
4220 if (TYPE_OK (intSI_type_node))
4221 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
4222 if (TYPE_OK (intHI_type_node))
4223 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
4224 if (TYPE_OK (intQI_type_node))
4225 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
4227 #undef GIMPLE_FIXED_TYPES
4228 #undef GIMPLE_FIXED_MODE_TYPES
4229 #undef GIMPLE_FIXED_TYPES_SAT
4230 #undef GIMPLE_FIXED_MODE_TYPES_SAT
4233 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
4237 /* Return an unsigned type the same as TYPE in other respects. */
4240 gimple_unsigned_type (tree type)
4242 return gimple_signed_or_unsigned_type (true, type);
4246 /* Return a signed type the same as TYPE in other respects. */
4249 gimple_signed_type (tree type)
4251 return gimple_signed_or_unsigned_type (false, type);
4255 /* Return the typed-based alias set for T, which may be an expression
4256 or a type. Return -1 if we don't do anything special. */
4259 gimple_get_alias_set (tree t)
4263 /* Permit type-punning when accessing a union, provided the access
4264 is directly through the union. For example, this code does not
4265 permit taking the address of a union member and then storing
4266 through it. Even the type-punning allowed here is a GCC
4267 extension, albeit a common and useful one; the C standard says
4268 that such accesses have implementation-defined behavior. */
4270 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4271 u = TREE_OPERAND (u, 0))
4272 if (TREE_CODE (u) == COMPONENT_REF
4273 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4276 /* That's all the expressions we handle specially. */
4280 /* For convenience, follow the C standard when dealing with
4281 character types. Any object may be accessed via an lvalue that
4282 has character type. */
4283 if (t == char_type_node
4284 || t == signed_char_type_node
4285 || t == unsigned_char_type_node)
4288 /* Allow aliasing between signed and unsigned variants of the same
4289 type. We treat the signed variant as canonical. */
4290 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4292 tree t1 = gimple_signed_type (t);
4294 /* t1 == t can happen for boolean nodes which are always unsigned. */
4296 return get_alias_set (t1);
4298 else if (POINTER_TYPE_P (t))
4300 /* From the common C and C++ langhook implementation:
4302 Unfortunately, there is no canonical form of a pointer type.
4303 In particular, if we have `typedef int I', then `int *', and
4304 `I *' are different types. So, we have to pick a canonical
4305 representative. We do this below.
4307 Technically, this approach is actually more conservative that
4308 it needs to be. In particular, `const int *' and `int *'
4309 should be in different alias sets, according to the C and C++
4310 standard, since their types are not the same, and so,
4311 technically, an `int **' and `const int **' cannot point at
4314 But, the standard is wrong. In particular, this code is
4319 const int* const* cipp = ipp;
4320 And, it doesn't make sense for that to be legal unless you
4321 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4322 the pointed-to types. This issue has been reported to the
4325 /* In addition to the above canonicalization issue with LTO
4326 we should also canonicalize `T (*)[]' to `T *' avoiding
4327 alias issues with pointer-to element types and pointer-to
4330 Likewise we need to deal with the situation of incomplete
4331 pointed-to types and make `*(struct X **)&a' and
4332 `*(struct X {} **)&a' alias. Otherwise we will have to
4333 guarantee that all pointer-to incomplete type variants
4334 will be replaced by pointer-to complete type variants if
4337 With LTO the convenient situation of using `void *' to
4338 access and store any pointer type will also become
4339 more apparent (and `void *' is just another pointer-to
4340 incomplete type). Assigning alias-set zero to `void *'
4341 and all pointer-to incomplete types is a not appealing
4342 solution. Assigning an effective alias-set zero only
4343 affecting pointers might be - by recording proper subset
4344 relationships of all pointer alias-sets.
4346 Pointer-to function types are another grey area which
4347 needs caution. Globbing them all into one alias-set
4348 or the above effective zero set would work. */
4350 /* For now just assign the same alias-set to all pointers.
4351 That's simple and avoids all the above problems. */
4352 if (t != ptr_type_node)
4353 return get_alias_set (ptr_type_node);
4360 /* Data structure used to count the number of dereferences to PTR
4361 inside an expression. */
4365 unsigned num_stores;
4369 /* Helper for count_uses_and_derefs. Called by walk_tree to look for
4370 (ALIGN/MISALIGNED_)INDIRECT_REF nodes for the pointer passed in DATA. */
4373 count_ptr_derefs (tree *tp, int *walk_subtrees, void *data)
4375 struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
4376 struct count_ptr_d *count_p = (struct count_ptr_d *) wi_p->info;
4378 /* Do not walk inside ADDR_EXPR nodes. In the expression &ptr->fld,
4379 pointer 'ptr' is *not* dereferenced, it is simply used to compute
4380 the address of 'fld' as 'ptr + offsetof(fld)'. */
4381 if (TREE_CODE (*tp) == ADDR_EXPR)
4387 if (INDIRECT_REF_P (*tp) && TREE_OPERAND (*tp, 0) == count_p->ptr)
4390 count_p->num_stores++;
4392 count_p->num_loads++;
4398 /* Count the number of direct and indirect uses for pointer PTR in
4399 statement STMT. The number of direct uses is stored in
4400 *NUM_USES_P. Indirect references are counted separately depending
4401 on whether they are store or load operations. The counts are
4402 stored in *NUM_STORES_P and *NUM_LOADS_P. */
4405 count_uses_and_derefs (tree ptr, gimple stmt, unsigned *num_uses_p,
4406 unsigned *num_loads_p, unsigned *num_stores_p)
4415 /* Find out the total number of uses of PTR in STMT. */
4416 FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
4420 /* Now count the number of indirect references to PTR. This is
4421 truly awful, but we don't have much choice. There are no parent
4422 pointers inside INDIRECT_REFs, so an expression like
4423 '*x_1 = foo (x_1, *x_1)' needs to be traversed piece by piece to
4424 find all the indirect and direct uses of x_1 inside. The only
4425 shortcut we can take is the fact that GIMPLE only allows
4426 INDIRECT_REFs inside the expressions below. */
4427 if (is_gimple_assign (stmt)
4428 || gimple_code (stmt) == GIMPLE_RETURN
4429 || gimple_code (stmt) == GIMPLE_ASM
4430 || is_gimple_call (stmt))
4432 struct walk_stmt_info wi;
4433 struct count_ptr_d count;
4436 count.num_stores = 0;
4437 count.num_loads = 0;
4439 memset (&wi, 0, sizeof (wi));
4441 walk_gimple_op (stmt, count_ptr_derefs, &wi);
4443 *num_stores_p = count.num_stores;
4444 *num_loads_p = count.num_loads;
4447 gcc_assert (*num_uses_p >= *num_loads_p + *num_stores_p);
4450 /* From a tree operand OP return the base of a load or store operation
4451 or NULL_TREE if OP is not a load or a store. */
4454 get_base_loadstore (tree op)
4456 while (handled_component_p (op))
4457 op = TREE_OPERAND (op, 0);
4459 || INDIRECT_REF_P (op)
4460 || TREE_CODE (op) == TARGET_MEM_REF)
4465 /* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
4466 VISIT_ADDR if non-NULL on loads, store and address-taken operands
4467 passing the STMT, the base of the operand and DATA to it. The base
4468 will be either a decl, an indirect reference (including TARGET_MEM_REF)
4469 or the argument of an address expression.
4470 Returns the results of these callbacks or'ed. */
4473 walk_stmt_load_store_addr_ops (gimple stmt, void *data,
4474 bool (*visit_load)(gimple, tree, void *),
4475 bool (*visit_store)(gimple, tree, void *),
4476 bool (*visit_addr)(gimple, tree, void *))
4480 if (gimple_assign_single_p (stmt))
4485 lhs = get_base_loadstore (gimple_assign_lhs (stmt));
4487 ret |= visit_store (stmt, lhs, data);
4489 rhs = gimple_assign_rhs1 (stmt);
4490 while (handled_component_p (rhs))
4491 rhs = TREE_OPERAND (rhs, 0);
4494 if (TREE_CODE (rhs) == ADDR_EXPR)
4495 ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
4496 else if (TREE_CODE (rhs) == TARGET_MEM_REF
4497 && TMR_BASE (rhs) != NULL_TREE
4498 && TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
4499 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
4500 else if (TREE_CODE (rhs) == OBJ_TYPE_REF
4501 && TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
4502 ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
4504 lhs = gimple_assign_lhs (stmt);
4505 if (TREE_CODE (lhs) == TARGET_MEM_REF
4506 && TMR_BASE (lhs) != NULL_TREE
4507 && TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
4508 ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), data);
4512 rhs = get_base_loadstore (rhs);
4514 ret |= visit_load (stmt, rhs, data);
4518 && (is_gimple_assign (stmt)
4519 || gimple_code (stmt) == GIMPLE_COND))
4521 for (i = 0; i < gimple_num_ops (stmt); ++i)
4522 if (gimple_op (stmt, i)
4523 && TREE_CODE (gimple_op (stmt, i)) == ADDR_EXPR)
4524 ret |= visit_addr (stmt, TREE_OPERAND (gimple_op (stmt, i), 0), data);
4526 else if (is_gimple_call (stmt))
4530 tree lhs = gimple_call_lhs (stmt);
4533 lhs = get_base_loadstore (lhs);
4535 ret |= visit_store (stmt, lhs, data);
4538 if (visit_load || visit_addr)
4539 for (i = 0; i < gimple_call_num_args (stmt); ++i)
4541 tree rhs = gimple_call_arg (stmt, i);
4543 && TREE_CODE (rhs) == ADDR_EXPR)
4544 ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
4545 else if (visit_load)
4547 rhs = get_base_loadstore (rhs);
4549 ret |= visit_load (stmt, rhs, data);
4553 && gimple_call_chain (stmt)
4554 && TREE_CODE (gimple_call_chain (stmt)) == ADDR_EXPR)
4555 ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (stmt), 0),
4558 && gimple_call_return_slot_opt_p (stmt)
4559 && gimple_call_lhs (stmt) != NULL_TREE
4560 && TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
4561 ret |= visit_addr (stmt, gimple_call_lhs (stmt), data);
4563 else if (gimple_code (stmt) == GIMPLE_ASM)
4566 const char *constraint;
4567 const char **oconstraints;
4568 bool allows_mem, allows_reg, is_inout;
4569 noutputs = gimple_asm_noutputs (stmt);
4570 oconstraints = XALLOCAVEC (const char *, noutputs);
4571 if (visit_store || visit_addr)
4572 for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
4574 tree link = gimple_asm_output_op (stmt, i);
4575 tree op = get_base_loadstore (TREE_VALUE (link));
4576 if (op && visit_store)
4577 ret |= visit_store (stmt, op, data);
4580 constraint = TREE_STRING_POINTER
4581 (TREE_VALUE (TREE_PURPOSE (link)));
4582 oconstraints[i] = constraint;
4583 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
4584 &allows_reg, &is_inout);
4585 if (op && !allows_reg && allows_mem)
4586 ret |= visit_addr (stmt, op, data);
4589 if (visit_load || visit_addr)
4590 for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
4592 tree link = gimple_asm_input_op (stmt, i);
4593 tree op = TREE_VALUE (link);
4595 && TREE_CODE (op) == ADDR_EXPR)
4596 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
4597 else if (visit_load || visit_addr)
4599 op = get_base_loadstore (op);
4603 ret |= visit_load (stmt, op, data);
4606 constraint = TREE_STRING_POINTER
4607 (TREE_VALUE (TREE_PURPOSE (link)));
4608 parse_input_constraint (&constraint, 0, 0, noutputs,
4610 &allows_mem, &allows_reg);
4611 if (!allows_reg && allows_mem)
4612 ret |= visit_addr (stmt, op, data);
4618 else if (gimple_code (stmt) == GIMPLE_RETURN)
4620 tree op = gimple_return_retval (stmt);
4624 && TREE_CODE (op) == ADDR_EXPR)
4625 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
4626 else if (visit_load)
4628 op = get_base_loadstore (op);
4630 ret |= visit_load (stmt, op, data);
4635 && gimple_code (stmt) == GIMPLE_PHI)
4637 for (i = 0; i < gimple_phi_num_args (stmt); ++i)
4639 tree op = PHI_ARG_DEF (stmt, i);
4640 if (TREE_CODE (op) == ADDR_EXPR)
4641 ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
4648 /* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
4649 should make a faster clone for this case. */
4652 walk_stmt_load_store_ops (gimple stmt, void *data,
4653 bool (*visit_load)(gimple, tree, void *),
4654 bool (*visit_store)(gimple, tree, void *))
4656 return walk_stmt_load_store_addr_ops (stmt, data,
4657 visit_load, visit_store, NULL);
4660 /* Helper for gimple_ior_addresses_taken_1. */
4663 gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
4664 tree addr, void *data)
4666 bitmap addresses_taken = (bitmap)data;
4667 addr = get_base_address (addr);
4671 bitmap_set_bit (addresses_taken, DECL_UID (addr));
4677 /* Set the bit for the uid of all decls that have their address taken
4678 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
4679 were any in this stmt. */
4682 gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
4684 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
4685 gimple_ior_addresses_taken_1);
4689 /* Return a printable name for symbol DECL. */
4692 gimple_decl_printable_name (tree decl, int verbosity)
4694 if (!DECL_NAME (decl))
4697 if (DECL_ASSEMBLER_NAME_SET_P (decl))
4699 const char *str, *mangled_str;
4700 int dmgl_opts = DMGL_NO_OPTS;
4704 dmgl_opts = DMGL_VERBOSE
4708 if (TREE_CODE (decl) == FUNCTION_DECL)
4709 dmgl_opts |= DMGL_PARAMS;
4712 mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4713 str = cplus_demangle_v3 (mangled_str, dmgl_opts);
4714 return (str) ? str : mangled_str;
4717 return IDENTIFIER_POINTER (DECL_NAME (decl));
4720 #include "gt-gimple.h"