hppa: Fix LO_SUM DLTIND14R address support in PRINT_OPERAND_ADDRESS
[official-gcc.git] / gcc / gimple.cc
bloba9f968cb0389029c30c7d566fd347ad34a9b465c
1 /* Gimple IR support functions.
3 Copyright (C) 2007-2024 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
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
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/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "ssa.h"
29 #include "cgraph.h"
30 #include "diagnostic.h"
31 #include "alias.h"
32 #include "fold-const.h"
33 #include "calls.h"
34 #include "stor-layout.h"
35 #include "internal-fn.h"
36 #include "tree-eh.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
39 #include "gimplify.h"
40 #include "target.h"
41 #include "builtins.h"
42 #include "selftest.h"
43 #include "gimple-pretty-print.h"
44 #include "stringpool.h"
45 #include "attribs.h"
46 #include "asan.h"
47 #include "ubsan.h"
48 #include "langhooks.h"
49 #include "attr-fnspec.h"
50 #include "ipa-modref-tree.h"
51 #include "ipa-modref.h"
52 #include "dbgcnt.h"
54 /* All the tuples have their operand vector (if present) at the very bottom
55 of the structure. Therefore, the offset required to find the
56 operands vector the size of the structure minus the size of the 1
57 element tree array at the end (see gimple_ops). */
58 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
59 (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
60 EXPORTED_CONST size_t gimple_ops_offset_[] = {
61 #include "gsstruct.def"
63 #undef DEFGSSTRUCT
65 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
66 static const size_t gsstruct_code_size[] = {
67 #include "gsstruct.def"
69 #undef DEFGSSTRUCT
71 #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
72 const char *const gimple_code_name[] = {
73 #include "gimple.def"
75 #undef DEFGSCODE
77 #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
78 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
79 #include "gimple.def"
81 #undef DEFGSCODE
83 /* Gimple stats. */
85 uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
86 uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
88 /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
89 static const char * const gimple_alloc_kind_names[] = {
90 "assignments",
91 "phi nodes",
92 "conditionals",
93 "everything else"
96 /* Static gimple tuple members. */
97 const enum gimple_code gassign::code_;
98 const enum gimple_code gcall::code_;
99 const enum gimple_code gcond::code_;
102 /* Gimple tuple constructors.
103 Note: Any constructor taking a ``gimple_seq'' as a parameter, can
104 be passed a NULL to start with an empty sequence. */
106 /* Set the code for statement G to CODE. */
108 static inline void
109 gimple_set_code (gimple *g, enum gimple_code code)
111 g->code = code;
114 /* Return the number of bytes needed to hold a GIMPLE statement with
115 code CODE. */
117 size_t
118 gimple_size (enum gimple_code code, unsigned num_ops)
120 size_t size = gsstruct_code_size[gss_for_code (code)];
121 if (num_ops > 0)
122 size += (sizeof (tree) * (num_ops - 1));
123 return size;
126 /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
128 void
129 gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
131 gimple_set_code (g, code);
132 gimple_set_num_ops (g, num_ops);
134 /* Do not call gimple_set_modified here as it has other side
135 effects and this tuple is still not completely built. */
136 g->modified = 1;
137 gimple_init_singleton (g);
140 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
141 operands. */
143 gimple *
144 gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
146 size_t size;
147 gimple *stmt;
149 size = gimple_size (code, num_ops);
150 if (GATHER_STATISTICS)
152 enum gimple_alloc_kind kind = gimple_alloc_kind (code);
153 gimple_alloc_counts[(int) kind]++;
154 gimple_alloc_sizes[(int) kind] += size;
157 stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
158 gimple_init (stmt, code, num_ops);
159 return stmt;
162 /* Set SUBCODE to be the code of the expression computed by statement G. */
164 static inline void
165 gimple_set_subcode (gimple *g, unsigned subcode)
167 /* We only have 16 bits for the RHS code. Assert that we are not
168 overflowing it. */
169 gcc_assert (subcode < (1 << 16));
170 g->subcode = subcode;
175 /* Build a tuple with operands. CODE is the statement to build (which
176 must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
177 for the new tuple. NUM_OPS is the number of operands to allocate. */
179 #define gimple_build_with_ops(c, s, n) \
180 gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
182 static gimple *
183 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
184 unsigned num_ops MEM_STAT_DECL)
186 gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
187 gimple_set_subcode (s, subcode);
189 return s;
193 /* Build a GIMPLE_RETURN statement returning RETVAL. */
195 greturn *
196 gimple_build_return (tree retval)
198 greturn *s
199 = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
200 2));
201 if (retval)
202 gimple_return_set_retval (s, retval);
203 return s;
206 /* Reset alias information on call S. */
208 void
209 gimple_call_reset_alias_info (gcall *s)
211 if (gimple_call_flags (s) & ECF_CONST)
212 memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
213 else
214 pt_solution_reset (gimple_call_use_set (s));
215 if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
216 memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
217 else
218 pt_solution_reset (gimple_call_clobber_set (s));
221 /* Helper for gimple_build_call, gimple_build_call_valist,
222 gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
223 components of a GIMPLE_CALL statement to function FN with NARGS
224 arguments. */
226 static inline gcall *
227 gimple_build_call_1 (tree fn, unsigned nargs)
229 gcall *s
230 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
231 nargs + 3));
232 if (TREE_CODE (fn) == FUNCTION_DECL)
233 fn = build_fold_addr_expr (fn);
234 gimple_set_op (s, 1, fn);
235 gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
236 gimple_call_reset_alias_info (s);
237 return s;
241 /* Build a GIMPLE_CALL statement to function FN with the arguments
242 specified in vector ARGS. */
244 gcall *
245 gimple_build_call_vec (tree fn, const vec<tree> &args)
247 unsigned i;
248 unsigned nargs = args.length ();
249 gcall *call = gimple_build_call_1 (fn, nargs);
251 for (i = 0; i < nargs; i++)
252 gimple_call_set_arg (call, i, args[i]);
254 return call;
258 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
259 arguments. The ... are the arguments. */
261 gcall *
262 gimple_build_call (tree fn, unsigned nargs, ...)
264 va_list ap;
265 gcall *call;
266 unsigned i;
268 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
270 call = gimple_build_call_1 (fn, nargs);
272 va_start (ap, nargs);
273 for (i = 0; i < nargs; i++)
274 gimple_call_set_arg (call, i, va_arg (ap, tree));
275 va_end (ap);
277 return call;
281 /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
282 arguments. AP contains the arguments. */
284 gcall *
285 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
287 gcall *call;
288 unsigned i;
290 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
292 call = gimple_build_call_1 (fn, nargs);
294 for (i = 0; i < nargs; i++)
295 gimple_call_set_arg (call, i, va_arg (ap, tree));
297 return call;
301 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
302 Build the basic components of a GIMPLE_CALL statement to internal
303 function FN with NARGS arguments. */
305 static inline gcall *
306 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
308 gcall *s
309 = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
310 nargs + 3));
311 s->subcode |= GF_CALL_INTERNAL;
312 gimple_call_set_internal_fn (s, fn);
313 gimple_call_reset_alias_info (s);
314 return s;
318 /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
319 the number of arguments. The ... are the arguments. */
321 gcall *
322 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
324 va_list ap;
325 gcall *call;
326 unsigned i;
328 call = gimple_build_call_internal_1 (fn, nargs);
329 va_start (ap, nargs);
330 for (i = 0; i < nargs; i++)
331 gimple_call_set_arg (call, i, va_arg (ap, tree));
332 va_end (ap);
334 return call;
338 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
339 specified in vector ARGS. */
341 gcall *
342 gimple_build_call_internal_vec (enum internal_fn fn, const vec<tree> &args)
344 unsigned i, nargs;
345 gcall *call;
347 nargs = args.length ();
348 call = gimple_build_call_internal_1 (fn, nargs);
349 for (i = 0; i < nargs; i++)
350 gimple_call_set_arg (call, i, args[i]);
352 return call;
356 /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
357 assumed to be in GIMPLE form already. Minimal checking is done of
358 this fact. */
360 gcall *
361 gimple_build_call_from_tree (tree t, tree fnptrtype)
363 unsigned i, nargs;
364 gcall *call;
366 gcc_assert (TREE_CODE (t) == CALL_EXPR);
368 nargs = call_expr_nargs (t);
370 tree fndecl = NULL_TREE;
371 if (CALL_EXPR_FN (t) == NULL_TREE)
372 call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
373 else
375 fndecl = get_callee_fndecl (t);
376 call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
379 for (i = 0; i < nargs; i++)
380 gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
382 gimple_set_block (call, TREE_BLOCK (t));
383 gimple_set_location (call, EXPR_LOCATION (t));
385 /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
386 gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
387 gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
388 gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
389 gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
390 if (fndecl
391 && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
392 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
393 gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
394 else if (fndecl
395 && (DECL_IS_OPERATOR_NEW_P (fndecl)
396 || DECL_IS_OPERATOR_DELETE_P (fndecl)))
397 gimple_call_set_from_new_or_delete (call, CALL_FROM_NEW_OR_DELETE_P (t));
398 else
399 gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
400 gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
401 gimple_call_set_nothrow (call, TREE_NOTHROW (t));
402 if (fndecl)
403 gimple_call_set_expected_throw (call,
404 flags_from_decl_or_type (fndecl)
405 & ECF_XTHROW);
406 gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
407 copy_warning (call, t);
409 if (fnptrtype)
411 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
413 /* Check if it's an indirect CALL and the type has the
414 nocf_check attribute. In that case propagate the information
415 to the gimple CALL insn. */
416 if (!fndecl)
418 gcc_assert (POINTER_TYPE_P (fnptrtype));
419 tree fntype = TREE_TYPE (fnptrtype);
421 if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
422 gimple_call_set_nocf_check (call, true);
426 return call;
429 /* Build a gcall to __builtin_unreachable as rewritten by
430 -fsanitize=unreachable. */
432 gcall *
433 gimple_build_builtin_unreachable (location_t loc)
435 tree data = NULL_TREE;
436 tree fn = sanitize_unreachable_fn (&data, loc);
437 gcall *g = gimple_build_call (fn, data != NULL_TREE, data);
438 gimple_call_set_ctrl_altering (g, true);
439 gimple_set_location (g, loc);
440 return g;
443 /* Build a GIMPLE_ASSIGN statement.
445 LHS of the assignment.
446 RHS of the assignment which can be unary or binary. */
448 gassign *
449 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
451 enum tree_code subcode;
452 tree op1, op2, op3;
454 extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
455 return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
459 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
460 OP1, OP2 and OP3. */
462 static inline gassign *
463 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
464 tree op2, tree op3 MEM_STAT_DECL)
466 unsigned num_ops;
467 gassign *p;
469 /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
470 code). */
471 num_ops = get_gimple_rhs_num_ops (subcode) + 1;
473 p = as_a <gassign *> (
474 gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
475 PASS_MEM_STAT));
476 gimple_assign_set_lhs (p, lhs);
477 gimple_assign_set_rhs1 (p, op1);
478 if (op2)
480 gcc_assert (num_ops > 2);
481 gimple_assign_set_rhs2 (p, op2);
484 if (op3)
486 gcc_assert (num_ops > 3);
487 gimple_assign_set_rhs3 (p, op3);
490 return p;
493 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
494 OP1, OP2 and OP3. */
496 gassign *
497 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
498 tree op2, tree op3 MEM_STAT_DECL)
500 return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
503 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
504 OP1 and OP2. */
506 gassign *
507 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
508 tree op2 MEM_STAT_DECL)
510 return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
511 PASS_MEM_STAT);
514 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
516 gassign *
517 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
519 return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
520 PASS_MEM_STAT);
524 /* Build a GIMPLE_COND statement.
526 PRED is the condition used to compare LHS and the RHS.
527 T_LABEL is the label to jump to if the condition is true.
528 F_LABEL is the label to jump to otherwise. */
530 gcond *
531 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
532 tree t_label, tree f_label)
534 gcond *p;
536 gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
537 p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
538 gimple_cond_set_lhs (p, lhs);
539 gimple_cond_set_rhs (p, rhs);
540 gimple_cond_set_true_label (p, t_label);
541 gimple_cond_set_false_label (p, f_label);
542 return p;
545 /* Build a GIMPLE_COND statement from the conditional expression tree
546 COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
548 gcond *
549 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
551 enum tree_code code;
552 tree lhs, rhs;
554 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
555 return gimple_build_cond (code, lhs, rhs, t_label, f_label);
558 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
559 boolean expression tree COND. */
561 void
562 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
564 enum tree_code code;
565 tree lhs, rhs;
567 gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
568 gimple_cond_set_condition (stmt, code, lhs, rhs);
571 /* Build a GIMPLE_LABEL statement for LABEL. */
573 glabel *
574 gimple_build_label (tree label)
576 glabel *p
577 = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
578 gimple_label_set_label (p, label);
579 return p;
582 /* Build a GIMPLE_GOTO statement to label DEST. */
584 ggoto *
585 gimple_build_goto (tree dest)
587 ggoto *p
588 = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
589 gimple_goto_set_dest (p, dest);
590 return p;
594 /* Build a GIMPLE_NOP statement. */
596 gimple *
597 gimple_build_nop (void)
599 return gimple_alloc (GIMPLE_NOP, 0);
603 /* Build a GIMPLE_BIND statement.
604 VARS are the variables in BODY.
605 BLOCK is the containing block. */
607 gbind *
608 gimple_build_bind (tree vars, gimple_seq body, tree block)
610 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
611 gimple_bind_set_vars (p, vars);
612 if (body)
613 gimple_bind_set_body (p, body);
614 if (block)
615 gimple_bind_set_block (p, block);
616 return p;
619 /* Helper function to set the simple fields of a asm stmt.
621 STRING is a pointer to a string that is the asm blocks assembly code.
622 NINPUT is the number of register inputs.
623 NOUTPUT is the number of register outputs.
624 NCLOBBERS is the number of clobbered registers.
627 static inline gasm *
628 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
629 unsigned nclobbers, unsigned nlabels)
631 gasm *p;
632 int size = strlen (string);
634 p = as_a <gasm *> (
635 gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
636 ninputs + noutputs + nclobbers + nlabels));
638 p->ni = ninputs;
639 p->no = noutputs;
640 p->nc = nclobbers;
641 p->nl = nlabels;
642 p->string = ggc_alloc_string (string, size);
644 if (GATHER_STATISTICS)
645 gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
647 return p;
650 /* Build a GIMPLE_ASM statement.
652 STRING is the assembly code.
653 NINPUT is the number of register inputs.
654 NOUTPUT is the number of register outputs.
655 NCLOBBERS is the number of clobbered registers.
656 INPUTS is a vector of the input register parameters.
657 OUTPUTS is a vector of the output register parameters.
658 CLOBBERS is a vector of the clobbered register parameters.
659 LABELS is a vector of destination labels. */
661 gasm *
662 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
663 vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
664 vec<tree, va_gc> *labels)
666 gasm *p;
667 unsigned i;
669 p = gimple_build_asm_1 (string,
670 vec_safe_length (inputs),
671 vec_safe_length (outputs),
672 vec_safe_length (clobbers),
673 vec_safe_length (labels));
675 for (i = 0; i < vec_safe_length (inputs); i++)
676 gimple_asm_set_input_op (p, i, (*inputs)[i]);
678 for (i = 0; i < vec_safe_length (outputs); i++)
679 gimple_asm_set_output_op (p, i, (*outputs)[i]);
681 for (i = 0; i < vec_safe_length (clobbers); i++)
682 gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
684 for (i = 0; i < vec_safe_length (labels); i++)
685 gimple_asm_set_label_op (p, i, (*labels)[i]);
687 return p;
690 /* Build a GIMPLE_CATCH statement.
692 TYPES are the catch types.
693 HANDLER is the exception handler. */
695 gcatch *
696 gimple_build_catch (tree types, gimple_seq handler)
698 gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
699 gimple_catch_set_types (p, types);
700 if (handler)
701 gimple_catch_set_handler (p, handler);
703 return p;
706 /* Build a GIMPLE_EH_FILTER statement.
708 TYPES are the filter's types.
709 FAILURE is the filter's failure action. */
711 geh_filter *
712 gimple_build_eh_filter (tree types, gimple_seq failure)
714 geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
715 gimple_eh_filter_set_types (p, types);
716 if (failure)
717 gimple_eh_filter_set_failure (p, failure);
719 return p;
722 /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
724 geh_mnt *
725 gimple_build_eh_must_not_throw (tree decl)
727 geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
729 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
730 gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
731 gimple_eh_must_not_throw_set_fndecl (p, decl);
733 return p;
736 /* Build a GIMPLE_EH_ELSE statement. */
738 geh_else *
739 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
741 geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
742 gimple_eh_else_set_n_body (p, n_body);
743 gimple_eh_else_set_e_body (p, e_body);
744 return p;
747 /* Build a GIMPLE_TRY statement.
749 EVAL is the expression to evaluate.
750 CLEANUP is the cleanup expression.
751 KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
752 whether this is a try/catch or a try/finally respectively. */
754 gtry *
755 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
756 enum gimple_try_flags kind)
758 gtry *p;
760 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
761 p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
762 gimple_set_subcode (p, kind);
763 if (eval)
764 gimple_try_set_eval (p, eval);
765 if (cleanup)
766 gimple_try_set_cleanup (p, cleanup);
768 return p;
771 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
773 CLEANUP is the cleanup expression. */
775 gimple *
776 gimple_build_wce (gimple_seq cleanup)
778 gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
779 if (cleanup)
780 gimple_wce_set_cleanup (p, cleanup);
782 return p;
786 /* Build a GIMPLE_RESX statement. */
788 gresx *
789 gimple_build_resx (int region)
791 gresx *p
792 = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
793 p->region = region;
794 return p;
798 /* The helper for constructing a gimple switch statement.
799 INDEX is the switch's index.
800 NLABELS is the number of labels in the switch excluding the default.
801 DEFAULT_LABEL is the default label for the switch statement. */
803 gswitch *
804 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
806 /* nlabels + 1 default label + 1 index. */
807 gcc_checking_assert (default_label);
808 gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
809 ERROR_MARK,
810 1 + 1 + nlabels));
811 gimple_switch_set_index (p, index);
812 gimple_switch_set_default_label (p, default_label);
813 return p;
816 /* Build a GIMPLE_SWITCH statement.
818 INDEX is the switch's index.
819 DEFAULT_LABEL is the default label
820 ARGS is a vector of labels excluding the default. */
822 gswitch *
823 gimple_build_switch (tree index, tree default_label, const vec<tree> &args)
825 unsigned i, nlabels = args.length ();
827 gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
829 /* Copy the labels from the vector to the switch statement. */
830 for (i = 0; i < nlabels; i++)
831 gimple_switch_set_label (p, i + 1, args[i]);
833 return p;
836 /* Build a GIMPLE_EH_DISPATCH statement. */
838 geh_dispatch *
839 gimple_build_eh_dispatch (int region)
841 geh_dispatch *p
842 = as_a <geh_dispatch *> (
843 gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
844 p->region = region;
845 return p;
848 /* Build a new GIMPLE_DEBUG_BIND statement.
850 VAR is bound to VALUE; block and location are taken from STMT. */
852 gdebug *
853 gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
855 gdebug *p
856 = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
857 (unsigned)GIMPLE_DEBUG_BIND, 2
858 PASS_MEM_STAT));
859 gimple_debug_bind_set_var (p, var);
860 gimple_debug_bind_set_value (p, value);
861 if (stmt)
862 gimple_set_location (p, gimple_location (stmt));
864 return p;
868 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
870 VAR is bound to VALUE; block and location are taken from STMT. */
872 gdebug *
873 gimple_build_debug_source_bind (tree var, tree value,
874 gimple *stmt MEM_STAT_DECL)
876 gdebug *p
877 = as_a <gdebug *> (
878 gimple_build_with_ops_stat (GIMPLE_DEBUG,
879 (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
880 PASS_MEM_STAT));
882 gimple_debug_source_bind_set_var (p, var);
883 gimple_debug_source_bind_set_value (p, value);
884 if (stmt)
885 gimple_set_location (p, gimple_location (stmt));
887 return p;
891 /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
892 LOCATION. */
894 gdebug *
895 gimple_build_debug_begin_stmt (tree block, location_t location
896 MEM_STAT_DECL)
898 gdebug *p
899 = as_a <gdebug *> (
900 gimple_build_with_ops_stat (GIMPLE_DEBUG,
901 (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
902 PASS_MEM_STAT));
904 gimple_set_location (p, location);
905 gimple_set_block (p, block);
906 cfun->debug_marker_count++;
908 return p;
912 /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
913 LOCATION. The BLOCK links to the inlined function. */
915 gdebug *
916 gimple_build_debug_inline_entry (tree block, location_t location
917 MEM_STAT_DECL)
919 gdebug *p
920 = as_a <gdebug *> (
921 gimple_build_with_ops_stat (GIMPLE_DEBUG,
922 (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
923 PASS_MEM_STAT));
925 gimple_set_location (p, location);
926 gimple_set_block (p, block);
927 cfun->debug_marker_count++;
929 return p;
933 /* Build a GIMPLE_OMP_CRITICAL statement.
935 BODY is the sequence of statements for which only one thread can execute.
936 NAME is optional identifier for this critical block.
937 CLAUSES are clauses for this critical block. */
939 gomp_critical *
940 gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
942 gomp_critical *p
943 = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
944 gimple_omp_critical_set_name (p, name);
945 gimple_omp_critical_set_clauses (p, clauses);
946 if (body)
947 gimple_omp_set_body (p, body);
949 return p;
952 /* Build a GIMPLE_OMP_FOR statement.
954 BODY is sequence of statements inside the for loop.
955 KIND is the `for' variant.
956 CLAUSES are any of the construct's clauses.
957 COLLAPSE is the collapse count.
958 PRE_BODY is the sequence of statements that are loop invariant. */
960 gomp_for *
961 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
962 gimple_seq pre_body)
964 gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
965 if (body)
966 gimple_omp_set_body (p, body);
967 gimple_omp_for_set_clauses (p, clauses);
968 gimple_omp_for_set_kind (p, kind);
969 p->collapse = collapse;
970 p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
972 if (pre_body)
973 gimple_omp_for_set_pre_body (p, pre_body);
975 return p;
979 /* Build a GIMPLE_OMP_PARALLEL statement.
981 BODY is sequence of statements which are executed in parallel.
982 CLAUSES are the OMP parallel construct's clauses.
983 CHILD_FN is the function created for the parallel threads to execute.
984 DATA_ARG are the shared data argument(s). */
986 gomp_parallel *
987 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
988 tree data_arg)
990 gomp_parallel *p
991 = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
992 if (body)
993 gimple_omp_set_body (p, body);
994 gimple_omp_parallel_set_clauses (p, clauses);
995 gimple_omp_parallel_set_child_fn (p, child_fn);
996 gimple_omp_parallel_set_data_arg (p, data_arg);
998 return p;
1002 /* Build a GIMPLE_OMP_TASK statement.
1004 BODY is sequence of statements which are executed by the explicit task.
1005 CLAUSES are the OMP task construct's clauses.
1006 CHILD_FN is the function created for the parallel threads to execute.
1007 DATA_ARG are the shared data argument(s).
1008 COPY_FN is the optional function for firstprivate initialization.
1009 ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
1011 gomp_task *
1012 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
1013 tree data_arg, tree copy_fn, tree arg_size,
1014 tree arg_align)
1016 gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
1017 if (body)
1018 gimple_omp_set_body (p, body);
1019 gimple_omp_task_set_clauses (p, clauses);
1020 gimple_omp_task_set_child_fn (p, child_fn);
1021 gimple_omp_task_set_data_arg (p, data_arg);
1022 gimple_omp_task_set_copy_fn (p, copy_fn);
1023 gimple_omp_task_set_arg_size (p, arg_size);
1024 gimple_omp_task_set_arg_align (p, arg_align);
1026 return p;
1030 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1032 BODY is the sequence of statements in the section. */
1034 gimple *
1035 gimple_build_omp_section (gimple_seq body)
1037 gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
1038 if (body)
1039 gimple_omp_set_body (p, body);
1041 return p;
1045 /* Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.
1047 BODY is the structured block sequence. */
1049 gimple *
1050 gimple_build_omp_structured_block (gimple_seq body)
1052 gimple *p = gimple_alloc (GIMPLE_OMP_STRUCTURED_BLOCK, 0);
1053 if (body)
1054 gimple_omp_set_body (p, body);
1056 return p;
1060 /* Build a GIMPLE_OMP_MASTER statement.
1062 BODY is the sequence of statements to be executed by just the master. */
1064 gimple *
1065 gimple_build_omp_master (gimple_seq body)
1067 gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
1068 if (body)
1069 gimple_omp_set_body (p, body);
1071 return p;
1074 /* Build a GIMPLE_OMP_MASKED statement.
1076 BODY is the sequence of statements to be executed by the selected thread(s). */
1078 gimple *
1079 gimple_build_omp_masked (gimple_seq body, tree clauses)
1081 gimple *p = gimple_alloc (GIMPLE_OMP_MASKED, 0);
1082 gimple_omp_masked_set_clauses (p, clauses);
1083 if (body)
1084 gimple_omp_set_body (p, body);
1086 return p;
1089 /* Build a GIMPLE_OMP_TASKGROUP statement.
1091 BODY is the sequence of statements to be executed by the taskgroup
1092 construct.
1093 CLAUSES are any of the construct's clauses. */
1095 gimple *
1096 gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
1098 gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1099 gimple_omp_taskgroup_set_clauses (p, clauses);
1100 if (body)
1101 gimple_omp_set_body (p, body);
1103 return p;
1107 /* Build a GIMPLE_OMP_CONTINUE statement.
1109 CONTROL_DEF is the definition of the control variable.
1110 CONTROL_USE is the use of the control variable. */
1112 gomp_continue *
1113 gimple_build_omp_continue (tree control_def, tree control_use)
1115 gomp_continue *p
1116 = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1117 gimple_omp_continue_set_control_def (p, control_def);
1118 gimple_omp_continue_set_control_use (p, control_use);
1119 return p;
1122 /* Build a GIMPLE_OMP_ORDERED statement.
1124 BODY is the sequence of statements inside a loop that will executed in
1125 sequence.
1126 CLAUSES are clauses for this statement. */
1128 gomp_ordered *
1129 gimple_build_omp_ordered (gimple_seq body, tree clauses)
1131 gomp_ordered *p
1132 = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1133 gimple_omp_ordered_set_clauses (p, clauses);
1134 if (body)
1135 gimple_omp_set_body (p, body);
1137 return p;
1141 /* Build a GIMPLE_OMP_RETURN statement.
1142 WAIT_P is true if this is a non-waiting return. */
1144 gimple *
1145 gimple_build_omp_return (bool wait_p)
1147 gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1148 if (wait_p)
1149 gimple_omp_return_set_nowait (p);
1151 return p;
1155 /* Build a GIMPLE_OMP_SCAN statement.
1157 BODY is the sequence of statements to be executed by the scan
1158 construct.
1159 CLAUSES are any of the construct's clauses. */
1161 gomp_scan *
1162 gimple_build_omp_scan (gimple_seq body, tree clauses)
1164 gomp_scan *p
1165 = as_a <gomp_scan *> (gimple_alloc (GIMPLE_OMP_SCAN, 0));
1166 gimple_omp_scan_set_clauses (p, clauses);
1167 if (body)
1168 gimple_omp_set_body (p, body);
1170 return p;
1174 /* Build a GIMPLE_OMP_SECTIONS statement.
1176 BODY is a sequence of section statements.
1177 CLAUSES are any of the OMP sections contsruct's clauses: private,
1178 firstprivate, lastprivate, reduction, and nowait. */
1180 gomp_sections *
1181 gimple_build_omp_sections (gimple_seq body, tree clauses)
1183 gomp_sections *p
1184 = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1185 if (body)
1186 gimple_omp_set_body (p, body);
1187 gimple_omp_sections_set_clauses (p, clauses);
1189 return p;
1193 /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1195 gimple *
1196 gimple_build_omp_sections_switch (void)
1198 return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1202 /* Build a GIMPLE_OMP_SINGLE statement.
1204 BODY is the sequence of statements that will be executed once.
1205 CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1206 copyprivate, nowait. */
1208 gomp_single *
1209 gimple_build_omp_single (gimple_seq body, tree clauses)
1211 gomp_single *p
1212 = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1213 if (body)
1214 gimple_omp_set_body (p, body);
1215 gimple_omp_single_set_clauses (p, clauses);
1217 return p;
1221 /* Build a GIMPLE_OMP_SCOPE statement.
1223 BODY is the sequence of statements that will be executed once.
1224 CLAUSES are any of the OMP scope construct's clauses: private, reduction,
1225 nowait. */
1227 gimple *
1228 gimple_build_omp_scope (gimple_seq body, tree clauses)
1230 gimple *p = gimple_alloc (GIMPLE_OMP_SCOPE, 0);
1231 gimple_omp_scope_set_clauses (p, clauses);
1232 if (body)
1233 gimple_omp_set_body (p, body);
1235 return p;
1239 /* Build a GIMPLE_OMP_TARGET statement.
1241 BODY is the sequence of statements that will be executed.
1242 KIND is the kind of the region.
1243 CLAUSES are any of the construct's clauses. */
1245 gomp_target *
1246 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1248 gomp_target *p
1249 = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1250 if (body)
1251 gimple_omp_set_body (p, body);
1252 gimple_omp_target_set_clauses (p, clauses);
1253 gimple_omp_target_set_kind (p, kind);
1255 return p;
1259 /* Build a GIMPLE_OMP_TEAMS statement.
1261 BODY is the sequence of statements that will be executed.
1262 CLAUSES are any of the OMP teams construct's clauses. */
1264 gomp_teams *
1265 gimple_build_omp_teams (gimple_seq body, tree clauses)
1267 gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1268 if (body)
1269 gimple_omp_set_body (p, body);
1270 gimple_omp_teams_set_clauses (p, clauses);
1272 return p;
1276 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1278 gomp_atomic_load *
1279 gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
1281 gomp_atomic_load *p
1282 = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1283 gimple_omp_atomic_load_set_lhs (p, lhs);
1284 gimple_omp_atomic_load_set_rhs (p, rhs);
1285 gimple_omp_atomic_set_memory_order (p, mo);
1286 return p;
1289 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1291 VAL is the value we are storing. */
1293 gomp_atomic_store *
1294 gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
1296 gomp_atomic_store *p
1297 = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1298 gimple_omp_atomic_store_set_val (p, val);
1299 gimple_omp_atomic_set_memory_order (p, mo);
1300 return p;
1303 /* Build a GIMPLE_ASSUME statement. */
1305 gimple *
1306 gimple_build_assume (tree guard, gimple_seq body)
1308 gimple_statement_assume *p
1309 = as_a <gimple_statement_assume *> (gimple_alloc (GIMPLE_ASSUME, 0));
1310 gimple_assume_set_guard (p, guard);
1311 *gimple_assume_body_ptr (p) = body;
1312 return p;
1315 /* Build a GIMPLE_TRANSACTION statement. */
1317 gtransaction *
1318 gimple_build_transaction (gimple_seq body)
1320 gtransaction *p
1321 = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1322 gimple_transaction_set_body (p, body);
1323 gimple_transaction_set_label_norm (p, 0);
1324 gimple_transaction_set_label_uninst (p, 0);
1325 gimple_transaction_set_label_over (p, 0);
1326 return p;
1329 #if defined ENABLE_GIMPLE_CHECKING
1330 /* Complain of a gimple type mismatch and die. */
1332 void
1333 gimple_check_failed (const gimple *gs, const char *file, int line,
1334 const char *function, enum gimple_code code,
1335 enum tree_code subcode)
1337 internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1338 gimple_code_name[code],
1339 get_tree_code_name (subcode),
1340 gimple_code_name[gimple_code (gs)],
1341 gs->subcode > 0
1342 ? get_tree_code_name ((enum tree_code) gs->subcode)
1343 : "",
1344 function, trim_filename (file), line);
1346 #endif /* ENABLE_GIMPLE_CHECKING */
1349 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1350 *SEQ_P is NULL, a new sequence is allocated. */
1352 void
1353 gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1355 gimple_stmt_iterator si;
1356 if (gs == NULL)
1357 return;
1359 si = gsi_last (*seq_p);
1360 gsi_insert_after (&si, gs, GSI_NEW_STMT);
1363 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1364 *SEQ_P is NULL, a new sequence is allocated. This function is
1365 similar to gimple_seq_add_stmt, but does not scan the operands.
1366 During gimplification, we need to manipulate statement sequences
1367 before the def/use vectors have been constructed. */
1369 void
1370 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1372 gimple_stmt_iterator si;
1374 if (gs == NULL)
1375 return;
1377 si = gsi_last (*seq_p);
1378 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1381 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1382 NULL, a new sequence is allocated. */
1384 void
1385 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1387 gimple_stmt_iterator si;
1388 if (src == NULL)
1389 return;
1391 si = gsi_last (*dst_p);
1392 gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1395 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1396 NULL, a new sequence is allocated. This function is
1397 similar to gimple_seq_add_seq, but does not scan the operands. */
1399 void
1400 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1402 gimple_stmt_iterator si;
1403 if (src == NULL)
1404 return;
1406 si = gsi_last (*dst_p);
1407 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1410 /* Determine whether to assign a location to the statement GS. */
1412 static bool
1413 should_carry_location_p (gimple *gs)
1415 /* Don't emit a line note for a label. We particularly don't want to
1416 emit one for the break label, since it doesn't actually correspond
1417 to the beginning of the loop/switch. */
1418 if (gimple_code (gs) == GIMPLE_LABEL)
1419 return false;
1421 return true;
1424 /* Set the location for gimple statement GS to LOCATION. */
1426 static void
1427 annotate_one_with_location (gimple *gs, location_t location)
1429 if (!gimple_has_location (gs)
1430 && !gimple_do_not_emit_location_p (gs)
1431 && should_carry_location_p (gs))
1432 gimple_set_location (gs, location);
1435 /* Set LOCATION for all the statements after iterator GSI in sequence
1436 SEQ. If GSI is pointing to the end of the sequence, start with the
1437 first statement in SEQ. */
1439 void
1440 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1441 location_t location)
1443 if (gsi_end_p (gsi))
1444 gsi = gsi_start (seq);
1445 else
1446 gsi_next (&gsi);
1448 for (; !gsi_end_p (gsi); gsi_next (&gsi))
1449 annotate_one_with_location (gsi_stmt (gsi), location);
1452 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1454 void
1455 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1457 gimple_stmt_iterator i;
1459 if (gimple_seq_empty_p (stmt_p))
1460 return;
1462 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1464 gimple *gs = gsi_stmt (i);
1465 annotate_one_with_location (gs, location);
1469 /* Helper function of empty_body_p. Return true if STMT is an empty
1470 statement. */
1472 static bool
1473 empty_stmt_p (gimple *stmt)
1475 if (gimple_code (stmt) == GIMPLE_NOP)
1476 return true;
1477 if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1478 return empty_body_p (gimple_bind_body (bind_stmt));
1479 return false;
1483 /* Return true if BODY contains nothing but empty statements. */
1485 bool
1486 empty_body_p (gimple_seq body)
1488 gimple_stmt_iterator i;
1490 if (gimple_seq_empty_p (body))
1491 return true;
1492 for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1493 if (!empty_stmt_p (gsi_stmt (i))
1494 && !is_gimple_debug (gsi_stmt (i)))
1495 return false;
1497 return true;
1501 /* Perform a deep copy of sequence SRC and return the result. */
1503 gimple_seq
1504 gimple_seq_copy (gimple_seq src)
1506 gimple_stmt_iterator gsi;
1507 gimple_seq new_seq = NULL;
1508 gimple *stmt;
1510 for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1512 stmt = gimple_copy (gsi_stmt (gsi));
1513 gimple_seq_add_stmt (&new_seq, stmt);
1516 return new_seq;
1521 /* Return true if calls C1 and C2 are known to go to the same function. */
1523 bool
1524 gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1526 if (gimple_call_internal_p (c1))
1527 return (gimple_call_internal_p (c2)
1528 && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1529 && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1530 || c1 == c2));
1531 else
1532 return (gimple_call_fn (c1) == gimple_call_fn (c2)
1533 || (gimple_call_fndecl (c1)
1534 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1537 /* Detect flags from a GIMPLE_CALL. This is just like
1538 call_expr_flags, but for gimple tuples. */
1541 gimple_call_flags (const gimple *stmt)
1543 int flags = 0;
1545 if (gimple_call_internal_p (stmt))
1546 flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1547 else
1549 tree decl = gimple_call_fndecl (stmt);
1550 if (decl)
1551 flags = flags_from_decl_or_type (decl);
1552 flags |= flags_from_decl_or_type (gimple_call_fntype (stmt));
1555 if (stmt->subcode & GF_CALL_NOTHROW)
1556 flags |= ECF_NOTHROW;
1557 if (stmt->subcode & GF_CALL_XTHROW)
1558 flags |= ECF_XTHROW;
1560 if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1561 flags |= ECF_BY_DESCRIPTOR;
1563 return flags;
1566 /* Return the "fn spec" string for call STMT. */
1568 attr_fnspec
1569 gimple_call_fnspec (const gcall *stmt)
1571 tree type, attr;
1573 if (gimple_call_internal_p (stmt))
1575 const_tree spec = internal_fn_fnspec (gimple_call_internal_fn (stmt));
1576 if (spec)
1577 return spec;
1578 else
1579 return "";
1582 type = gimple_call_fntype (stmt);
1583 if (type)
1585 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1586 if (attr)
1587 return TREE_VALUE (TREE_VALUE (attr));
1589 if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
1590 return builtin_fnspec (gimple_call_fndecl (stmt));
1591 tree fndecl = gimple_call_fndecl (stmt);
1592 /* If the call is to a replaceable operator delete and results
1593 from a delete expression as opposed to a direct call to
1594 such operator, then we can treat it as free. */
1595 if (fndecl
1596 && DECL_IS_OPERATOR_DELETE_P (fndecl)
1597 && DECL_IS_REPLACEABLE_OPERATOR (fndecl)
1598 && gimple_call_from_new_or_delete (stmt))
1599 return ". o ";
1600 /* Similarly operator new can be treated as malloc. */
1601 if (fndecl
1602 && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
1603 && gimple_call_from_new_or_delete (stmt))
1604 return "m ";
1605 return "";
1608 /* Detects argument flags for argument number ARG on call STMT. */
1611 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1613 attr_fnspec fnspec = gimple_call_fnspec (stmt);
1614 int flags = 0;
1616 if (fnspec.known_p ())
1617 flags = fnspec.arg_eaf_flags (arg);
1618 tree callee = gimple_call_fndecl (stmt);
1619 if (callee)
1621 cgraph_node *node = cgraph_node::get (callee);
1622 modref_summary *summary = node ? get_modref_function_summary (node)
1623 : NULL;
1625 if (summary && summary->arg_flags.length () > arg)
1627 int modref_flags = summary->arg_flags[arg];
1629 /* We have possibly optimized out load. Be conservative here. */
1630 if (!node->binds_to_current_def_p ())
1631 modref_flags = interposable_eaf_flags (modref_flags, flags);
1632 if (dbg_cnt (ipa_mod_ref_pta))
1633 flags |= modref_flags;
1636 return flags;
1639 /* Detects argument flags for return slot on call STMT. */
1642 gimple_call_retslot_flags (const gcall *stmt)
1644 int flags = implicit_retslot_eaf_flags;
1646 tree callee = gimple_call_fndecl (stmt);
1647 if (callee)
1649 cgraph_node *node = cgraph_node::get (callee);
1650 modref_summary *summary = node ? get_modref_function_summary (node)
1651 : NULL;
1653 if (summary)
1655 int modref_flags = summary->retslot_flags;
1657 /* We have possibly optimized out load. Be conservative here. */
1658 if (!node->binds_to_current_def_p ())
1659 modref_flags = interposable_eaf_flags (modref_flags, flags);
1660 if (dbg_cnt (ipa_mod_ref_pta))
1661 flags |= modref_flags;
1664 return flags;
1667 /* Detects argument flags for static chain on call STMT. */
1670 gimple_call_static_chain_flags (const gcall *stmt)
1672 int flags = 0;
1674 tree callee = gimple_call_fndecl (stmt);
1675 if (callee)
1677 cgraph_node *node = cgraph_node::get (callee);
1678 modref_summary *summary = node ? get_modref_function_summary (node)
1679 : NULL;
1681 /* Nested functions should always bind to current def since
1682 there is no public ABI for them. */
1683 gcc_checking_assert (node->binds_to_current_def_p ());
1684 if (summary)
1686 int modref_flags = summary->static_chain_flags;
1688 if (dbg_cnt (ipa_mod_ref_pta))
1689 flags |= modref_flags;
1692 return flags;
1695 /* Detects return flags for the call STMT. */
1698 gimple_call_return_flags (const gcall *stmt)
1700 if (gimple_call_flags (stmt) & ECF_MALLOC)
1701 return ERF_NOALIAS;
1703 attr_fnspec fnspec = gimple_call_fnspec (stmt);
1705 unsigned int arg_no;
1706 if (fnspec.returns_arg (&arg_no))
1707 return ERF_RETURNS_ARG | arg_no;
1709 if (fnspec.returns_noalias_p ())
1710 return ERF_NOALIAS;
1711 return 0;
1715 /* Return true if call STMT is known to return a non-zero result. */
1717 bool
1718 gimple_call_nonnull_result_p (gcall *call)
1720 tree fndecl = gimple_call_fndecl (call);
1721 if (!fndecl)
1722 return false;
1723 if (flag_delete_null_pointer_checks && !flag_check_new
1724 && DECL_IS_OPERATOR_NEW_P (fndecl)
1725 && !TREE_NOTHROW (fndecl))
1726 return true;
1728 /* References are always non-NULL. */
1729 if (flag_delete_null_pointer_checks
1730 && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
1731 return true;
1733 if (flag_delete_null_pointer_checks
1734 && lookup_attribute ("returns_nonnull",
1735 TYPE_ATTRIBUTES (gimple_call_fntype (call))))
1736 return true;
1737 return gimple_alloca_call_p (call);
1741 /* If CALL returns a non-null result in an argument, return that arg. */
1743 tree
1744 gimple_call_nonnull_arg (gcall *call)
1746 tree fndecl = gimple_call_fndecl (call);
1747 if (!fndecl)
1748 return NULL_TREE;
1750 unsigned rf = gimple_call_return_flags (call);
1751 if (rf & ERF_RETURNS_ARG)
1753 unsigned argnum = rf & ERF_RETURN_ARG_MASK;
1754 if (argnum < gimple_call_num_args (call))
1756 tree arg = gimple_call_arg (call, argnum);
1757 if (SSA_VAR_P (arg)
1758 && infer_nonnull_range_by_attribute (call, arg))
1759 return arg;
1762 return NULL_TREE;
1766 /* Return true if GS is a copy assignment. */
1768 bool
1769 gimple_assign_copy_p (gimple *gs)
1771 return (gimple_assign_single_p (gs)
1772 && is_gimple_val (gimple_op (gs, 1)));
1776 /* Return true if GS is a SSA_NAME copy assignment. */
1778 bool
1779 gimple_assign_ssa_name_copy_p (gimple *gs)
1781 return (gimple_assign_single_p (gs)
1782 && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1783 && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1787 /* Return true if GS is an assignment with a unary RHS, but the
1788 operator has no effect on the assigned value. The logic is adapted
1789 from STRIP_NOPS. This predicate is intended to be used in tuplifying
1790 instances in which STRIP_NOPS was previously applied to the RHS of
1791 an assignment.
1793 NOTE: In the use cases that led to the creation of this function
1794 and of gimple_assign_single_p, it is typical to test for either
1795 condition and to proceed in the same manner. In each case, the
1796 assigned value is represented by the single RHS operand of the
1797 assignment. I suspect there may be cases where gimple_assign_copy_p,
1798 gimple_assign_single_p, or equivalent logic is used where a similar
1799 treatment of unary NOPs is appropriate. */
1801 bool
1802 gimple_assign_unary_nop_p (gimple *gs)
1804 return (is_gimple_assign (gs)
1805 && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1806 || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1807 && gimple_assign_rhs1 (gs) != error_mark_node
1808 && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1809 == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1812 /* Return true if GS is an assignment that loads from its rhs1. */
1814 bool
1815 gimple_assign_load_p (const gimple *gs)
1817 tree rhs;
1818 if (!gimple_assign_single_p (gs))
1819 return false;
1820 rhs = gimple_assign_rhs1 (gs);
1821 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
1822 return true;
1823 if (handled_component_p (rhs))
1824 rhs = TREE_OPERAND (rhs, 0);
1825 return (handled_component_p (rhs)
1826 || DECL_P (rhs)
1827 || TREE_CODE (rhs) == MEM_REF
1828 || TREE_CODE (rhs) == TARGET_MEM_REF);
1832 /* Set BB to be the basic block holding G. */
1834 void
1835 gimple_set_bb (gimple *stmt, basic_block bb)
1837 stmt->bb = bb;
1839 if (gimple_code (stmt) != GIMPLE_LABEL)
1840 return;
1842 /* If the statement is a label, add the label to block-to-labels map
1843 so that we can speed up edge creation for GIMPLE_GOTOs. */
1844 if (cfun->cfg)
1846 tree t;
1847 int uid;
1849 t = gimple_label_label (as_a <glabel *> (stmt));
1850 uid = LABEL_DECL_UID (t);
1851 if (uid == -1)
1853 unsigned old_len =
1854 vec_safe_length (label_to_block_map_for_fn (cfun));
1855 LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1856 if (old_len <= (unsigned) uid)
1857 vec_safe_grow_cleared (label_to_block_map_for_fn (cfun), uid + 1);
1860 (*label_to_block_map_for_fn (cfun))[uid] = bb;
1865 /* Modify the RHS of the assignment pointed-to by GSI using the
1866 operands in the expression tree EXPR.
1868 NOTE: The statement pointed-to by GSI may be reallocated if it
1869 did not have enough operand slots.
1871 This function is useful to convert an existing tree expression into
1872 the flat representation used for the RHS of a GIMPLE assignment.
1873 It will reallocate memory as needed to expand or shrink the number
1874 of operand slots needed to represent EXPR.
1876 NOTE: If you find yourself building a tree and then calling this
1877 function, you are most certainly doing it the slow way. It is much
1878 better to build a new assignment or to use the function
1879 gimple_assign_set_rhs_with_ops, which does not require an
1880 expression tree to be built. */
1882 void
1883 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1885 enum tree_code subcode;
1886 tree op1, op2, op3;
1888 extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1889 gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1893 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1894 operands OP1, OP2 and OP3.
1896 NOTE: The statement pointed-to by GSI may be reallocated if it
1897 did not have enough operand slots. */
1899 void
1900 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1901 tree op1, tree op2, tree op3)
1903 unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1904 gimple *stmt = gsi_stmt (*gsi);
1905 gimple *old_stmt = stmt;
1907 /* If the new CODE needs more operands, allocate a new statement. */
1908 if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1910 tree lhs = gimple_assign_lhs (old_stmt);
1911 stmt = gimple_alloc (gimple_code (old_stmt), new_rhs_ops + 1);
1912 memcpy (stmt, old_stmt, gimple_size (gimple_code (old_stmt)));
1913 gimple_init_singleton (stmt);
1915 /* The LHS needs to be reset as this also changes the SSA name
1916 on the LHS. */
1917 gimple_assign_set_lhs (stmt, lhs);
1920 gimple_set_num_ops (stmt, new_rhs_ops + 1);
1921 gimple_set_subcode (stmt, code);
1922 gimple_assign_set_rhs1 (stmt, op1);
1923 if (new_rhs_ops > 1)
1924 gimple_assign_set_rhs2 (stmt, op2);
1925 if (new_rhs_ops > 2)
1926 gimple_assign_set_rhs3 (stmt, op3);
1927 if (stmt != old_stmt)
1928 gsi_replace (gsi, stmt, false);
1932 /* Return the LHS of a statement that performs an assignment,
1933 either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1934 for a call to a function that returns no value, or for a
1935 statement other than an assignment or a call. */
1937 tree
1938 gimple_get_lhs (const gimple *stmt)
1940 enum gimple_code code = gimple_code (stmt);
1942 if (code == GIMPLE_ASSIGN)
1943 return gimple_assign_lhs (stmt);
1944 else if (code == GIMPLE_CALL)
1945 return gimple_call_lhs (stmt);
1946 else if (code == GIMPLE_PHI)
1947 return gimple_phi_result (stmt);
1948 else
1949 return NULL_TREE;
1953 /* Set the LHS of a statement that performs an assignment,
1954 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1956 void
1957 gimple_set_lhs (gimple *stmt, tree lhs)
1959 enum gimple_code code = gimple_code (stmt);
1961 if (code == GIMPLE_ASSIGN)
1962 gimple_assign_set_lhs (stmt, lhs);
1963 else if (code == GIMPLE_CALL)
1964 gimple_call_set_lhs (stmt, lhs);
1965 else
1966 gcc_unreachable ();
1970 /* Return a deep copy of statement STMT. All the operands from STMT
1971 are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1972 and VUSE operand arrays are set to empty in the new copy. The new
1973 copy isn't part of any sequence. */
1975 gimple *
1976 gimple_copy (gimple *stmt)
1978 enum gimple_code code = gimple_code (stmt);
1979 unsigned num_ops = gimple_num_ops (stmt);
1980 gimple *copy = gimple_alloc (code, num_ops);
1981 unsigned i;
1983 /* Shallow copy all the fields from STMT. */
1984 memcpy (copy, stmt, gimple_size (code));
1985 gimple_init_singleton (copy);
1987 /* If STMT has sub-statements, deep-copy them as well. */
1988 if (gimple_has_substatements (stmt))
1990 gimple_seq new_seq;
1991 tree t;
1993 switch (gimple_code (stmt))
1995 case GIMPLE_BIND:
1997 gbind *bind_stmt = as_a <gbind *> (stmt);
1998 gbind *bind_copy = as_a <gbind *> (copy);
1999 new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
2000 gimple_bind_set_body (bind_copy, new_seq);
2001 gimple_bind_set_vars (bind_copy,
2002 unshare_expr (gimple_bind_vars (bind_stmt)));
2003 gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
2005 break;
2007 case GIMPLE_CATCH:
2009 gcatch *catch_stmt = as_a <gcatch *> (stmt);
2010 gcatch *catch_copy = as_a <gcatch *> (copy);
2011 new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
2012 gimple_catch_set_handler (catch_copy, new_seq);
2013 t = unshare_expr (gimple_catch_types (catch_stmt));
2014 gimple_catch_set_types (catch_copy, t);
2016 break;
2018 case GIMPLE_EH_FILTER:
2020 geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
2021 geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
2022 new_seq
2023 = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
2024 gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
2025 t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
2026 gimple_eh_filter_set_types (eh_filter_copy, t);
2028 break;
2030 case GIMPLE_EH_ELSE:
2032 geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
2033 geh_else *eh_else_copy = as_a <geh_else *> (copy);
2034 new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
2035 gimple_eh_else_set_n_body (eh_else_copy, new_seq);
2036 new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
2037 gimple_eh_else_set_e_body (eh_else_copy, new_seq);
2039 break;
2041 case GIMPLE_TRY:
2043 gtry *try_stmt = as_a <gtry *> (stmt);
2044 gtry *try_copy = as_a <gtry *> (copy);
2045 new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
2046 gimple_try_set_eval (try_copy, new_seq);
2047 new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
2048 gimple_try_set_cleanup (try_copy, new_seq);
2050 break;
2052 case GIMPLE_OMP_FOR:
2053 new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
2054 gimple_omp_for_set_pre_body (copy, new_seq);
2055 t = unshare_expr (gimple_omp_for_clauses (stmt));
2056 gimple_omp_for_set_clauses (copy, t);
2058 gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
2059 omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
2060 ( gimple_omp_for_collapse (stmt));
2062 for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
2064 gimple_omp_for_set_cond (copy, i,
2065 gimple_omp_for_cond (stmt, i));
2066 gimple_omp_for_set_index (copy, i,
2067 gimple_omp_for_index (stmt, i));
2068 t = unshare_expr (gimple_omp_for_initial (stmt, i));
2069 gimple_omp_for_set_initial (copy, i, t);
2070 t = unshare_expr (gimple_omp_for_final (stmt, i));
2071 gimple_omp_for_set_final (copy, i, t);
2072 t = unshare_expr (gimple_omp_for_incr (stmt, i));
2073 gimple_omp_for_set_incr (copy, i, t);
2075 goto copy_omp_body;
2077 case GIMPLE_OMP_PARALLEL:
2079 gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
2080 gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
2081 t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
2082 gimple_omp_parallel_set_clauses (omp_par_copy, t);
2083 t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
2084 gimple_omp_parallel_set_child_fn (omp_par_copy, t);
2085 t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
2086 gimple_omp_parallel_set_data_arg (omp_par_copy, t);
2088 goto copy_omp_body;
2090 case GIMPLE_OMP_TASK:
2091 t = unshare_expr (gimple_omp_task_clauses (stmt));
2092 gimple_omp_task_set_clauses (copy, t);
2093 t = unshare_expr (gimple_omp_task_child_fn (stmt));
2094 gimple_omp_task_set_child_fn (copy, t);
2095 t = unshare_expr (gimple_omp_task_data_arg (stmt));
2096 gimple_omp_task_set_data_arg (copy, t);
2097 t = unshare_expr (gimple_omp_task_copy_fn (stmt));
2098 gimple_omp_task_set_copy_fn (copy, t);
2099 t = unshare_expr (gimple_omp_task_arg_size (stmt));
2100 gimple_omp_task_set_arg_size (copy, t);
2101 t = unshare_expr (gimple_omp_task_arg_align (stmt));
2102 gimple_omp_task_set_arg_align (copy, t);
2103 goto copy_omp_body;
2105 case GIMPLE_OMP_CRITICAL:
2106 t = unshare_expr (gimple_omp_critical_name
2107 (as_a <gomp_critical *> (stmt)));
2108 gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
2109 t = unshare_expr (gimple_omp_critical_clauses
2110 (as_a <gomp_critical *> (stmt)));
2111 gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
2112 goto copy_omp_body;
2114 case GIMPLE_OMP_ORDERED:
2115 t = unshare_expr (gimple_omp_ordered_clauses
2116 (as_a <gomp_ordered *> (stmt)));
2117 gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
2118 goto copy_omp_body;
2120 case GIMPLE_OMP_SCAN:
2121 t = gimple_omp_scan_clauses (as_a <gomp_scan *> (stmt));
2122 t = unshare_expr (t);
2123 gimple_omp_scan_set_clauses (as_a <gomp_scan *> (copy), t);
2124 goto copy_omp_body;
2126 case GIMPLE_OMP_TASKGROUP:
2127 t = unshare_expr (gimple_omp_taskgroup_clauses (stmt));
2128 gimple_omp_taskgroup_set_clauses (copy, t);
2129 goto copy_omp_body;
2131 case GIMPLE_OMP_SECTIONS:
2132 t = unshare_expr (gimple_omp_sections_clauses (stmt));
2133 gimple_omp_sections_set_clauses (copy, t);
2134 t = unshare_expr (gimple_omp_sections_control (stmt));
2135 gimple_omp_sections_set_control (copy, t);
2136 goto copy_omp_body;
2138 case GIMPLE_OMP_SINGLE:
2140 gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
2141 t = unshare_expr (gimple_omp_single_clauses (stmt));
2142 gimple_omp_single_set_clauses (omp_single_copy, t);
2144 goto copy_omp_body;
2146 case GIMPLE_OMP_SCOPE:
2147 t = unshare_expr (gimple_omp_scope_clauses (stmt));
2148 gimple_omp_scope_set_clauses (copy, t);
2149 goto copy_omp_body;
2151 case GIMPLE_OMP_TARGET:
2153 gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
2154 gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
2155 t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
2156 gimple_omp_target_set_clauses (omp_target_copy, t);
2157 t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
2158 gimple_omp_target_set_data_arg (omp_target_copy, t);
2160 goto copy_omp_body;
2162 case GIMPLE_OMP_TEAMS:
2164 gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
2165 t = unshare_expr (gimple_omp_teams_clauses (stmt));
2166 gimple_omp_teams_set_clauses (omp_teams_copy, t);
2168 /* FALLTHRU */
2170 case GIMPLE_OMP_SECTION:
2171 case GIMPLE_OMP_MASTER:
2172 case GIMPLE_OMP_STRUCTURED_BLOCK:
2173 copy_omp_body:
2174 new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2175 gimple_omp_set_body (copy, new_seq);
2176 break;
2178 case GIMPLE_OMP_MASKED:
2179 t = unshare_expr (gimple_omp_masked_clauses (stmt));
2180 gimple_omp_masked_set_clauses (copy, t);
2181 goto copy_omp_body;
2183 case GIMPLE_ASSUME:
2184 new_seq = gimple_seq_copy (gimple_assume_body (stmt));
2185 *gimple_assume_body_ptr (copy) = new_seq;
2186 gimple_assume_set_guard (copy,
2187 unshare_expr (gimple_assume_guard (stmt)));
2188 break;
2190 case GIMPLE_TRANSACTION:
2191 new_seq = gimple_seq_copy (gimple_transaction_body (
2192 as_a <gtransaction *> (stmt)));
2193 gimple_transaction_set_body (as_a <gtransaction *> (copy),
2194 new_seq);
2195 break;
2197 case GIMPLE_WITH_CLEANUP_EXPR:
2198 new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2199 gimple_wce_set_cleanup (copy, new_seq);
2200 break;
2202 default:
2203 gcc_unreachable ();
2207 /* Make copy of operands. */
2208 for (i = 0; i < num_ops; i++)
2209 gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2211 if (gimple_has_mem_ops (stmt))
2213 gimple_set_vdef (copy, gimple_vdef (stmt));
2214 gimple_set_vuse (copy, gimple_vuse (stmt));
2217 /* Clear out SSA operand vectors on COPY. */
2218 if (gimple_has_ops (stmt))
2220 gimple_set_use_ops (copy, NULL);
2222 /* SSA operands need to be updated. */
2223 gimple_set_modified (copy, true);
2226 if (gimple_debug_nonbind_marker_p (stmt))
2227 cfun->debug_marker_count++;
2229 return copy;
2232 /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2233 that OLD_STMT is about to be removed. */
2235 void
2236 gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
2238 tree vdef = gimple_vdef (old_stmt);
2239 gimple_set_vuse (new_stmt, gimple_vuse (old_stmt));
2240 gimple_set_vdef (new_stmt, vdef);
2241 if (vdef && TREE_CODE (vdef) == SSA_NAME)
2242 SSA_NAME_DEF_STMT (vdef) = new_stmt;
2245 /* Return true if statement S has side-effects. We consider a
2246 statement to have side effects if:
2248 - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2249 - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2251 bool
2252 gimple_has_side_effects (const gimple *s)
2254 if (is_gimple_debug (s))
2255 return false;
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))
2261 return true;
2263 if (gimple_code (s) == GIMPLE_ASM
2264 && gimple_asm_volatile_p (as_a <const gasm *> (s)))
2265 return true;
2267 if (is_gimple_call (s))
2269 int flags = gimple_call_flags (s);
2271 /* An infinite loop is considered a side effect. */
2272 if (!(flags & (ECF_CONST | ECF_PURE))
2273 || (flags & ECF_LOOPING_CONST_OR_PURE))
2274 return true;
2276 return false;
2279 return false;
2282 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2283 Return true if S can trap. When INCLUDE_MEM is true, check whether
2284 the memory operations could trap. When INCLUDE_STORES is true and
2285 S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2287 bool
2288 gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores)
2290 tree t, div = NULL_TREE;
2291 enum tree_code op;
2293 if (include_mem)
2295 unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
2297 for (i = start; i < gimple_num_ops (s); i++)
2298 if (tree_could_trap_p (gimple_op (s, i)))
2299 return true;
2302 switch (gimple_code (s))
2304 case GIMPLE_ASM:
2305 return gimple_asm_volatile_p (as_a <const gasm *> (s));
2307 case GIMPLE_CALL:
2308 if (gimple_call_internal_p (s))
2309 return false;
2310 t = gimple_call_fndecl (s);
2311 /* Assume that indirect and calls to weak functions may trap. */
2312 if (!t || !DECL_P (t) || DECL_WEAK (t))
2313 return true;
2314 return false;
2316 case GIMPLE_ASSIGN:
2317 op = gimple_assign_rhs_code (s);
2319 /* For COND_EXPR only the condition may trap. */
2320 if (op == COND_EXPR)
2321 return tree_could_trap_p (gimple_assign_rhs1 (s));
2323 /* For comparisons we need to check rhs operand types instead of lhs type
2324 (which is BOOLEAN_TYPE). */
2325 if (TREE_CODE_CLASS (op) == tcc_comparison)
2326 t = TREE_TYPE (gimple_assign_rhs1 (s));
2327 else
2328 t = TREE_TYPE (gimple_assign_lhs (s));
2330 if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2331 div = gimple_assign_rhs2 (s);
2333 return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2334 (INTEGRAL_TYPE_P (t)
2335 && TYPE_OVERFLOW_TRAPS (t)),
2336 div));
2338 case GIMPLE_COND:
2339 t = TREE_TYPE (gimple_cond_lhs (s));
2340 return operation_could_trap_p (gimple_cond_code (s),
2341 FLOAT_TYPE_P (t), false, NULL_TREE);
2343 default:
2344 break;
2347 return false;
2350 /* Return true if statement S can trap. */
2352 bool
2353 gimple_could_trap_p (const gimple *s)
2355 return gimple_could_trap_p_1 (s, true, true);
2358 /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2360 bool
2361 gimple_assign_rhs_could_trap_p (gimple *s)
2363 gcc_assert (is_gimple_assign (s));
2364 return gimple_could_trap_p_1 (s, true, false);
2368 /* Print debugging information for gimple stmts generated. */
2370 void
2371 dump_gimple_statistics (void)
2373 int i;
2374 uint64_t total_tuples = 0, total_bytes = 0;
2376 if (! GATHER_STATISTICS)
2378 fprintf (stderr, "No GIMPLE statistics\n");
2379 return;
2382 fprintf (stderr, "\nGIMPLE statements\n");
2383 fprintf (stderr, "Kind Stmts Bytes\n");
2384 fprintf (stderr, "---------------------------------------\n");
2385 for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2387 fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
2388 gimple_alloc_kind_names[i],
2389 SIZE_AMOUNT (gimple_alloc_counts[i]),
2390 SIZE_AMOUNT (gimple_alloc_sizes[i]));
2391 total_tuples += gimple_alloc_counts[i];
2392 total_bytes += gimple_alloc_sizes[i];
2394 fprintf (stderr, "---------------------------------------\n");
2395 fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
2396 SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
2397 fprintf (stderr, "---------------------------------------\n");
2401 /* Return the number of operands needed on the RHS of a GIMPLE
2402 assignment for an expression with tree code CODE. */
2404 unsigned
2405 get_gimple_rhs_num_ops (enum tree_code code)
2407 switch (get_gimple_rhs_class (code))
2409 case GIMPLE_UNARY_RHS:
2410 case GIMPLE_SINGLE_RHS:
2411 return 1;
2412 case GIMPLE_BINARY_RHS:
2413 return 2;
2414 case GIMPLE_TERNARY_RHS:
2415 return 3;
2416 default:
2417 gcc_unreachable ();
2421 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2422 (unsigned char) \
2423 ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2424 : ((TYPE) == tcc_binary \
2425 || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2426 : ((TYPE) == tcc_constant \
2427 || (TYPE) == tcc_declaration \
2428 || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2429 : ((SYM) == TRUTH_AND_EXPR \
2430 || (SYM) == TRUTH_OR_EXPR \
2431 || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2432 : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2433 : ((SYM) == COND_EXPR \
2434 || (SYM) == WIDEN_MULT_PLUS_EXPR \
2435 || (SYM) == WIDEN_MULT_MINUS_EXPR \
2436 || (SYM) == DOT_PROD_EXPR \
2437 || (SYM) == SAD_EXPR \
2438 || (SYM) == REALIGN_LOAD_EXPR \
2439 || (SYM) == VEC_COND_EXPR \
2440 || (SYM) == VEC_PERM_EXPR \
2441 || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2442 : ((SYM) == CONSTRUCTOR \
2443 || (SYM) == OBJ_TYPE_REF \
2444 || (SYM) == ADDR_EXPR \
2445 || (SYM) == WITH_SIZE_EXPR \
2446 || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2447 : GIMPLE_INVALID_RHS),
2448 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2450 const unsigned char gimple_rhs_class_table[] = {
2451 #include "all-tree.def"
2454 #undef DEFTREECODE
2455 #undef END_OF_BASE_TREE_CODES
2457 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2458 the positions marked by the set ARGS_TO_SKIP. */
2460 gcall *
2461 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2463 int i;
2464 int nargs = gimple_call_num_args (stmt);
2465 auto_vec<tree> vargs (nargs);
2466 gcall *new_stmt;
2468 for (i = 0; i < nargs; i++)
2469 if (!bitmap_bit_p (args_to_skip, i))
2470 vargs.quick_push (gimple_call_arg (stmt, i));
2472 if (gimple_call_internal_p (stmt))
2473 new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2474 vargs);
2475 else
2476 new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2478 if (gimple_call_lhs (stmt))
2479 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2481 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2482 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2484 if (gimple_has_location (stmt))
2485 gimple_set_location (new_stmt, gimple_location (stmt));
2486 gimple_call_copy_flags (new_stmt, stmt);
2487 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2489 gimple_set_modified (new_stmt, true);
2491 return new_stmt;
2496 /* Return true if the field decls F1 and F2 are at the same offset.
2498 This is intended to be used on GIMPLE types only. */
2500 bool
2501 gimple_compare_field_offset (tree f1, tree f2)
2503 if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2505 tree offset1 = DECL_FIELD_OFFSET (f1);
2506 tree offset2 = DECL_FIELD_OFFSET (f2);
2507 return ((offset1 == offset2
2508 /* Once gimplification is done, self-referential offsets are
2509 instantiated as operand #2 of the COMPONENT_REF built for
2510 each access and reset. Therefore, they are not relevant
2511 anymore and fields are interchangeable provided that they
2512 represent the same access. */
2513 || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2514 && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2515 && (DECL_SIZE (f1) == DECL_SIZE (f2)
2516 || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2517 && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2518 || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2519 && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2520 || operand_equal_p (offset1, offset2, 0))
2521 && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2522 DECL_FIELD_BIT_OFFSET (f2)));
2525 /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2526 should be, so handle differing ones specially by decomposing
2527 the offset into a byte and bit offset manually. */
2528 if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2529 && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2531 unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2532 unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2533 bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2534 byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2535 + bit_offset1 / BITS_PER_UNIT);
2536 bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2537 byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2538 + bit_offset2 / BITS_PER_UNIT);
2539 if (byte_offset1 != byte_offset2)
2540 return false;
2541 return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2544 return false;
2548 /* Return a type the same as TYPE except unsigned or
2549 signed according to UNSIGNEDP. */
2551 static tree
2552 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2554 tree type1;
2555 int i;
2557 type1 = TYPE_MAIN_VARIANT (type);
2558 if (type1 == signed_char_type_node
2559 || type1 == char_type_node
2560 || type1 == unsigned_char_type_node)
2561 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2562 if (type1 == integer_type_node || type1 == unsigned_type_node)
2563 return unsignedp ? unsigned_type_node : integer_type_node;
2564 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2565 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2566 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2567 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2568 if (type1 == long_long_integer_type_node
2569 || type1 == long_long_unsigned_type_node)
2570 return unsignedp
2571 ? long_long_unsigned_type_node
2572 : long_long_integer_type_node;
2574 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2575 if (int_n_enabled_p[i]
2576 && (type1 == int_n_trees[i].unsigned_type
2577 || type1 == int_n_trees[i].signed_type))
2578 return unsignedp
2579 ? int_n_trees[i].unsigned_type
2580 : int_n_trees[i].signed_type;
2582 #if HOST_BITS_PER_WIDE_INT >= 64
2583 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2584 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2585 #endif
2586 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2587 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2588 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2589 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2590 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2591 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2592 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2593 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2595 #define GIMPLE_FIXED_TYPES(NAME) \
2596 if (type1 == short_ ## NAME ## _type_node \
2597 || type1 == unsigned_short_ ## NAME ## _type_node) \
2598 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2599 : short_ ## NAME ## _type_node; \
2600 if (type1 == NAME ## _type_node \
2601 || type1 == unsigned_ ## NAME ## _type_node) \
2602 return unsignedp ? unsigned_ ## NAME ## _type_node \
2603 : NAME ## _type_node; \
2604 if (type1 == long_ ## NAME ## _type_node \
2605 || type1 == unsigned_long_ ## NAME ## _type_node) \
2606 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2607 : long_ ## NAME ## _type_node; \
2608 if (type1 == long_long_ ## NAME ## _type_node \
2609 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2610 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2611 : long_long_ ## NAME ## _type_node;
2613 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2614 if (type1 == NAME ## _type_node \
2615 || type1 == u ## NAME ## _type_node) \
2616 return unsignedp ? u ## NAME ## _type_node \
2617 : NAME ## _type_node;
2619 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2620 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2621 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2622 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2623 : sat_ ## short_ ## NAME ## _type_node; \
2624 if (type1 == sat_ ## NAME ## _type_node \
2625 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2626 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2627 : sat_ ## NAME ## _type_node; \
2628 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2629 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2630 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2631 : sat_ ## long_ ## NAME ## _type_node; \
2632 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2633 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2634 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2635 : sat_ ## long_long_ ## NAME ## _type_node;
2637 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2638 if (type1 == sat_ ## NAME ## _type_node \
2639 || type1 == sat_ ## u ## NAME ## _type_node) \
2640 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2641 : sat_ ## NAME ## _type_node;
2643 GIMPLE_FIXED_TYPES (fract);
2644 GIMPLE_FIXED_TYPES_SAT (fract);
2645 GIMPLE_FIXED_TYPES (accum);
2646 GIMPLE_FIXED_TYPES_SAT (accum);
2648 GIMPLE_FIXED_MODE_TYPES (qq);
2649 GIMPLE_FIXED_MODE_TYPES (hq);
2650 GIMPLE_FIXED_MODE_TYPES (sq);
2651 GIMPLE_FIXED_MODE_TYPES (dq);
2652 GIMPLE_FIXED_MODE_TYPES (tq);
2653 GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2654 GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2655 GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2656 GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2657 GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2658 GIMPLE_FIXED_MODE_TYPES (ha);
2659 GIMPLE_FIXED_MODE_TYPES (sa);
2660 GIMPLE_FIXED_MODE_TYPES (da);
2661 GIMPLE_FIXED_MODE_TYPES (ta);
2662 GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2663 GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2664 GIMPLE_FIXED_MODE_TYPES_SAT (da);
2665 GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2667 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2668 the precision; they have precision set to match their range, but
2669 may use a wider mode to match an ABI. If we change modes, we may
2670 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2671 the precision as well, so as to yield correct results for
2672 bit-field types. C++ does not have these separate bit-field
2673 types, and producing a signed or unsigned variant of an
2674 ENUMERAL_TYPE may cause other problems as well. */
2675 if (!INTEGRAL_TYPE_P (type)
2676 || TYPE_UNSIGNED (type) == unsignedp)
2677 return type;
2679 #define TYPE_OK(node) \
2680 (TYPE_MODE (type) == TYPE_MODE (node) \
2681 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2682 if (TYPE_OK (signed_char_type_node))
2683 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2684 if (TYPE_OK (integer_type_node))
2685 return unsignedp ? unsigned_type_node : integer_type_node;
2686 if (TYPE_OK (short_integer_type_node))
2687 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2688 if (TYPE_OK (long_integer_type_node))
2689 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2690 if (TYPE_OK (long_long_integer_type_node))
2691 return (unsignedp
2692 ? long_long_unsigned_type_node
2693 : long_long_integer_type_node);
2695 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2696 if (int_n_enabled_p[i]
2697 && TYPE_MODE (type) == int_n_data[i].m
2698 && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2699 return unsignedp
2700 ? int_n_trees[i].unsigned_type
2701 : int_n_trees[i].signed_type;
2703 #if HOST_BITS_PER_WIDE_INT >= 64
2704 if (TYPE_OK (intTI_type_node))
2705 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2706 #endif
2707 if (TYPE_OK (intDI_type_node))
2708 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2709 if (TYPE_OK (intSI_type_node))
2710 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2711 if (TYPE_OK (intHI_type_node))
2712 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2713 if (TYPE_OK (intQI_type_node))
2714 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2716 #undef GIMPLE_FIXED_TYPES
2717 #undef GIMPLE_FIXED_MODE_TYPES
2718 #undef GIMPLE_FIXED_TYPES_SAT
2719 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2720 #undef TYPE_OK
2722 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2726 /* Return an unsigned type the same as TYPE in other respects. */
2728 tree
2729 gimple_unsigned_type (tree type)
2731 return gimple_signed_or_unsigned_type (true, type);
2735 /* Return a signed type the same as TYPE in other respects. */
2737 tree
2738 gimple_signed_type (tree type)
2740 return gimple_signed_or_unsigned_type (false, type);
2744 /* Return the typed-based alias set for T, which may be an expression
2745 or a type. Return -1 if we don't do anything special. */
2747 alias_set_type
2748 gimple_get_alias_set (tree t)
2750 /* That's all the expressions we handle specially. */
2751 if (!TYPE_P (t))
2752 return -1;
2754 /* For convenience, follow the C standard when dealing with
2755 character types. Any object may be accessed via an lvalue that
2756 has character type. */
2757 if (t == char_type_node
2758 || t == signed_char_type_node
2759 || t == unsigned_char_type_node)
2760 return 0;
2762 /* Allow aliasing between signed and unsigned variants of the same
2763 type. We treat the signed variant as canonical. */
2764 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2766 tree t1 = gimple_signed_type (t);
2768 /* t1 == t can happen for boolean nodes which are always unsigned. */
2769 if (t1 != t)
2770 return get_alias_set (t1);
2773 /* Allow aliasing between enumeral types and the underlying
2774 integer type. This is required for C since those are
2775 compatible types. */
2776 else if (TREE_CODE (t) == ENUMERAL_TYPE)
2778 tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
2779 false /* short-cut above */);
2780 return get_alias_set (t1);
2783 return -1;
2787 /* Helper for gimple_ior_addresses_taken_1. */
2789 static bool
2790 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2792 bitmap addresses_taken = (bitmap)data;
2793 addr = get_base_address (addr);
2794 if (addr
2795 && DECL_P (addr))
2797 bitmap_set_bit (addresses_taken, DECL_UID (addr));
2798 return true;
2800 return false;
2803 /* Set the bit for the uid of all decls that have their address taken
2804 in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2805 were any in this stmt. */
2807 bool
2808 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2810 return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2811 gimple_ior_addresses_taken_1);
2815 /* Return true when STMTs arguments and return value match those of FNDECL,
2816 a decl of a builtin function. */
2818 bool
2819 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2821 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2823 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2824 if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
2825 fndecl = decl;
2827 tree ret = gimple_call_lhs (stmt);
2828 if (ret
2829 && !useless_type_conversion_p (TREE_TYPE (ret),
2830 TREE_TYPE (TREE_TYPE (fndecl))))
2831 return false;
2833 tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2834 unsigned nargs = gimple_call_num_args (stmt);
2835 for (unsigned i = 0; i < nargs; ++i)
2837 /* Variadic args follow. */
2838 if (!targs)
2839 return true;
2840 tree arg = gimple_call_arg (stmt, i);
2841 tree type = TREE_VALUE (targs);
2842 if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2843 /* char/short integral arguments are promoted to int
2844 by several frontends if targetm.calls.promote_prototypes
2845 is true. Allow such promotion too. */
2846 && !(INTEGRAL_TYPE_P (type)
2847 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2848 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2849 && useless_type_conversion_p (integer_type_node,
2850 TREE_TYPE (arg))))
2851 return false;
2852 targs = TREE_CHAIN (targs);
2854 if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2855 return false;
2856 return true;
2859 /* Return true when STMT is operator a replaceable delete call. */
2861 bool
2862 gimple_call_operator_delete_p (const gcall *stmt)
2864 tree fndecl;
2866 if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
2867 return DECL_IS_OPERATOR_DELETE_P (fndecl);
2868 return false;
2871 /* Return true when STMT is builtins call. */
2873 bool
2874 gimple_call_builtin_p (const gimple *stmt)
2876 tree fndecl;
2877 if (is_gimple_call (stmt)
2878 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2879 && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2880 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2881 return false;
2884 /* Return true when STMT is builtins call to CLASS. */
2886 bool
2887 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2889 tree fndecl;
2890 if (is_gimple_call (stmt)
2891 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2892 && DECL_BUILT_IN_CLASS (fndecl) == klass)
2893 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2894 return false;
2897 /* Return true when STMT is builtins call to CODE of CLASS. */
2899 bool
2900 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2902 tree fndecl;
2903 if (is_gimple_call (stmt)
2904 && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2905 && fndecl_built_in_p (fndecl, code))
2906 return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2907 return false;
2910 /* If CALL is a call to a combined_fn (i.e. an internal function or
2911 a normal built-in function), return its code, otherwise return
2912 CFN_LAST. */
2914 combined_fn
2915 gimple_call_combined_fn (const gimple *stmt)
2917 if (const gcall *call = dyn_cast <const gcall *> (stmt))
2919 if (gimple_call_internal_p (call))
2920 return as_combined_fn (gimple_call_internal_fn (call));
2922 tree fndecl = gimple_call_fndecl (stmt);
2923 if (fndecl
2924 && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
2925 && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2926 return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2928 return CFN_LAST;
2931 /* Return true if STMT clobbers memory. STMT is required to be a
2932 GIMPLE_ASM. */
2934 bool
2935 gimple_asm_clobbers_memory_p (const gasm *stmt)
2937 unsigned i;
2939 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2941 tree op = gimple_asm_clobber_op (stmt, i);
2942 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2943 return true;
2946 /* Non-empty basic ASM implicitly clobbers memory. */
2947 if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2948 return true;
2950 return false;
2953 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2955 void
2956 dump_decl_set (FILE *file, bitmap set)
2958 if (set)
2960 bitmap_iterator bi;
2961 unsigned i;
2963 fprintf (file, "{ ");
2965 EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2967 fprintf (file, "D.%u", i);
2968 fprintf (file, " ");
2971 fprintf (file, "}");
2973 else
2974 fprintf (file, "NIL");
2977 /* Return true when CALL is a call stmt that definitely doesn't
2978 free any memory or makes it unavailable otherwise. */
2979 bool
2980 nonfreeing_call_p (gimple *call)
2982 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2983 && gimple_call_flags (call) & ECF_LEAF)
2984 switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2986 /* Just in case these become ECF_LEAF in the future. */
2987 case BUILT_IN_FREE:
2988 case BUILT_IN_TM_FREE:
2989 case BUILT_IN_REALLOC:
2990 case BUILT_IN_STACK_RESTORE:
2991 case BUILT_IN_GOMP_FREE:
2992 case BUILT_IN_GOMP_REALLOC:
2993 return false;
2994 default:
2995 return true;
2997 else if (gimple_call_internal_p (call))
2998 switch (gimple_call_internal_fn (call))
3000 case IFN_ABNORMAL_DISPATCHER:
3001 return true;
3002 case IFN_ASAN_MARK:
3003 return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
3004 default:
3005 if (gimple_call_flags (call) & ECF_LEAF)
3006 return true;
3007 return false;
3010 tree fndecl = gimple_call_fndecl (call);
3011 if (!fndecl)
3012 return false;
3013 struct cgraph_node *n = cgraph_node::get (fndecl);
3014 if (!n)
3015 return false;
3016 enum availability availability;
3017 n = n->function_symbol (&availability);
3018 if (!n || availability <= AVAIL_INTERPOSABLE)
3019 return false;
3020 return n->nonfreeing_fn;
3023 /* Return true when CALL is a call stmt that definitely need not
3024 be considered to be a memory barrier. */
3025 bool
3026 nonbarrier_call_p (gimple *call)
3028 if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
3029 return true;
3030 /* Should extend this to have a nonbarrier_fn flag, just as above in
3031 the nonfreeing case. */
3032 return false;
3035 /* Callback for walk_stmt_load_store_ops.
3037 Return TRUE if OP will dereference the tree stored in DATA, FALSE
3038 otherwise.
3040 This routine only makes a superficial check for a dereference. Thus
3041 it must only be used if it is safe to return a false negative. */
3042 static bool
3043 check_loadstore (gimple *, tree op, tree, void *data)
3045 if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
3047 /* Some address spaces may legitimately dereference zero. */
3048 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
3049 if (targetm.addr_space.zero_address_valid (as))
3050 return false;
3052 return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
3054 return false;
3058 /* Return true if OP can be inferred to be non-NULL after STMT executes,
3059 either by using a pointer dereference or attributes. */
3060 bool
3061 infer_nonnull_range (gimple *stmt, tree op)
3063 return (infer_nonnull_range_by_dereference (stmt, op)
3064 || infer_nonnull_range_by_attribute (stmt, op));
3067 /* Return true if OP can be inferred to be non-NULL after STMT
3068 executes by using a pointer dereference. */
3069 bool
3070 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
3072 /* We can only assume that a pointer dereference will yield
3073 non-NULL if -fdelete-null-pointer-checks is enabled. */
3074 if (!flag_delete_null_pointer_checks
3075 || !POINTER_TYPE_P (TREE_TYPE (op))
3076 || gimple_code (stmt) == GIMPLE_ASM
3077 || gimple_clobber_p (stmt))
3078 return false;
3080 if (walk_stmt_load_store_ops (stmt, (void *)op,
3081 check_loadstore, check_loadstore))
3082 return true;
3084 return false;
3087 /* Return true if OP can be inferred to be a non-NULL after STMT
3088 executes by using attributes. */
3089 bool
3090 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
3092 /* We can only assume that a pointer dereference will yield
3093 non-NULL if -fdelete-null-pointer-checks is enabled. */
3094 if (!flag_delete_null_pointer_checks
3095 || !POINTER_TYPE_P (TREE_TYPE (op))
3096 || gimple_code (stmt) == GIMPLE_ASM)
3097 return false;
3099 if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
3101 tree fntype = gimple_call_fntype (stmt);
3102 tree attrs = TYPE_ATTRIBUTES (fntype);
3103 for (; attrs; attrs = TREE_CHAIN (attrs))
3105 attrs = lookup_attribute ("nonnull", attrs);
3107 /* If "nonnull" wasn't specified, we know nothing about
3108 the argument. */
3109 if (attrs == NULL_TREE)
3110 return false;
3112 /* If "nonnull" applies to all the arguments, then ARG
3113 is non-null if it's in the argument list. */
3114 if (TREE_VALUE (attrs) == NULL_TREE)
3116 for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
3118 if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
3119 && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
3120 return true;
3122 return false;
3125 /* Now see if op appears in the nonnull list. */
3126 for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
3128 unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
3129 if (idx < gimple_call_num_args (stmt))
3131 tree arg = gimple_call_arg (stmt, idx);
3132 if (operand_equal_p (op, arg, 0))
3133 return true;
3139 /* If this function is marked as returning non-null, then we can
3140 infer OP is non-null if it is used in the return statement. */
3141 if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
3142 if (gimple_return_retval (return_stmt)
3143 && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
3144 && lookup_attribute ("returns_nonnull",
3145 TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
3146 return true;
3148 return false;
3151 /* Compare two case labels. Because the front end should already have
3152 made sure that case ranges do not overlap, it is enough to only compare
3153 the CASE_LOW values of each case label. */
3155 static int
3156 compare_case_labels (const void *p1, const void *p2)
3158 const_tree const case1 = *(const_tree const*)p1;
3159 const_tree const case2 = *(const_tree const*)p2;
3161 /* The 'default' case label always goes first. */
3162 if (!CASE_LOW (case1))
3163 return -1;
3164 else if (!CASE_LOW (case2))
3165 return 1;
3166 else
3167 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
3170 /* Sort the case labels in LABEL_VEC in place in ascending order. */
3172 void
3173 sort_case_labels (vec<tree> &label_vec)
3175 label_vec.qsort (compare_case_labels);
3178 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3180 LABELS is a vector that contains all case labels to look at.
3182 INDEX_TYPE is the type of the switch index expression. Case labels
3183 in LABELS are discarded if their values are not in the value range
3184 covered by INDEX_TYPE. The remaining case label values are folded
3185 to INDEX_TYPE.
3187 If a default case exists in LABELS, it is removed from LABELS and
3188 returned in DEFAULT_CASEP. If no default case exists, but the
3189 case labels already cover the whole range of INDEX_TYPE, a default
3190 case is returned pointing to one of the existing case labels.
3191 Otherwise DEFAULT_CASEP is set to NULL_TREE.
3193 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3194 apply and no action is taken regardless of whether a default case is
3195 found or not. */
3197 void
3198 preprocess_case_label_vec_for_gimple (vec<tree> &labels,
3199 tree index_type,
3200 tree *default_casep)
3202 tree min_value, max_value;
3203 tree default_case = NULL_TREE;
3204 size_t i, len;
3206 i = 0;
3207 min_value = TYPE_MIN_VALUE (index_type);
3208 max_value = TYPE_MAX_VALUE (index_type);
3209 while (i < labels.length ())
3211 tree elt = labels[i];
3212 tree low = CASE_LOW (elt);
3213 tree high = CASE_HIGH (elt);
3214 bool remove_element = false;
3216 if (low)
3218 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
3219 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
3221 /* This is a non-default case label, i.e. it has a value.
3223 See if the case label is reachable within the range of
3224 the index type. Remove out-of-range case values. Turn
3225 case ranges into a canonical form (high > low strictly)
3226 and convert the case label values to the index type.
3228 NB: The type of gimple_switch_index() may be the promoted
3229 type, but the case labels retain the original type. */
3231 if (high)
3233 /* This is a case range. Discard empty ranges.
3234 If the bounds or the range are equal, turn this
3235 into a simple (one-value) case. */
3236 int cmp = tree_int_cst_compare (high, low);
3237 if (cmp < 0)
3238 remove_element = true;
3239 else if (cmp == 0)
3240 high = NULL_TREE;
3243 if (! high)
3245 /* If the simple case value is unreachable, ignore it. */
3246 if ((TREE_CODE (min_value) == INTEGER_CST
3247 && tree_int_cst_compare (low, min_value) < 0)
3248 || (TREE_CODE (max_value) == INTEGER_CST
3249 && tree_int_cst_compare (low, max_value) > 0))
3250 remove_element = true;
3251 else
3252 low = fold_convert (index_type, low);
3254 else
3256 /* If the entire case range is unreachable, ignore it. */
3257 if ((TREE_CODE (min_value) == INTEGER_CST
3258 && tree_int_cst_compare (high, min_value) < 0)
3259 || (TREE_CODE (max_value) == INTEGER_CST
3260 && tree_int_cst_compare (low, max_value) > 0))
3261 remove_element = true;
3262 else
3264 /* If the lower bound is less than the index type's
3265 minimum value, truncate the range bounds. */
3266 if (TREE_CODE (min_value) == INTEGER_CST
3267 && tree_int_cst_compare (low, min_value) < 0)
3268 low = min_value;
3269 low = fold_convert (index_type, low);
3271 /* If the upper bound is greater than the index type's
3272 maximum value, truncate the range bounds. */
3273 if (TREE_CODE (max_value) == INTEGER_CST
3274 && tree_int_cst_compare (high, max_value) > 0)
3275 high = max_value;
3276 high = fold_convert (index_type, high);
3278 /* We may have folded a case range to a one-value case. */
3279 if (tree_int_cst_equal (low, high))
3280 high = NULL_TREE;
3284 CASE_LOW (elt) = low;
3285 CASE_HIGH (elt) = high;
3287 else
3289 gcc_assert (!default_case);
3290 default_case = elt;
3291 /* The default case must be passed separately to the
3292 gimple_build_switch routine. But if DEFAULT_CASEP
3293 is NULL, we do not remove the default case (it would
3294 be completely lost). */
3295 if (default_casep)
3296 remove_element = true;
3299 if (remove_element)
3300 labels.ordered_remove (i);
3301 else
3302 i++;
3304 len = i;
3306 if (!labels.is_empty ())
3307 sort_case_labels (labels);
3309 if (default_casep && !default_case)
3311 /* If the switch has no default label, add one, so that we jump
3312 around the switch body. If the labels already cover the whole
3313 range of the switch index_type, add the default label pointing
3314 to one of the existing labels. */
3315 if (len
3316 && TYPE_MIN_VALUE (index_type)
3317 && TYPE_MAX_VALUE (index_type)
3318 && tree_int_cst_equal (CASE_LOW (labels[0]),
3319 TYPE_MIN_VALUE (index_type)))
3321 tree low, high = CASE_HIGH (labels[len - 1]);
3322 if (!high)
3323 high = CASE_LOW (labels[len - 1]);
3324 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3326 tree widest_label = labels[0];
3327 for (i = 1; i < len; i++)
3329 high = CASE_LOW (labels[i]);
3330 low = CASE_HIGH (labels[i - 1]);
3331 if (!low)
3332 low = CASE_LOW (labels[i - 1]);
3334 if (CASE_HIGH (labels[i]) != NULL_TREE
3335 && (CASE_HIGH (widest_label) == NULL_TREE
3336 || (wi::gtu_p
3337 (wi::to_wide (CASE_HIGH (labels[i]))
3338 - wi::to_wide (CASE_LOW (labels[i])),
3339 wi::to_wide (CASE_HIGH (widest_label))
3340 - wi::to_wide (CASE_LOW (widest_label))))))
3341 widest_label = labels[i];
3343 if (wi::to_wide (low) + 1 != wi::to_wide (high))
3344 break;
3346 if (i == len)
3348 /* Designate the label with the widest range to be the
3349 default label. */
3350 tree label = CASE_LABEL (widest_label);
3351 default_case = build_case_label (NULL_TREE, NULL_TREE,
3352 label);
3358 if (default_casep)
3359 *default_casep = default_case;
3362 /* Set the location of all statements in SEQ to LOC. */
3364 void
3365 gimple_seq_set_location (gimple_seq seq, location_t loc)
3367 for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3368 gimple_set_location (gsi_stmt (i), loc);
3371 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3373 void
3374 gimple_seq_discard (gimple_seq seq)
3376 gimple_stmt_iterator gsi;
3378 for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3380 gimple *stmt = gsi_stmt (gsi);
3381 gsi_remove (&gsi, true);
3382 release_defs (stmt);
3383 ggc_free (stmt);
3387 /* See if STMT now calls function that takes no parameters and if so, drop
3388 call arguments. This is used when devirtualization machinery redirects
3389 to __builtin_unreachable or __cxa_pure_virtual. */
3391 void
3392 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3394 tree decl = gimple_call_fndecl (stmt);
3395 if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3396 && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3397 && gimple_call_num_args (stmt))
3399 gimple_set_num_ops (stmt, 3);
3400 update_stmt_fn (fn, stmt);
3404 /* Return false if STMT will likely expand to real function call. */
3406 bool
3407 gimple_inexpensive_call_p (gcall *stmt)
3409 if (gimple_call_internal_p (stmt))
3410 return true;
3411 tree decl = gimple_call_fndecl (stmt);
3412 if (decl && is_inexpensive_builtin (decl))
3413 return true;
3414 return false;
3417 /* Return a non-artificial location for STMT. If STMT does not have
3418 location information, get the location from EXPR. */
3420 location_t
3421 gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
3423 location_t loc = gimple_nonartificial_location (stmt);
3424 if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
3425 loc = tree_nonartificial_location (expr);
3426 return expansion_point_location_if_in_system_header (loc);
3430 #if CHECKING_P
3432 namespace selftest {
3434 /* Selftests for core gimple structures. */
3436 /* Verify that STMT is pretty-printed as EXPECTED.
3437 Helper function for selftests. */
3439 static void
3440 verify_gimple_pp (const char *expected, gimple *stmt)
3442 pretty_printer pp;
3443 pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
3444 ASSERT_STREQ (expected, pp_formatted_text (&pp));
3447 /* Build a GIMPLE_ASSIGN equivalent to
3448 tmp = 5;
3449 and verify various properties of it. */
3451 static void
3452 test_assign_single ()
3454 tree type = integer_type_node;
3455 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3456 get_identifier ("tmp"),
3457 type);
3458 tree rhs = build_int_cst (type, 5);
3459 gassign *stmt = gimple_build_assign (lhs, rhs);
3460 verify_gimple_pp ("tmp = 5;", stmt);
3462 ASSERT_TRUE (is_gimple_assign (stmt));
3463 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3464 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3465 ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3466 ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3467 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3468 ASSERT_TRUE (gimple_assign_single_p (stmt));
3469 ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3472 /* Build a GIMPLE_ASSIGN equivalent to
3473 tmp = a * b;
3474 and verify various properties of it. */
3476 static void
3477 test_assign_binop ()
3479 tree type = integer_type_node;
3480 tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3481 get_identifier ("tmp"),
3482 type);
3483 tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3484 get_identifier ("a"),
3485 type);
3486 tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3487 get_identifier ("b"),
3488 type);
3489 gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3490 verify_gimple_pp ("tmp = a * b;", stmt);
3492 ASSERT_TRUE (is_gimple_assign (stmt));
3493 ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3494 ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3495 ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3496 ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3497 ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3498 ASSERT_FALSE (gimple_assign_single_p (stmt));
3499 ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3502 /* Build a GIMPLE_NOP and verify various properties of it. */
3504 static void
3505 test_nop_stmt ()
3507 gimple *stmt = gimple_build_nop ();
3508 verify_gimple_pp ("GIMPLE_NOP", stmt);
3509 ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3510 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3511 ASSERT_FALSE (gimple_assign_single_p (stmt));
3514 /* Build a GIMPLE_RETURN equivalent to
3515 return 7;
3516 and verify various properties of it. */
3518 static void
3519 test_return_stmt ()
3521 tree type = integer_type_node;
3522 tree val = build_int_cst (type, 7);
3523 greturn *stmt = gimple_build_return (val);
3524 verify_gimple_pp ("return 7;", stmt);
3526 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3527 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3528 ASSERT_EQ (val, gimple_return_retval (stmt));
3529 ASSERT_FALSE (gimple_assign_single_p (stmt));
3532 /* Build a GIMPLE_RETURN equivalent to
3533 return;
3534 and verify various properties of it. */
3536 static void
3537 test_return_without_value ()
3539 greturn *stmt = gimple_build_return (NULL);
3540 verify_gimple_pp ("return;", stmt);
3542 ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3543 ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3544 ASSERT_EQ (NULL, gimple_return_retval (stmt));
3545 ASSERT_FALSE (gimple_assign_single_p (stmt));
3548 /* Run all of the selftests within this file. */
3550 void
3551 gimple_cc_tests ()
3553 test_assign_single ();
3554 test_assign_binop ();
3555 test_nop_stmt ();
3556 test_return_stmt ();
3557 test_return_without_value ();
3560 } // namespace selftest
3563 #endif /* CHECKING_P */