Line data Source code
1 : /* Gimple IR support functions.
2 :
3 : Copyright (C) 2007-2026 Free Software Foundation, Inc.
4 : Contributed by Aldy Hernandez <aldyh@redhat.com>
5 :
6 : This file is part of GCC.
7 :
8 : GCC is free software; you can redistribute it and/or modify it under
9 : the terms of the GNU General Public License as published by the Free
10 : Software Foundation; either version 3, or (at your option) any later
11 : version.
12 :
13 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : for more details.
17 :
18 : You should have received a copy of the GNU General Public License
19 : along with GCC; see the file COPYING3. If not see
20 : <http://www.gnu.org/licenses/>. */
21 :
22 : #include "config.h"
23 : #include "system.h"
24 : #include "coretypes.h"
25 : #include "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"
53 :
54 : /* All the tuples have their operand vector (if present) at the very bottom of
55 : the structure. Therefore, the offset required to find the operands vector is
56 : the size of the structure minus the size of the 1-element tree array at the
57 : end (see gimple_ops). An adjustment may be required if there is tail
58 : padding, as may happen on a host (e.g. sparc) where a pointer has 4-byte
59 : alignment while a uint64_t has 8-byte alignment.
60 :
61 : Unfortunately, we can't use offsetof to do this computation 100%
62 : straightforwardly, because these structs use inheritance and so are not
63 : standard layout types. However, the fact that they are not standard layout
64 : types also means that tail padding will be reused in inheritance, which makes
65 : it possible to check for the problematic case with the following logic
66 : instead. If tail padding is detected, the offset should be decreased
67 : accordingly. */
68 :
69 : template<typename G>
70 : static constexpr size_t
71 : get_tail_padding_adjustment ()
72 : {
73 : struct padding_check : G
74 : {
75 : tree t;
76 : };
77 : return sizeof (padding_check) == sizeof (G) ? sizeof (tree) : 0;
78 : }
79 :
80 : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
81 : (HAS_TREE_OP \
82 : ? sizeof (STRUCT) - sizeof (tree) - get_tail_padding_adjustment<STRUCT> () \
83 : : 0),
84 : EXPORTED_CONST size_t gimple_ops_offset_[] = {
85 : #include "gsstruct.def"
86 : };
87 : #undef DEFGSSTRUCT
88 :
89 : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
90 : static const size_t gsstruct_code_size[] = {
91 : #include "gsstruct.def"
92 : };
93 : #undef DEFGSSTRUCT
94 :
95 : #define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
96 : const char *const gimple_code_name[] = {
97 : #include "gimple.def"
98 : };
99 : #undef DEFGSCODE
100 :
101 : #define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
102 : EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
103 : #include "gimple.def"
104 : };
105 : #undef DEFGSCODE
106 :
107 : /* Gimple stats. */
108 :
109 : uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
110 : uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
111 :
112 : /* Keep in sync with gimple.h:enum gimple_alloc_kind. */
113 : static const char * const gimple_alloc_kind_names[] = {
114 : "assignments",
115 : "phi nodes",
116 : "conditionals",
117 : "everything else"
118 : };
119 :
120 : /* Static gimple tuple members. */
121 : const enum gimple_code gassign::code_;
122 : const enum gimple_code gcall::code_;
123 : const enum gimple_code gcond::code_;
124 :
125 :
126 : /* Gimple tuple constructors.
127 : Note: Any constructor taking a ``gimple_seq'' as a parameter, can
128 : be passed a NULL to start with an empty sequence. */
129 :
130 : /* Set the code for statement G to CODE. */
131 :
132 : static inline void
133 337642256 : gimple_set_code (gimple *g, enum gimple_code code)
134 : {
135 337642256 : g->code = code;
136 : }
137 :
138 : /* Return the number of bytes needed to hold a GIMPLE statement with
139 : code CODE. */
140 :
141 : size_t
142 413372642 : gimple_size (enum gimple_code code, unsigned num_ops)
143 : {
144 413372642 : size_t size = gsstruct_code_size[gss_for_code (code)];
145 413372642 : if (num_ops > 0)
146 283244469 : size += (sizeof (tree) * (num_ops - 1));
147 413372642 : return size;
148 : }
149 :
150 : /* Initialize GIMPLE statement G with CODE and NUM_OPS. */
151 :
152 : void
153 337642256 : gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
154 : {
155 337642256 : gimple_set_code (g, code);
156 337642256 : gimple_set_num_ops (g, num_ops);
157 :
158 : /* Do not call gimple_set_modified here as it has other side
159 : effects and this tuple is still not completely built. */
160 337642256 : g->modified = 1;
161 337642256 : gimple_init_singleton (g);
162 337642256 : }
163 :
164 : /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
165 : operands. */
166 :
167 : gimple *
168 335139508 : gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
169 : {
170 335139508 : size_t size;
171 335139508 : gimple *stmt;
172 :
173 335139508 : size = gimple_size (code, num_ops);
174 335139508 : if (GATHER_STATISTICS)
175 : {
176 : enum gimple_alloc_kind kind = gimple_alloc_kind (code);
177 : gimple_alloc_counts[(int) kind]++;
178 : gimple_alloc_sizes[(int) kind] += size;
179 : }
180 :
181 335139508 : stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
182 335139508 : gimple_init (stmt, code, num_ops);
183 335139508 : return stmt;
184 : }
185 :
186 : /* Set SUBCODE to be the code of the expression computed by statement G. */
187 :
188 : static inline void
189 239279862 : gimple_set_subcode (gimple *g, unsigned subcode)
190 : {
191 : /* We only have 16 bits for the RHS code. Assert that we are not
192 : overflowing it. */
193 239279862 : gcc_assert (subcode < (1 << 16));
194 239279862 : g->subcode = subcode;
195 239279862 : }
196 :
197 :
198 :
199 : /* Build a tuple with operands. CODE is the statement to build (which
200 : must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
201 : for the new tuple. NUM_OPS is the number of operands to allocate. */
202 :
203 : #define gimple_build_with_ops(c, s, n) \
204 : gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
205 :
206 : static gimple *
207 228424870 : gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
208 : unsigned num_ops MEM_STAT_DECL)
209 : {
210 0 : gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
211 228424870 : gimple_set_subcode (s, subcode);
212 :
213 228424870 : return s;
214 : }
215 :
216 :
217 : /* Build a GIMPLE_RETURN statement returning RETVAL. */
218 :
219 : greturn *
220 3672943 : gimple_build_return (tree retval)
221 : {
222 3672943 : greturn *s
223 3672943 : = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
224 : 2));
225 3672943 : if (retval)
226 2223748 : gimple_return_set_retval (s, retval);
227 3672943 : return s;
228 : }
229 :
230 : /* Reset alias information on call S. */
231 :
232 : void
233 18766990 : gimple_call_reset_alias_info (gcall *s)
234 : {
235 18766990 : if (gimple_call_flags (s) & ECF_CONST)
236 2408000 : memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
237 : else
238 16358990 : pt_solution_reset (gimple_call_use_set (s));
239 18766990 : if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
240 3651816 : memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
241 : else
242 15115174 : pt_solution_reset (gimple_call_clobber_set (s));
243 18766990 : }
244 :
245 : /* Helper for gimple_build_call, gimple_build_call_valist,
246 : gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
247 : components of a GIMPLE_CALL statement to function FN with NARGS
248 : arguments. */
249 :
250 : static inline gcall *
251 12285033 : gimple_build_call_1 (tree fn, unsigned nargs)
252 : {
253 12285033 : gcall *s
254 24570066 : = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
255 : nargs + 3));
256 12285033 : if (TREE_CODE (fn) == FUNCTION_DECL)
257 12065215 : fn = build_fold_addr_expr (fn);
258 12285033 : gimple_set_op (s, 1, fn);
259 12285033 : gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
260 12285033 : gimple_call_reset_alias_info (s);
261 12285033 : return s;
262 : }
263 :
264 :
265 : /* Build a GIMPLE_CALL statement to function FN with the arguments
266 : specified in vector ARGS. */
267 :
268 : gcall *
269 779466 : gimple_build_call_vec (tree fn, const vec<tree> &args)
270 : {
271 779466 : unsigned i;
272 779466 : unsigned nargs = args.length ();
273 779466 : gcall *call = gimple_build_call_1 (fn, nargs);
274 :
275 3430706 : for (i = 0; i < nargs; i++)
276 1871774 : gimple_call_set_arg (call, i, args[i]);
277 :
278 779466 : return call;
279 : }
280 :
281 :
282 : /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
283 : arguments. The ... are the arguments. */
284 :
285 : gcall *
286 632712 : gimple_build_call (tree fn, unsigned nargs, ...)
287 : {
288 632712 : va_list ap;
289 632712 : gcall *call;
290 632712 : unsigned i;
291 :
292 632712 : gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
293 :
294 632712 : call = gimple_build_call_1 (fn, nargs);
295 :
296 632712 : va_start (ap, nargs);
297 1310905 : for (i = 0; i < nargs; i++)
298 678193 : gimple_call_set_arg (call, i, va_arg (ap, tree));
299 632712 : va_end (ap);
300 :
301 632712 : return call;
302 : }
303 :
304 :
305 : /* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
306 : arguments. AP contains the arguments. */
307 :
308 : gcall *
309 2454 : gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
310 : {
311 2454 : gcall *call;
312 2454 : unsigned i;
313 :
314 2454 : gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
315 :
316 2454 : call = gimple_build_call_1 (fn, nargs);
317 :
318 11953 : for (i = 0; i < nargs; i++)
319 7045 : gimple_call_set_arg (call, i, va_arg (ap, tree));
320 :
321 2454 : return call;
322 : }
323 :
324 :
325 : /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
326 : Build the basic components of a GIMPLE_CALL statement to internal
327 : function FN with NARGS arguments. */
328 :
329 : static inline gcall *
330 868856 : gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
331 : {
332 868856 : gcall *s
333 1737712 : = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
334 : nargs + 3));
335 868856 : s->subcode |= GF_CALL_INTERNAL;
336 868856 : gimple_call_set_internal_fn (s, fn);
337 868856 : gimple_call_reset_alias_info (s);
338 868856 : return s;
339 : }
340 :
341 :
342 : /* Build a GIMPLE_CALL statement to internal function FN. NARGS is
343 : the number of arguments. The ... are the arguments. */
344 :
345 : gcall *
346 482241 : gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
347 : {
348 482241 : va_list ap;
349 482241 : gcall *call;
350 482241 : unsigned i;
351 :
352 482241 : call = gimple_build_call_internal_1 (fn, nargs);
353 482241 : va_start (ap, nargs);
354 1938300 : for (i = 0; i < nargs; i++)
355 1456059 : gimple_call_set_arg (call, i, va_arg (ap, tree));
356 482241 : va_end (ap);
357 :
358 482241 : return call;
359 : }
360 :
361 :
362 : /* Build a GIMPLE_CALL statement to internal function FN with the arguments
363 : specified in vector ARGS. */
364 :
365 : gcall *
366 386599 : gimple_build_call_internal_vec (enum internal_fn fn, const vec<tree> &args)
367 : {
368 386599 : unsigned i, nargs;
369 386599 : gcall *call;
370 :
371 386599 : nargs = args.length ();
372 386599 : call = gimple_build_call_internal_1 (fn, nargs);
373 1921887 : for (i = 0; i < nargs; i++)
374 1148689 : gimple_call_set_arg (call, i, args[i]);
375 :
376 386599 : return call;
377 : }
378 :
379 :
380 : /* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
381 : assumed to be in GIMPLE form already. Minimal checking is done of
382 : this fact. */
383 :
384 : gcall *
385 10870417 : gimple_build_call_from_tree (tree t, tree fnptrtype)
386 : {
387 10870417 : unsigned i, nargs;
388 10870417 : gcall *call;
389 :
390 10870417 : gcc_assert (TREE_CODE (t) == CALL_EXPR);
391 :
392 10870417 : nargs = call_expr_nargs (t);
393 :
394 10870417 : tree fndecl = NULL_TREE;
395 10870417 : if (CALL_EXPR_FN (t) == NULL_TREE)
396 16 : call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
397 : else
398 : {
399 10870401 : fndecl = get_callee_fndecl (t);
400 11033772 : call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
401 : }
402 :
403 30339623 : for (i = 0; i < nargs; i++)
404 19469206 : gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
405 :
406 10870417 : gimple_set_block (call, TREE_BLOCK (t));
407 10870417 : gimple_set_location (call, EXPR_LOCATION (t));
408 :
409 : /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
410 10870417 : gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
411 10870417 : gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
412 10870417 : gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
413 10870417 : gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
414 10870417 : if (fndecl
415 10707030 : && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
416 13175494 : && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
417 82940 : gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
418 10828947 : else if (fndecl
419 21494507 : && (DECL_IS_OPERATOR_NEW_P (fndecl)
420 10609223 : || DECL_IS_OPERATOR_DELETE_P (fndecl)))
421 268548 : gimple_call_set_from_new_or_delete (call, CALL_FROM_NEW_OR_DELETE_P (t));
422 : else
423 21389346 : gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
424 10870417 : gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
425 10870417 : gimple_call_set_nothrow (call, TREE_NOTHROW (t));
426 10870417 : if (fndecl)
427 10707030 : gimple_call_set_expected_throw (call,
428 10707030 : flags_from_decl_or_type (fndecl)
429 10707030 : & ECF_XTHROW);
430 10870417 : gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
431 10870417 : copy_warning (call, t);
432 :
433 10870417 : if (fnptrtype)
434 : {
435 10870275 : gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
436 :
437 : /* Check if it's an indirect CALL and the type has the
438 : nocf_check attribute. In that case propagate the information
439 : to the gimple CALL insn. */
440 10870275 : if (!fndecl)
441 : {
442 163245 : gcc_assert (POINTER_TYPE_P (fnptrtype));
443 163245 : tree fntype = TREE_TYPE (fnptrtype);
444 :
445 163245 : if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
446 21 : gimple_call_set_nocf_check (call, true);
447 : }
448 : }
449 :
450 10870417 : return call;
451 : }
452 :
453 : /* Build a gcall to __builtin_unreachable as rewritten by
454 : -fsanitize=unreachable. */
455 :
456 : gcall *
457 184829 : gimple_build_builtin_unreachable (location_t loc)
458 : {
459 184829 : tree data = NULL_TREE;
460 184829 : tree fn = sanitize_unreachable_fn (&data, loc);
461 184829 : gcall *g = gimple_build_call (fn, data != NULL_TREE, data);
462 184829 : gimple_call_set_ctrl_altering (g, true);
463 184829 : gimple_set_location (g, loc);
464 184829 : return g;
465 : }
466 :
467 : /* Build a GIMPLE_ASSIGN statement.
468 :
469 : LHS of the assignment.
470 : RHS of the assignment which can be unary or binary. */
471 :
472 : gassign *
473 89095057 : gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
474 : {
475 89095057 : enum tree_code subcode;
476 89095057 : tree op1, op2, op3;
477 :
478 89095057 : extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
479 89095057 : return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
480 : }
481 :
482 :
483 : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
484 : OP1, OP2 and OP3. */
485 :
486 : static inline gassign *
487 95626103 : gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
488 : tree op2, tree op3 MEM_STAT_DECL)
489 : {
490 95626103 : unsigned num_ops;
491 95626103 : gassign *p;
492 :
493 : /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
494 : code). */
495 95626103 : num_ops = get_gimple_rhs_num_ops (subcode) + 1;
496 :
497 191252206 : p = as_a <gassign *> (
498 : gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
499 : PASS_MEM_STAT));
500 95626103 : gimple_assign_set_lhs (p, lhs);
501 : /* For COND_EXPR, op1 should not be a comparison. */
502 95626103 : if (op1 && subcode == COND_EXPR)
503 275796 : gcc_assert (!COMPARISON_CLASS_P (op1));
504 95626103 : gimple_assign_set_rhs1 (p, op1);
505 95626103 : if (op2)
506 : {
507 15113755 : gcc_assert (num_ops > 2);
508 15113755 : gimple_assign_set_rhs2 (p, op2);
509 : }
510 :
511 95626103 : if (op3)
512 : {
513 393002 : gcc_assert (num_ops > 3);
514 393002 : gimple_assign_set_rhs3 (p, op3);
515 : }
516 :
517 95626103 : return p;
518 : }
519 :
520 : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
521 : OP1, OP2 and OP3. */
522 :
523 : gassign *
524 90509965 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
525 : tree op2, tree op3 MEM_STAT_DECL)
526 : {
527 90509965 : return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
528 : }
529 :
530 : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
531 : OP1 and OP2. */
532 :
533 : gassign *
534 3583718 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
535 : tree op2 MEM_STAT_DECL)
536 : {
537 3583718 : return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
538 3583718 : PASS_MEM_STAT);
539 : }
540 :
541 : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
542 :
543 : gassign *
544 1532420 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
545 : {
546 1532420 : return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
547 1532420 : PASS_MEM_STAT);
548 : }
549 :
550 :
551 : /* Build a GIMPLE_COND statement.
552 :
553 : PRED is the condition used to compare LHS and the RHS.
554 : T_LABEL is the label to jump to if the condition is true.
555 : F_LABEL is the label to jump to otherwise. */
556 :
557 : gcond *
558 10885090 : gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
559 : tree t_label, tree f_label)
560 : {
561 10885090 : gcond *p;
562 :
563 10885090 : gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
564 21770180 : p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
565 10885090 : gimple_cond_set_lhs (p, lhs);
566 10885090 : gimple_cond_set_rhs (p, rhs);
567 10885090 : gimple_cond_set_true_label (p, t_label);
568 10885090 : gimple_cond_set_false_label (p, f_label);
569 10885090 : return p;
570 : }
571 :
572 : /* Build a GIMPLE_COND statement from the conditional expression tree
573 : COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
574 :
575 : gcond *
576 99123 : gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
577 : {
578 99123 : enum tree_code code;
579 99123 : tree lhs, rhs;
580 :
581 99123 : gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
582 99123 : return gimple_build_cond (code, lhs, rhs, t_label, f_label);
583 : }
584 :
585 : /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
586 : boolean expression tree COND. */
587 :
588 : void
589 428232 : gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
590 : {
591 428232 : enum tree_code code;
592 428232 : tree lhs, rhs;
593 :
594 428232 : gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
595 428232 : gimple_cond_set_condition (stmt, code, lhs, rhs);
596 428232 : }
597 :
598 : /* Build a GIMPLE_LABEL statement for LABEL. */
599 :
600 : glabel *
601 19585244 : gimple_build_label (tree label)
602 : {
603 19585244 : glabel *p
604 19585244 : = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
605 19585244 : gimple_label_set_label (p, label);
606 19585244 : return p;
607 : }
608 :
609 : /* Build a GIMPLE_GOTO statement to label DEST. */
610 :
611 : ggoto *
612 7175145 : gimple_build_goto (tree dest)
613 : {
614 7175145 : ggoto *p
615 7175145 : = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
616 7175145 : gimple_goto_set_dest (p, dest);
617 7175145 : return p;
618 : }
619 :
620 :
621 : /* Build a GIMPLE_NOP statement. */
622 :
623 : gimple *
624 15802466 : gimple_build_nop (void)
625 : {
626 15802466 : return gimple_alloc (GIMPLE_NOP, 0);
627 : }
628 :
629 :
630 : /* Build a GIMPLE_BIND statement.
631 : VARS are the variables in BODY.
632 : BLOCK is the containing block. */
633 :
634 : gbind *
635 7556593 : gimple_build_bind (tree vars, gimple_seq body, tree block)
636 : {
637 7556593 : gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
638 7556593 : gimple_bind_set_vars (p, vars);
639 7556593 : if (body)
640 1365890 : gimple_bind_set_body (p, body);
641 7556593 : if (block)
642 6044092 : gimple_bind_set_block (p, block);
643 7556593 : return p;
644 : }
645 :
646 : /* Helper function to set the simple fields of a asm stmt.
647 :
648 : STRING is a pointer to a string that is the asm blocks assembly code.
649 : NINPUT is the number of register inputs.
650 : NOUTPUT is the number of register outputs.
651 : NCLOBBERS is the number of clobbered registers.
652 : */
653 :
654 : static inline gasm *
655 87788 : gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
656 : unsigned nclobbers, unsigned nlabels)
657 : {
658 87788 : gasm *p;
659 87788 : int size = strlen (string);
660 :
661 87788 : p = as_a <gasm *> (
662 87788 : gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
663 : ninputs + noutputs + nclobbers + nlabels));
664 :
665 87788 : p->ni = ninputs;
666 87788 : p->no = noutputs;
667 87788 : p->nc = nclobbers;
668 87788 : p->nl = nlabels;
669 87788 : p->string = ggc_alloc_string (string, size);
670 :
671 87788 : if (GATHER_STATISTICS)
672 : gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
673 :
674 87788 : return p;
675 : }
676 :
677 : /* Build a GIMPLE_ASM statement.
678 :
679 : STRING is the assembly code.
680 : NINPUT is the number of register inputs.
681 : NOUTPUT is the number of register outputs.
682 : NCLOBBERS is the number of clobbered registers.
683 : INPUTS is a vector of the input register parameters.
684 : OUTPUTS is a vector of the output register parameters.
685 : CLOBBERS is a vector of the clobbered register parameters.
686 : LABELS is a vector of destination labels. */
687 :
688 : gasm *
689 87788 : gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
690 : vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
691 : vec<tree, va_gc> *labels)
692 : {
693 87788 : gasm *p;
694 87788 : unsigned i;
695 :
696 171960 : p = gimple_build_asm_1 (string,
697 : vec_safe_length (inputs),
698 : vec_safe_length (outputs),
699 : vec_safe_length (clobbers),
700 : vec_safe_length (labels));
701 :
702 303426 : for (i = 0; i < vec_safe_length (inputs); i++)
703 47150 : gimple_asm_set_input_op (p, i, (*inputs)[i]);
704 :
705 250367 : for (i = 0; i < vec_safe_length (outputs); i++)
706 65999 : gimple_asm_set_output_op (p, i, (*outputs)[i]);
707 :
708 301183 : for (i = 0; i < vec_safe_length (clobbers); i++)
709 80206 : gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
710 :
711 88735 : for (i = 0; i < vec_safe_length (labels); i++)
712 947 : gimple_asm_set_label_op (p, i, (*labels)[i]);
713 :
714 87788 : return p;
715 : }
716 :
717 : /* Build a GIMPLE_CATCH statement.
718 :
719 : TYPES are the catch types.
720 : HANDLER is the exception handler. */
721 :
722 : gcatch *
723 41033 : gimple_build_catch (tree types, gimple_seq handler)
724 : {
725 41033 : gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
726 41033 : gimple_catch_set_types (p, types);
727 41033 : if (handler)
728 41021 : gimple_catch_set_handler (p, handler);
729 :
730 41033 : return p;
731 : }
732 :
733 : /* Build a GIMPLE_EH_FILTER statement.
734 :
735 : TYPES are the filter's types.
736 : FAILURE is the filter's failure action. */
737 :
738 : geh_filter *
739 5841 : gimple_build_eh_filter (tree types, gimple_seq failure)
740 : {
741 5841 : geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
742 5841 : gimple_eh_filter_set_types (p, types);
743 5841 : if (failure)
744 5841 : gimple_eh_filter_set_failure (p, failure);
745 :
746 5841 : return p;
747 : }
748 :
749 : /* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
750 :
751 : geh_mnt *
752 1352646 : gimple_build_eh_must_not_throw (tree decl)
753 : {
754 1352646 : geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
755 :
756 1352646 : gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
757 1352646 : gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
758 1352646 : gimple_eh_must_not_throw_set_fndecl (p, decl);
759 :
760 1352646 : return p;
761 : }
762 :
763 : /* Build a GIMPLE_EH_ELSE statement. */
764 :
765 : geh_else *
766 554 : gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
767 : {
768 554 : geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
769 554 : gimple_eh_else_set_n_body (p, n_body);
770 554 : gimple_eh_else_set_e_body (p, e_body);
771 554 : return p;
772 : }
773 :
774 : /* Build a GIMPLE_TRY statement.
775 :
776 : EVAL is the expression to evaluate.
777 : CLEANUP is the cleanup expression.
778 : KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
779 : whether this is a try/catch or a try/finally respectively. */
780 :
781 : gtry *
782 3288282 : gimple_build_try (gimple_seq eval, gimple_seq cleanup,
783 : enum gimple_try_flags kind)
784 : {
785 3288282 : gtry *p;
786 :
787 3288282 : gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
788 3288282 : p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
789 3288282 : gimple_set_subcode (p, kind);
790 3288282 : if (eval)
791 3193824 : gimple_try_set_eval (p, eval);
792 3288282 : if (cleanup)
793 3288282 : gimple_try_set_cleanup (p, cleanup);
794 :
795 3288282 : return p;
796 : }
797 :
798 : /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
799 :
800 : CLEANUP is the cleanup expression. */
801 :
802 : gimple *
803 653804 : gimple_build_wce (gimple_seq cleanup)
804 : {
805 653804 : gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
806 653804 : if (cleanup)
807 653804 : gimple_wce_set_cleanup (p, cleanup);
808 :
809 653804 : return p;
810 : }
811 :
812 :
813 : /* Build a GIMPLE_RESX statement. */
814 :
815 : gresx *
816 949559 : gimple_build_resx (int region)
817 : {
818 949559 : gresx *p
819 949559 : = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
820 949559 : p->region = region;
821 949559 : return p;
822 : }
823 :
824 :
825 : /* The helper for constructing a gimple switch statement.
826 : INDEX is the switch's index.
827 : NLABELS is the number of labels in the switch excluding the default.
828 : DEFAULT_LABEL is the default label for the switch statement. */
829 :
830 : gswitch *
831 67494 : gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
832 : {
833 : /* nlabels + 1 default label + 1 index. */
834 67494 : gcc_checking_assert (default_label);
835 134988 : gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
836 : ERROR_MARK,
837 : 1 + 1 + nlabels));
838 67494 : gimple_switch_set_index (p, index);
839 67494 : gimple_switch_set_default_label (p, default_label);
840 67494 : return p;
841 : }
842 :
843 : /* Build a GIMPLE_SWITCH statement.
844 :
845 : INDEX is the switch's index.
846 : DEFAULT_LABEL is the default label
847 : ARGS is a vector of labels excluding the default. */
848 :
849 : gswitch *
850 67494 : gimple_build_switch (tree index, tree default_label, const vec<tree> &args)
851 : {
852 67494 : unsigned i, nlabels = args.length ();
853 :
854 67494 : gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
855 :
856 : /* Copy the labels from the vector to the switch statement. */
857 1231609 : for (i = 0; i < nlabels; i++)
858 1096621 : gimple_switch_set_label (p, i + 1, args[i]);
859 :
860 67494 : return p;
861 : }
862 :
863 : /* Build a GIMPLE_EH_DISPATCH statement. */
864 :
865 : geh_dispatch *
866 42785 : gimple_build_eh_dispatch (int region)
867 : {
868 42785 : geh_dispatch *p
869 42785 : = as_a <geh_dispatch *> (
870 : gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
871 42785 : p->region = region;
872 42785 : return p;
873 : }
874 :
875 : /* Build a new GIMPLE_DEBUG_BIND statement.
876 :
877 : VAR is bound to VALUE; block and location are taken from STMT. */
878 :
879 : gdebug *
880 69809183 : gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
881 : {
882 69809183 : gdebug *p
883 69809183 : = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
884 : (unsigned)GIMPLE_DEBUG_BIND, 2
885 : PASS_MEM_STAT));
886 69809183 : gimple_debug_bind_set_var (p, var);
887 69809183 : gimple_debug_bind_set_value (p, value);
888 69809183 : if (stmt)
889 68804437 : gimple_set_location (p, gimple_location (stmt));
890 :
891 69809183 : return p;
892 : }
893 :
894 :
895 : /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
896 :
897 : VAR is bound to VALUE; block and location are taken from STMT. */
898 :
899 : gdebug *
900 736881 : gimple_build_debug_source_bind (tree var, tree value,
901 : gimple *stmt MEM_STAT_DECL)
902 : {
903 736881 : gdebug *p
904 736881 : = as_a <gdebug *> (
905 : gimple_build_with_ops_stat (GIMPLE_DEBUG,
906 : (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
907 : PASS_MEM_STAT));
908 :
909 736881 : gimple_debug_source_bind_set_var (p, var);
910 736881 : gimple_debug_source_bind_set_value (p, value);
911 736881 : if (stmt)
912 585392 : gimple_set_location (p, gimple_location (stmt));
913 :
914 736881 : return p;
915 : }
916 :
917 :
918 : /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
919 : LOCATION. */
920 :
921 : gdebug *
922 2507429 : gimple_build_debug_begin_stmt (tree block, location_t location
923 : MEM_STAT_DECL)
924 : {
925 2507429 : gdebug *p
926 2507429 : = as_a <gdebug *> (
927 : gimple_build_with_ops_stat (GIMPLE_DEBUG,
928 : (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
929 : PASS_MEM_STAT));
930 :
931 2507429 : gimple_set_location (p, location);
932 2507429 : gimple_set_block (p, block);
933 2507429 : cfun->debug_marker_count++;
934 :
935 2507429 : return p;
936 : }
937 :
938 :
939 : /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
940 : LOCATION. The BLOCK links to the inlined function. */
941 :
942 : gdebug *
943 4125337 : gimple_build_debug_inline_entry (tree block, location_t location
944 : MEM_STAT_DECL)
945 : {
946 4125337 : gdebug *p
947 4125337 : = as_a <gdebug *> (
948 : gimple_build_with_ops_stat (GIMPLE_DEBUG,
949 : (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
950 : PASS_MEM_STAT));
951 :
952 4125337 : gimple_set_location (p, location);
953 4125337 : gimple_set_block (p, block);
954 4125337 : cfun->debug_marker_count++;
955 :
956 4125337 : return p;
957 : }
958 :
959 :
960 : /* Build a GIMPLE_OMP_CRITICAL statement.
961 :
962 : BODY is the sequence of statements for which only one thread can execute.
963 : NAME is optional identifier for this critical block.
964 : CLAUSES are clauses for this critical block. */
965 :
966 : gomp_critical *
967 547 : gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
968 : {
969 547 : gomp_critical *p
970 547 : = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
971 547 : gimple_omp_critical_set_name (p, name);
972 547 : gimple_omp_critical_set_clauses (p, clauses);
973 547 : if (body)
974 457 : gimple_omp_set_body (p, body);
975 :
976 547 : return p;
977 : }
978 :
979 : /* Build a GIMPLE_OMP_FOR statement.
980 :
981 : BODY is sequence of statements inside the for loop.
982 : KIND is the `for' variant.
983 : CLAUSES are any of the construct's clauses.
984 : COLLAPSE is the collapse count.
985 : PRE_BODY is the sequence of statements that are loop invariant. */
986 :
987 : gomp_for *
988 53539 : gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
989 : gimple_seq pre_body)
990 : {
991 53539 : gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
992 53539 : if (body)
993 49687 : gimple_omp_set_body (p, body);
994 53539 : gimple_omp_for_set_clauses (p, clauses);
995 53539 : gimple_omp_for_set_kind (p, kind);
996 53539 : p->collapse = collapse;
997 53539 : p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
998 :
999 53539 : if (pre_body)
1000 3573 : gimple_omp_for_set_pre_body (p, pre_body);
1001 :
1002 53539 : return p;
1003 : }
1004 :
1005 :
1006 : /* Build a GIMPLE_OMP_PARALLEL statement.
1007 :
1008 : BODY is sequence of statements which are executed in parallel.
1009 : CLAUSES are the OMP parallel construct's clauses.
1010 : CHILD_FN is the function created for the parallel threads to execute.
1011 : DATA_ARG are the shared data argument(s). */
1012 :
1013 : gomp_parallel *
1014 18577 : gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
1015 : tree data_arg)
1016 : {
1017 18577 : gomp_parallel *p
1018 18577 : = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
1019 18577 : if (body)
1020 18384 : gimple_omp_set_body (p, body);
1021 18577 : gimple_omp_parallel_set_clauses (p, clauses);
1022 18577 : gimple_omp_parallel_set_child_fn (p, child_fn);
1023 18577 : gimple_omp_parallel_set_data_arg (p, data_arg);
1024 :
1025 18577 : return p;
1026 : }
1027 :
1028 :
1029 : /* Build a GIMPLE_OMP_TASK statement.
1030 :
1031 : BODY is sequence of statements which are executed by the explicit task.
1032 : CLAUSES are the OMP task construct's clauses.
1033 : CHILD_FN is the function created for the parallel threads to execute.
1034 : DATA_ARG are the shared data argument(s).
1035 : COPY_FN is the optional function for firstprivate initialization.
1036 : ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
1037 :
1038 : gomp_task *
1039 5690 : gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
1040 : tree data_arg, tree copy_fn, tree arg_size,
1041 : tree arg_align)
1042 : {
1043 5690 : gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
1044 5690 : if (body)
1045 5597 : gimple_omp_set_body (p, body);
1046 5690 : gimple_omp_task_set_clauses (p, clauses);
1047 5690 : gimple_omp_task_set_child_fn (p, child_fn);
1048 5690 : gimple_omp_task_set_data_arg (p, data_arg);
1049 5690 : gimple_omp_task_set_copy_fn (p, copy_fn);
1050 5690 : gimple_omp_task_set_arg_size (p, arg_size);
1051 5690 : gimple_omp_task_set_arg_align (p, arg_align);
1052 :
1053 5690 : return p;
1054 : }
1055 :
1056 :
1057 : /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1058 :
1059 : BODY is the sequence of statements in the section. */
1060 :
1061 : gimple *
1062 1279 : gimple_build_omp_section (gimple_seq body)
1063 : {
1064 1279 : gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
1065 1279 : if (body)
1066 1087 : gimple_omp_set_body (p, body);
1067 :
1068 1279 : return p;
1069 : }
1070 :
1071 :
1072 : /* Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.
1073 :
1074 : BODY is the structured block sequence. */
1075 :
1076 : gimple *
1077 791 : gimple_build_omp_structured_block (gimple_seq body)
1078 : {
1079 791 : gimple *p = gimple_alloc (GIMPLE_OMP_STRUCTURED_BLOCK, 0);
1080 791 : if (body)
1081 791 : gimple_omp_set_body (p, body);
1082 :
1083 791 : return p;
1084 : }
1085 :
1086 :
1087 : /* Build a GIMPLE_OMP_MASTER statement.
1088 :
1089 : BODY is the sequence of statements to be executed by just the master. */
1090 :
1091 : gimple *
1092 874 : gimple_build_omp_master (gimple_seq body)
1093 : {
1094 874 : gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
1095 874 : if (body)
1096 793 : gimple_omp_set_body (p, body);
1097 :
1098 874 : return p;
1099 : }
1100 :
1101 : /* Build a GIMPLE_OMP_MASKED statement.
1102 :
1103 : BODY is the sequence of statements to be executed by the selected thread(s). */
1104 :
1105 : gimple *
1106 497 : gimple_build_omp_masked (gimple_seq body, tree clauses)
1107 : {
1108 497 : gimple *p = gimple_alloc (GIMPLE_OMP_MASKED, 0);
1109 497 : gimple_omp_masked_set_clauses (p, clauses);
1110 497 : if (body)
1111 417 : gimple_omp_set_body (p, body);
1112 :
1113 497 : return p;
1114 : }
1115 :
1116 : /* Build a GIMPLE_OMP_TASKGROUP statement.
1117 :
1118 : BODY is the sequence of statements to be executed by the taskgroup
1119 : construct.
1120 : CLAUSES are any of the construct's clauses. */
1121 :
1122 : gimple *
1123 611 : gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
1124 : {
1125 611 : gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
1126 611 : gimple_omp_taskgroup_set_clauses (p, clauses);
1127 611 : if (body)
1128 611 : gimple_omp_set_body (p, body);
1129 :
1130 611 : return p;
1131 : }
1132 :
1133 :
1134 : /* Build a GIMPLE_OMP_CONTINUE statement.
1135 :
1136 : CONTROL_DEF is the definition of the control variable.
1137 : CONTROL_USE is the use of the control variable. */
1138 :
1139 : gomp_continue *
1140 52058 : gimple_build_omp_continue (tree control_def, tree control_use)
1141 : {
1142 52058 : gomp_continue *p
1143 52058 : = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1144 52058 : gimple_omp_continue_set_control_def (p, control_def);
1145 52058 : gimple_omp_continue_set_control_use (p, control_use);
1146 52058 : return p;
1147 : }
1148 :
1149 : /* Build a GIMPLE_OMP_ORDERED statement.
1150 :
1151 : BODY is the sequence of statements inside a loop that will executed in
1152 : sequence.
1153 : CLAUSES are clauses for this statement. */
1154 :
1155 : gomp_ordered *
1156 1848 : gimple_build_omp_ordered (gimple_seq body, tree clauses)
1157 : {
1158 1848 : gomp_ordered *p
1159 1848 : = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
1160 1848 : gimple_omp_ordered_set_clauses (p, clauses);
1161 1848 : if (body)
1162 501 : gimple_omp_set_body (p, body);
1163 :
1164 1848 : return p;
1165 : }
1166 :
1167 :
1168 : /* Build a GIMPLE_OMP_RETURN statement.
1169 : WAIT_P is true if this is a non-waiting return. */
1170 :
1171 : gimple *
1172 102194 : gimple_build_omp_return (bool wait_p)
1173 : {
1174 102194 : gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1175 102194 : if (wait_p)
1176 37840 : gimple_omp_return_set_nowait (p);
1177 :
1178 102194 : return p;
1179 : }
1180 :
1181 :
1182 : /* Build a GIMPLE_OMP_SCAN statement.
1183 :
1184 : BODY is the sequence of statements to be executed by the scan
1185 : construct.
1186 : CLAUSES are any of the construct's clauses. */
1187 :
1188 : gomp_scan *
1189 1324 : gimple_build_omp_scan (gimple_seq body, tree clauses)
1190 : {
1191 1324 : gomp_scan *p
1192 1324 : = as_a <gomp_scan *> (gimple_alloc (GIMPLE_OMP_SCAN, 0));
1193 1324 : gimple_omp_scan_set_clauses (p, clauses);
1194 1324 : if (body)
1195 1094 : gimple_omp_set_body (p, body);
1196 :
1197 1324 : return p;
1198 : }
1199 :
1200 :
1201 : /* Build a GIMPLE_OMP_SECTIONS statement.
1202 :
1203 : BODY is a sequence of section statements.
1204 : CLAUSES are any of the OMP sections contsruct's clauses: private,
1205 : firstprivate, lastprivate, reduction, and nowait. */
1206 :
1207 : gomp_sections *
1208 634 : gimple_build_omp_sections (gimple_seq body, tree clauses)
1209 : {
1210 634 : gomp_sections *p
1211 634 : = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1212 634 : if (body)
1213 634 : gimple_omp_set_body (p, body);
1214 634 : gimple_omp_sections_set_clauses (p, clauses);
1215 :
1216 634 : return p;
1217 : }
1218 :
1219 :
1220 : /* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1221 :
1222 : gimple *
1223 386 : gimple_build_omp_sections_switch (void)
1224 : {
1225 386 : return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1226 : }
1227 :
1228 :
1229 : /* Build a GIMPLE_OMP_SINGLE statement.
1230 :
1231 : BODY is the sequence of statements that will be executed once.
1232 : CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1233 : copyprivate, nowait. */
1234 :
1235 : gomp_single *
1236 1283 : gimple_build_omp_single (gimple_seq body, tree clauses)
1237 : {
1238 1283 : gomp_single *p
1239 1283 : = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1240 1283 : if (body)
1241 1170 : gimple_omp_set_body (p, body);
1242 1283 : gimple_omp_single_set_clauses (p, clauses);
1243 :
1244 1283 : return p;
1245 : }
1246 :
1247 :
1248 : /* Build a GIMPLE_OMP_SCOPE statement.
1249 :
1250 : BODY is the sequence of statements that will be executed once.
1251 : CLAUSES are any of the OMP scope construct's clauses: private, reduction,
1252 : nowait. */
1253 :
1254 : gimple *
1255 242 : gimple_build_omp_scope (gimple_seq body, tree clauses)
1256 : {
1257 242 : gimple *p = gimple_alloc (GIMPLE_OMP_SCOPE, 0);
1258 242 : gimple_omp_scope_set_clauses (p, clauses);
1259 242 : if (body)
1260 168 : gimple_omp_set_body (p, body);
1261 :
1262 242 : return p;
1263 : }
1264 :
1265 : /* Build a GIMPLE_OMP_DISPATCH statement.
1266 :
1267 : BODY is the target function call to be dispatched.
1268 : CLAUSES are any of the OMP dispatch construct's clauses. */
1269 :
1270 : gimple *
1271 852 : gimple_build_omp_dispatch (gimple_seq body, tree clauses)
1272 : {
1273 852 : gimple *p = gimple_alloc (GIMPLE_OMP_DISPATCH, 0);
1274 852 : gimple_omp_dispatch_set_clauses (p, clauses);
1275 852 : if (body)
1276 852 : gimple_omp_set_body (p, body);
1277 :
1278 852 : return p;
1279 : }
1280 :
1281 : /* Build a GIMPLE_OMP_INTEROP statement.
1282 :
1283 : CLAUSES are any of the OMP interop construct's clauses. */
1284 :
1285 : gimple *
1286 612 : gimple_build_omp_interop (tree clauses)
1287 : {
1288 612 : gimple *p = gimple_alloc (GIMPLE_OMP_INTEROP, 0);
1289 612 : gimple_omp_interop_set_clauses (p, clauses);
1290 :
1291 612 : return p;
1292 : }
1293 :
1294 : /* Build a GIMPLE_OMP_TARGET statement.
1295 :
1296 : BODY is the sequence of statements that will be executed.
1297 : KIND is the kind of the region.
1298 : CLAUSES are any of the construct's clauses.
1299 : ITERATOR_LOOPS is an optional sequence containing constructed loops
1300 : for OpenMP iterators. */
1301 :
1302 : gomp_target *
1303 43160 : gimple_build_omp_target (gimple_seq body, int kind, tree clauses,
1304 : gimple_seq iterator_loops)
1305 : {
1306 43160 : gomp_target *p
1307 43160 : = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1308 43160 : if (body)
1309 29357 : gimple_omp_set_body (p, body);
1310 43160 : gimple_omp_target_set_clauses (p, clauses);
1311 43160 : gimple_omp_target_set_kind (p, kind);
1312 43160 : gimple_omp_target_set_iterator_loops (p, iterator_loops);
1313 :
1314 43160 : return p;
1315 : }
1316 :
1317 :
1318 : /* Build a GIMPLE_OMP_TEAMS statement.
1319 :
1320 : BODY is the sequence of statements that will be executed.
1321 : CLAUSES are any of the OMP teams construct's clauses. */
1322 :
1323 : gomp_teams *
1324 8892 : gimple_build_omp_teams (gimple_seq body, tree clauses)
1325 : {
1326 8892 : gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1327 8892 : if (body)
1328 8892 : gimple_omp_set_body (p, body);
1329 8892 : gimple_omp_teams_set_clauses (p, clauses);
1330 :
1331 8892 : return p;
1332 : }
1333 :
1334 :
1335 : /* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1336 :
1337 : gomp_atomic_load *
1338 10316 : gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
1339 : {
1340 10316 : gomp_atomic_load *p
1341 10316 : = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1342 10316 : gimple_omp_atomic_load_set_lhs (p, lhs);
1343 10316 : gimple_omp_atomic_load_set_rhs (p, rhs);
1344 10316 : gimple_omp_atomic_set_memory_order (p, mo);
1345 10316 : return p;
1346 : }
1347 :
1348 : /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1349 :
1350 : VAL is the value we are storing. */
1351 :
1352 : gomp_atomic_store *
1353 10316 : gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
1354 : {
1355 10316 : gomp_atomic_store *p
1356 10316 : = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1357 10316 : gimple_omp_atomic_store_set_val (p, val);
1358 10316 : gimple_omp_atomic_set_memory_order (p, mo);
1359 10316 : return p;
1360 : }
1361 :
1362 : /* Build a GIMPLE_ASSUME statement. */
1363 :
1364 : gimple *
1365 126 : gimple_build_assume (tree guard, gimple_seq body)
1366 : {
1367 126 : gimple_statement_assume *p
1368 126 : = as_a <gimple_statement_assume *> (gimple_alloc (GIMPLE_ASSUME, 0));
1369 126 : gimple_assume_set_guard (p, guard);
1370 126 : *gimple_assume_body_ptr (p) = body;
1371 126 : return p;
1372 : }
1373 :
1374 : /* Build a GIMPLE_TRANSACTION statement. */
1375 :
1376 : gtransaction *
1377 545 : gimple_build_transaction (gimple_seq body)
1378 : {
1379 545 : gtransaction *p
1380 545 : = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1381 545 : gimple_transaction_set_body (p, body);
1382 545 : gimple_transaction_set_label_norm (p, 0);
1383 545 : gimple_transaction_set_label_uninst (p, 0);
1384 545 : gimple_transaction_set_label_over (p, 0);
1385 545 : return p;
1386 : }
1387 :
1388 : #if defined ENABLE_GIMPLE_CHECKING
1389 : /* Complain of a gimple type mismatch and die. */
1390 :
1391 : void
1392 0 : gimple_check_failed (const gimple *gs, const char *file, int line,
1393 : const char *function, enum gimple_code code,
1394 : enum tree_code subcode)
1395 : {
1396 0 : internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1397 0 : gimple_code_name[code],
1398 : get_tree_code_name (subcode),
1399 0 : gimple_code_name[gimple_code (gs)],
1400 0 : gs->subcode > 0
1401 0 : ? get_tree_code_name ((enum tree_code) gs->subcode)
1402 : : "",
1403 : function, trim_filename (file), line);
1404 : }
1405 : #endif /* ENABLE_GIMPLE_CHECKING */
1406 :
1407 :
1408 : /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1409 : *SEQ_P is NULL, a new sequence is allocated. */
1410 :
1411 : void
1412 47652997 : gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1413 : {
1414 47652997 : gimple_stmt_iterator si;
1415 47652997 : if (gs == NULL)
1416 0 : return;
1417 :
1418 47652997 : si = gsi_last (*seq_p);
1419 47652997 : gsi_insert_after (&si, gs, GSI_NEW_STMT);
1420 : }
1421 :
1422 : /* Link gimple statement GS to the end of the sequence *SEQ_P. If
1423 : *SEQ_P is NULL, a new sequence is allocated. This function is
1424 : similar to gimple_seq_add_stmt, but does not scan the operands.
1425 : During gimplification, we need to manipulate statement sequences
1426 : before the def/use vectors have been constructed. */
1427 :
1428 : void
1429 197066321 : gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1430 : {
1431 197066321 : gimple_stmt_iterator si;
1432 :
1433 197066321 : if (gs == NULL)
1434 0 : return;
1435 :
1436 197066321 : si = gsi_last (*seq_p);
1437 197066321 : gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1438 : }
1439 :
1440 : /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1441 : NULL, a new sequence is allocated. */
1442 :
1443 : void
1444 17168051 : gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1445 : {
1446 17168051 : gimple_stmt_iterator si;
1447 17168051 : if (src == NULL)
1448 5243300 : return;
1449 :
1450 11924751 : si = gsi_last (*dst_p);
1451 11924751 : gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1452 : }
1453 :
1454 : /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1455 : NULL, a new sequence is allocated. This function is
1456 : similar to gimple_seq_add_seq, but does not scan the operands. */
1457 :
1458 : void
1459 277514 : gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1460 : {
1461 277514 : gimple_stmt_iterator si;
1462 277514 : if (src == NULL)
1463 96847 : return;
1464 :
1465 180667 : si = gsi_last (*dst_p);
1466 180667 : gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1467 : }
1468 :
1469 : /* Determine whether to assign a location to the statement GS. */
1470 :
1471 : static bool
1472 268176638 : should_carry_location_p (gimple *gs)
1473 : {
1474 : /* Don't emit a line note for a label. We particularly don't want to
1475 : emit one for the break label, since it doesn't actually correspond
1476 : to the beginning of the loop/switch. */
1477 268176638 : if (gimple_code (gs) == GIMPLE_LABEL)
1478 0 : return false;
1479 :
1480 : return true;
1481 : }
1482 :
1483 : /* Set the location for gimple statement GS to LOCATION. */
1484 :
1485 : static void
1486 680221340 : annotate_one_with_location (gimple *gs, location_t location)
1487 : {
1488 680221340 : if (!gimple_has_location (gs)
1489 337815297 : && !gimple_do_not_emit_location_p (gs)
1490 680221340 : && should_carry_location_p (gs))
1491 26241700 : gimple_set_location (gs, location);
1492 680221340 : }
1493 :
1494 : /* Set LOCATION for all the statements after iterator GSI in sequence
1495 : SEQ. If GSI is pointing to the end of the sequence, start with the
1496 : first statement in SEQ. */
1497 :
1498 : void
1499 100650805 : annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1500 : location_t location)
1501 : {
1502 100650805 : if (gsi_end_p (gsi))
1503 100650805 : gsi = gsi_start (seq);
1504 : else
1505 65825803 : gsi_next (&gsi);
1506 :
1507 780519001 : for (; !gsi_end_p (gsi); gsi_next (&gsi))
1508 679868196 : annotate_one_with_location (gsi_stmt (gsi), location);
1509 100650805 : }
1510 :
1511 : /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1512 :
1513 : void
1514 228272 : annotate_all_with_location (gimple_seq stmt_p, location_t location)
1515 : {
1516 228272 : gimple_stmt_iterator i;
1517 :
1518 228272 : if (gimple_seq_empty_p (stmt_p))
1519 228272 : return;
1520 :
1521 573675 : for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1522 : {
1523 353144 : gimple *gs = gsi_stmt (i);
1524 353144 : annotate_one_with_location (gs, location);
1525 : }
1526 : }
1527 :
1528 : /* Helper function of empty_body_p. Return true if STMT is an empty
1529 : statement. */
1530 :
1531 : static bool
1532 36755 : empty_stmt_p (gimple *stmt)
1533 : {
1534 36755 : if (gimple_code (stmt) == GIMPLE_NOP)
1535 : return true;
1536 36753 : if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1537 21806 : return empty_body_p (gimple_bind_body (bind_stmt));
1538 : return false;
1539 : }
1540 :
1541 :
1542 : /* Return true if BODY contains nothing but empty statements. */
1543 :
1544 : bool
1545 36832 : empty_body_p (gimple_seq body)
1546 : {
1547 36832 : gimple_stmt_iterator i;
1548 :
1549 36832 : if (gimple_seq_empty_p (body))
1550 : return true;
1551 36938 : for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1552 36755 : if (!empty_stmt_p (gsi_stmt (i))
1553 36755 : && !is_gimple_debug (gsi_stmt (i)))
1554 : return false;
1555 :
1556 : return true;
1557 : }
1558 :
1559 :
1560 : /* Perform a deep copy of sequence SRC and return the result. */
1561 :
1562 : gimple_seq
1563 1881763 : gimple_seq_copy (gimple_seq src)
1564 : {
1565 1881763 : gimple_stmt_iterator gsi;
1566 1881763 : gimple_seq new_seq = NULL;
1567 1881763 : gimple *stmt;
1568 :
1569 4223885 : for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1570 : {
1571 2342122 : stmt = gimple_copy (gsi_stmt (gsi));
1572 2342122 : gimple_seq_add_stmt (&new_seq, stmt);
1573 : }
1574 :
1575 1881763 : return new_seq;
1576 : }
1577 :
1578 :
1579 :
1580 : /* Return true if calls C1 and C2 are known to go to the same function. */
1581 :
1582 : bool
1583 1021244 : gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1584 : {
1585 1021244 : if (gimple_call_internal_p (c1))
1586 8522 : return (gimple_call_internal_p (c2)
1587 8522 : && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
1588 17044 : && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
1589 0 : || c1 == c2));
1590 : else
1591 1012722 : return (gimple_call_fn (c1) == gimple_call_fn (c2)
1592 1012722 : || (gimple_call_fndecl (c1)
1593 1012095 : && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1594 : }
1595 :
1596 : /* Detect flags from a GIMPLE_CALL. This is just like
1597 : call_expr_flags, but for gimple tuples. */
1598 :
1599 : int
1600 4322327939 : gimple_call_flags (const gimple *stmt)
1601 : {
1602 4322327939 : int flags = 0;
1603 :
1604 4322327939 : if (gimple_call_internal_p (stmt))
1605 123714225 : flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1606 : else
1607 : {
1608 4198613714 : tree decl = gimple_call_fndecl (stmt);
1609 4198613714 : if (decl)
1610 4073784121 : flags = flags_from_decl_or_type (decl);
1611 4198613714 : flags |= flags_from_decl_or_type (gimple_call_fntype (stmt));
1612 : }
1613 :
1614 4322327939 : if (stmt->subcode & GF_CALL_NOTHROW)
1615 765600175 : flags |= ECF_NOTHROW;
1616 4322327939 : if (stmt->subcode & GF_CALL_XTHROW)
1617 14829974 : flags |= ECF_XTHROW;
1618 :
1619 4322327939 : if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1620 0 : flags |= ECF_BY_DESCRIPTOR;
1621 :
1622 4322327939 : return flags;
1623 : }
1624 :
1625 : /* Return the "fn spec" string for call STMT. */
1626 :
1627 : attr_fnspec
1628 447554525 : gimple_call_fnspec (const gcall *stmt)
1629 : {
1630 447554525 : tree type, attr;
1631 :
1632 447554525 : if (gimple_call_internal_p (stmt))
1633 : {
1634 9684670 : const_tree spec = internal_fn_fnspec (gimple_call_internal_fn (stmt));
1635 9684670 : if (spec)
1636 394728 : return spec;
1637 : else
1638 9289942 : return "";
1639 : }
1640 :
1641 437869855 : type = gimple_call_fntype (stmt);
1642 437869855 : if (type)
1643 : {
1644 437869855 : attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1645 437869855 : if (attr)
1646 61493199 : return TREE_VALUE (TREE_VALUE (attr));
1647 : }
1648 376376656 : if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
1649 112190850 : return builtin_fnspec (gimple_call_fndecl (stmt));
1650 264185806 : tree fndecl = gimple_call_fndecl (stmt);
1651 : /* If the call is to a replaceable operator delete and results
1652 : from a delete expression as opposed to a direct call to
1653 : such operator, then we can treat it as free. */
1654 264185806 : if (fndecl
1655 250108240 : && DECL_IS_OPERATOR_DELETE_P (fndecl)
1656 7763141 : && DECL_IS_REPLACEABLE_OPERATOR (fndecl)
1657 271943168 : && gimple_call_from_new_or_delete (stmt))
1658 : {
1659 7701872 : if (flag_assume_sane_operators_new_delete)
1660 7700377 : return ".co ";
1661 : else
1662 1495 : return ". o ";
1663 : }
1664 : /* Similarly operator new can be treated as malloc. */
1665 256483934 : if (fndecl
1666 242406368 : && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
1667 259660330 : && gimple_call_from_new_or_delete (stmt))
1668 : {
1669 3141577 : if (flag_assume_sane_operators_new_delete)
1670 3140584 : return "mC";
1671 : else
1672 993 : return "m ";
1673 : }
1674 253342357 : return "";
1675 : }
1676 :
1677 : /* Detects argument flags for argument number ARG on call STMT. */
1678 :
1679 : int
1680 124247894 : gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1681 : {
1682 124247894 : attr_fnspec fnspec = gimple_call_fnspec (stmt);
1683 124247894 : int flags = 0;
1684 :
1685 124247894 : if (fnspec.known_p ())
1686 24430658 : flags = fnspec.arg_eaf_flags (arg);
1687 124247894 : tree callee = gimple_call_fndecl (stmt);
1688 124247894 : if (callee)
1689 : {
1690 116192234 : cgraph_node *node = cgraph_node::get (callee);
1691 116192234 : modref_summary *summary = node ? get_modref_function_summary (node)
1692 : : NULL;
1693 :
1694 115975690 : if (summary && summary->arg_flags.length () > arg)
1695 : {
1696 23550517 : int modref_flags = summary->arg_flags[arg];
1697 :
1698 : /* We have possibly optimized out load. Be conservative here. */
1699 23550517 : if (!node->binds_to_current_def_p ())
1700 11645090 : modref_flags = interposable_eaf_flags (modref_flags, flags);
1701 23550517 : if (dbg_cnt (ipa_mod_ref_pta))
1702 23550517 : flags |= modref_flags;
1703 : }
1704 : }
1705 124247894 : return flags;
1706 : }
1707 :
1708 : /* Detects argument flags for return slot on call STMT. */
1709 :
1710 : int
1711 97781 : gimple_call_retslot_flags (const gcall *stmt)
1712 : {
1713 97781 : int flags = implicit_retslot_eaf_flags;
1714 :
1715 97781 : tree callee = gimple_call_fndecl (stmt);
1716 97781 : if (callee)
1717 : {
1718 89055 : cgraph_node *node = cgraph_node::get (callee);
1719 89055 : modref_summary *summary = node ? get_modref_function_summary (node)
1720 : : NULL;
1721 :
1722 89055 : if (summary)
1723 : {
1724 61969 : int modref_flags = summary->retslot_flags;
1725 :
1726 : /* We have possibly optimized out load. Be conservative here. */
1727 61969 : if (!node->binds_to_current_def_p ())
1728 52071 : modref_flags = interposable_eaf_flags (modref_flags, flags);
1729 61969 : if (dbg_cnt (ipa_mod_ref_pta))
1730 61969 : flags |= modref_flags;
1731 : }
1732 : }
1733 97781 : return flags;
1734 : }
1735 :
1736 : /* Detects argument flags for static chain on call STMT. */
1737 :
1738 : int
1739 180508 : gimple_call_static_chain_flags (const gcall *stmt)
1740 : {
1741 180508 : int flags = 0;
1742 :
1743 180508 : tree callee = gimple_call_fndecl (stmt);
1744 180508 : if (callee)
1745 : {
1746 27996 : cgraph_node *node = cgraph_node::get (callee);
1747 27996 : modref_summary *summary = node ? get_modref_function_summary (node)
1748 : : NULL;
1749 :
1750 : /* Nested functions should always bind to current def since
1751 : there is no public ABI for them. */
1752 27996 : gcc_checking_assert (node->binds_to_current_def_p ());
1753 27996 : if (summary)
1754 : {
1755 26159 : int modref_flags = summary->static_chain_flags;
1756 :
1757 26159 : if (dbg_cnt (ipa_mod_ref_pta))
1758 180508 : flags |= modref_flags;
1759 : }
1760 : }
1761 180508 : return flags;
1762 : }
1763 :
1764 : /* Detects return flags for the call STMT. */
1765 :
1766 : int
1767 49208647 : gimple_call_return_flags (const gcall *stmt)
1768 : {
1769 49208647 : if (gimple_call_flags (stmt) & ECF_MALLOC)
1770 : return ERF_NOALIAS;
1771 :
1772 47176279 : attr_fnspec fnspec = gimple_call_fnspec (stmt);
1773 :
1774 47176279 : unsigned int arg_no;
1775 47176279 : if (fnspec.returns_arg (&arg_no))
1776 1123751 : return ERF_RETURNS_ARG | arg_no;
1777 :
1778 46052528 : if (fnspec.returns_noalias_p ())
1779 6076 : return ERF_NOALIAS;
1780 : return 0;
1781 : }
1782 :
1783 :
1784 : /* Return true if call STMT is known to return a non-zero result. */
1785 :
1786 : bool
1787 13412533 : gimple_call_nonnull_result_p (gcall *call)
1788 : {
1789 13412533 : tree fndecl = gimple_call_fndecl (call);
1790 13412533 : if (!fndecl)
1791 : return false;
1792 12229200 : if (flag_delete_null_pointer_checks && !flag_check_new
1793 12229145 : && DECL_IS_OPERATOR_NEW_P (fndecl)
1794 12787454 : && !TREE_NOTHROW (fndecl))
1795 : return true;
1796 :
1797 : /* References are always non-NULL. */
1798 11686740 : if (flag_delete_null_pointer_checks
1799 11686740 : && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
1800 : return true;
1801 :
1802 11686740 : if (flag_delete_null_pointer_checks
1803 23366993 : && lookup_attribute ("returns_nonnull",
1804 11680253 : TYPE_ATTRIBUTES (gimple_call_fntype (call))))
1805 : return true;
1806 11622763 : return gimple_alloca_call_p (call);
1807 : }
1808 :
1809 :
1810 : /* If CALL returns a non-null result in an argument, return that arg. */
1811 :
1812 : tree
1813 12735719 : gimple_call_nonnull_arg (gcall *call)
1814 : {
1815 12735719 : tree fndecl = gimple_call_fndecl (call);
1816 12735719 : if (!fndecl)
1817 : return NULL_TREE;
1818 :
1819 11558873 : unsigned rf = gimple_call_return_flags (call);
1820 11558873 : if (rf & ERF_RETURNS_ARG)
1821 : {
1822 0 : unsigned argnum = rf & ERF_RETURN_ARG_MASK;
1823 0 : if (argnum < gimple_call_num_args (call))
1824 : {
1825 0 : tree arg = gimple_call_arg (call, argnum);
1826 0 : if (SSA_VAR_P (arg)
1827 0 : && infer_nonnull_range_by_attribute (call, arg))
1828 0 : return arg;
1829 : }
1830 : }
1831 : return NULL_TREE;
1832 : }
1833 :
1834 :
1835 : /* Return true if GS is a copy assignment. */
1836 :
1837 : bool
1838 203034316 : gimple_assign_copy_p (gimple *gs)
1839 : {
1840 203034316 : return (gimple_assign_single_p (gs)
1841 203034316 : && is_gimple_val (gimple_op (gs, 1)));
1842 : }
1843 :
1844 :
1845 : /* Return true if GS is a SSA_NAME copy assignment. */
1846 :
1847 : bool
1848 40894274 : gimple_assign_ssa_name_copy_p (gimple *gs)
1849 : {
1850 40894274 : return (gimple_assign_single_p (gs)
1851 23150442 : && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1852 54370013 : && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1853 : }
1854 :
1855 :
1856 : /* Return true if GS is an assignment with a unary RHS, but the
1857 : operator has no effect on the assigned value. The logic is adapted
1858 : from STRIP_NOPS. This predicate is intended to be used in tuplifying
1859 : instances in which STRIP_NOPS was previously applied to the RHS of
1860 : an assignment.
1861 :
1862 : NOTE: In the use cases that led to the creation of this function
1863 : and of gimple_assign_single_p, it is typical to test for either
1864 : condition and to proceed in the same manner. In each case, the
1865 : assigned value is represented by the single RHS operand of the
1866 : assignment. I suspect there may be cases where gimple_assign_copy_p,
1867 : gimple_assign_single_p, or equivalent logic is used where a similar
1868 : treatment of unary NOPs is appropriate. */
1869 :
1870 : bool
1871 47111 : gimple_assign_unary_nop_p (gimple *gs)
1872 : {
1873 47111 : return (is_gimple_assign (gs)
1874 47111 : && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1875 41587 : || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1876 5524 : && gimple_assign_rhs1 (gs) != error_mark_node
1877 58159 : && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1878 5524 : == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1879 : }
1880 :
1881 : /* Return true if GS is an assignment that loads from its rhs1. */
1882 :
1883 : bool
1884 551987111 : gimple_assign_load_p (const gimple *gs)
1885 : {
1886 551987111 : tree rhs;
1887 551987111 : if (!gimple_assign_single_p (gs))
1888 : return false;
1889 335302999 : rhs = gimple_assign_rhs1 (gs);
1890 335302999 : if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
1891 : return true;
1892 335302995 : if (handled_component_p (rhs))
1893 91234802 : rhs = TREE_OPERAND (rhs, 0);
1894 335302995 : return (handled_component_p (rhs)
1895 309285679 : || DECL_P (rhs)
1896 250338727 : || TREE_CODE (rhs) == MEM_REF
1897 185074682 : || TREE_CODE (rhs) == TARGET_MEM_REF);
1898 : }
1899 :
1900 :
1901 : /* Set BB to be the basic block holding G. */
1902 :
1903 : void
1904 757339721 : gimple_set_bb (gimple *stmt, basic_block bb)
1905 : {
1906 757339721 : stmt->bb = bb;
1907 :
1908 757339721 : if (gimple_code (stmt) != GIMPLE_LABEL)
1909 : return;
1910 :
1911 : /* If the statement is a label, add the label to block-to-labels map
1912 : so that we can speed up edge creation for GIMPLE_GOTOs. */
1913 39057603 : if (cfun->cfg)
1914 : {
1915 39057489 : tree t;
1916 39057489 : int uid;
1917 :
1918 39057489 : t = gimple_label_label (as_a <glabel *> (stmt));
1919 39057489 : uid = LABEL_DECL_UID (t);
1920 39057489 : if (uid == -1)
1921 : {
1922 19914547 : unsigned old_len =
1923 19914547 : vec_safe_length (label_to_block_map_for_fn (cfun));
1924 19914547 : LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1925 19914547 : if (old_len <= (unsigned) uid)
1926 9433128 : vec_safe_grow_cleared (label_to_block_map_for_fn (cfun), uid + 1);
1927 : }
1928 :
1929 39057489 : (*label_to_block_map_for_fn (cfun))[uid] = bb;
1930 : }
1931 : }
1932 :
1933 :
1934 : /* Modify the RHS of the assignment pointed-to by GSI using the
1935 : operands in the expression tree EXPR.
1936 :
1937 : NOTE: The statement pointed-to by GSI may be reallocated if it
1938 : did not have enough operand slots.
1939 :
1940 : This function is useful to convert an existing tree expression into
1941 : the flat representation used for the RHS of a GIMPLE assignment.
1942 : It will reallocate memory as needed to expand or shrink the number
1943 : of operand slots needed to represent EXPR.
1944 :
1945 : NOTE: If you find yourself building a tree and then calling this
1946 : function, you are most certainly doing it the slow way. It is much
1947 : better to build a new assignment or to use the function
1948 : gimple_assign_set_rhs_with_ops, which does not require an
1949 : expression tree to be built. */
1950 :
1951 : void
1952 4834726 : gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1953 : {
1954 4834726 : enum tree_code subcode;
1955 4834726 : tree op1, op2, op3;
1956 :
1957 4834726 : extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1958 4834726 : gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1959 4834726 : }
1960 :
1961 :
1962 : /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1963 : operands OP1, OP2 and OP3.
1964 :
1965 : NOTE: The statement pointed-to by GSI may be reallocated if it
1966 : did not have enough operand slots. */
1967 :
1968 : void
1969 7566710 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1970 : tree op1, tree op2, tree op3)
1971 : {
1972 7566710 : unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1973 7566710 : gimple *stmt = gsi_stmt (*gsi);
1974 7566710 : gimple *old_stmt = stmt;
1975 :
1976 : /* If the new CODE needs more operands, allocate a new statement. */
1977 7566710 : if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1978 : {
1979 206504 : tree lhs = gimple_assign_lhs (old_stmt);
1980 206504 : stmt = gimple_alloc (gimple_code (old_stmt), new_rhs_ops + 1);
1981 206504 : memcpy (stmt, old_stmt, gimple_size (gimple_code (old_stmt)));
1982 206504 : gimple_init_singleton (stmt);
1983 :
1984 : /* The LHS needs to be reset as this also changes the SSA name
1985 : on the LHS. */
1986 206504 : gimple_assign_set_lhs (stmt, lhs);
1987 : }
1988 :
1989 7566710 : gimple_set_num_ops (stmt, new_rhs_ops + 1);
1990 7566710 : gimple_set_subcode (stmt, code);
1991 7566710 : gimple_assign_set_rhs1 (stmt, op1);
1992 7566710 : if (new_rhs_ops > 1)
1993 1195690 : gimple_assign_set_rhs2 (stmt, op2);
1994 1195690 : if (new_rhs_ops > 2)
1995 36180 : gimple_assign_set_rhs3 (stmt, op3);
1996 7566710 : if (stmt != old_stmt)
1997 206504 : gsi_replace (gsi, stmt, false);
1998 7566710 : }
1999 :
2000 :
2001 : /* Return the LHS of a statement that performs an assignment,
2002 : either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
2003 : for a call to a function that returns no value, or for a
2004 : statement other than an assignment or a call. */
2005 :
2006 : tree
2007 7268785763 : gimple_get_lhs (const gimple *stmt)
2008 : {
2009 7268785763 : enum gimple_code code = gimple_code (stmt);
2010 :
2011 7268785763 : if (code == GIMPLE_ASSIGN)
2012 4552666319 : return gimple_assign_lhs (stmt);
2013 2716119444 : else if (code == GIMPLE_CALL)
2014 527208217 : return gimple_call_lhs (stmt);
2015 2188911227 : else if (code == GIMPLE_PHI)
2016 132098287 : return gimple_phi_result (stmt);
2017 : else
2018 : return NULL_TREE;
2019 : }
2020 :
2021 :
2022 : /* Set the LHS of a statement that performs an assignment,
2023 : either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2024 :
2025 : void
2026 2257158 : gimple_set_lhs (gimple *stmt, tree lhs)
2027 : {
2028 2257158 : enum gimple_code code = gimple_code (stmt);
2029 :
2030 2257158 : if (code == GIMPLE_ASSIGN)
2031 1073252 : gimple_assign_set_lhs (stmt, lhs);
2032 1183906 : else if (code == GIMPLE_CALL)
2033 1183906 : gimple_call_set_lhs (stmt, lhs);
2034 : else
2035 0 : gcc_unreachable ();
2036 2257158 : }
2037 :
2038 :
2039 : /* Return a deep copy of statement STMT. All the operands from STMT
2040 : are reallocated and copied using unshare_expr. The DEF, USE, VDEF
2041 : and VUSE operand arrays are set to empty in the new copy. The new
2042 : copy isn't part of any sequence. */
2043 :
2044 : gimple *
2045 75523882 : gimple_copy (gimple *stmt)
2046 : {
2047 75523882 : enum gimple_code code = gimple_code (stmt);
2048 75523882 : unsigned num_ops = gimple_num_ops (stmt);
2049 75523882 : gimple *copy = gimple_alloc (code, num_ops);
2050 75523882 : unsigned i;
2051 :
2052 : /* Shallow copy all the fields from STMT. */
2053 75523882 : memcpy (copy, stmt, gimple_size (code));
2054 75523882 : gimple_init_singleton (copy);
2055 :
2056 : /* If STMT has sub-statements, deep-copy them as well. */
2057 75523882 : if (gimple_has_substatements (stmt))
2058 : {
2059 42597 : gimple_seq new_seq;
2060 42597 : tree t;
2061 :
2062 42597 : switch (gimple_code (stmt))
2063 : {
2064 357 : case GIMPLE_BIND:
2065 357 : {
2066 357 : gbind *bind_stmt = as_a <gbind *> (stmt);
2067 357 : gbind *bind_copy = as_a <gbind *> (copy);
2068 357 : new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
2069 357 : gimple_bind_set_body (bind_copy, new_seq);
2070 357 : gimple_bind_set_vars (bind_copy,
2071 : unshare_expr (gimple_bind_vars (bind_stmt)));
2072 357 : gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
2073 : }
2074 357 : break;
2075 :
2076 17498 : case GIMPLE_CATCH:
2077 17498 : {
2078 17498 : gcatch *catch_stmt = as_a <gcatch *> (stmt);
2079 17498 : gcatch *catch_copy = as_a <gcatch *> (copy);
2080 17498 : new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
2081 17498 : gimple_catch_set_handler (catch_copy, new_seq);
2082 17498 : t = unshare_expr (gimple_catch_types (catch_stmt));
2083 17498 : gimple_catch_set_types (catch_copy, t);
2084 : }
2085 17498 : break;
2086 :
2087 0 : case GIMPLE_EH_FILTER:
2088 0 : {
2089 0 : geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
2090 0 : geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
2091 0 : new_seq
2092 0 : = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
2093 0 : gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
2094 0 : t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
2095 0 : gimple_eh_filter_set_types (eh_filter_copy, t);
2096 : }
2097 0 : break;
2098 :
2099 273 : case GIMPLE_EH_ELSE:
2100 273 : {
2101 273 : geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
2102 273 : geh_else *eh_else_copy = as_a <geh_else *> (copy);
2103 273 : new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
2104 273 : gimple_eh_else_set_n_body (eh_else_copy, new_seq);
2105 273 : new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
2106 273 : gimple_eh_else_set_e_body (eh_else_copy, new_seq);
2107 : }
2108 273 : break;
2109 :
2110 24187 : case GIMPLE_TRY:
2111 24187 : {
2112 24187 : gtry *try_stmt = as_a <gtry *> (stmt);
2113 24187 : gtry *try_copy = as_a <gtry *> (copy);
2114 24187 : new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
2115 24187 : gimple_try_set_eval (try_copy, new_seq);
2116 24187 : new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
2117 24187 : gimple_try_set_cleanup (try_copy, new_seq);
2118 : }
2119 24187 : break;
2120 :
2121 276 : case GIMPLE_OMP_FOR:
2122 276 : new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
2123 276 : gimple_omp_for_set_pre_body (copy, new_seq);
2124 276 : t = unshare_expr (gimple_omp_for_clauses (stmt));
2125 276 : gimple_omp_for_set_clauses (copy, t);
2126 276 : {
2127 276 : gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
2128 276 : omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
2129 276 : ( gimple_omp_for_collapse (stmt));
2130 : }
2131 564 : for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
2132 : {
2133 288 : gimple_omp_for_set_cond (copy, i,
2134 : gimple_omp_for_cond (stmt, i));
2135 288 : gimple_omp_for_set_index (copy, i,
2136 : gimple_omp_for_index (stmt, i));
2137 288 : t = unshare_expr (gimple_omp_for_initial (stmt, i));
2138 288 : gimple_omp_for_set_initial (copy, i, t);
2139 288 : t = unshare_expr (gimple_omp_for_final (stmt, i));
2140 288 : gimple_omp_for_set_final (copy, i, t);
2141 288 : t = unshare_expr (gimple_omp_for_incr (stmt, i));
2142 288 : gimple_omp_for_set_incr (copy, i, t);
2143 : }
2144 276 : goto copy_omp_body;
2145 :
2146 0 : case GIMPLE_OMP_PARALLEL:
2147 0 : {
2148 0 : gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
2149 0 : gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
2150 0 : t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
2151 0 : gimple_omp_parallel_set_clauses (omp_par_copy, t);
2152 0 : t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
2153 0 : gimple_omp_parallel_set_child_fn (omp_par_copy, t);
2154 0 : t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
2155 0 : gimple_omp_parallel_set_data_arg (omp_par_copy, t);
2156 : }
2157 0 : goto copy_omp_body;
2158 :
2159 0 : case GIMPLE_OMP_TASK:
2160 0 : t = unshare_expr (gimple_omp_task_clauses (stmt));
2161 0 : gimple_omp_task_set_clauses (copy, t);
2162 0 : t = unshare_expr (gimple_omp_task_child_fn (stmt));
2163 0 : gimple_omp_task_set_child_fn (copy, t);
2164 0 : t = unshare_expr (gimple_omp_task_data_arg (stmt));
2165 0 : gimple_omp_task_set_data_arg (copy, t);
2166 0 : t = unshare_expr (gimple_omp_task_copy_fn (stmt));
2167 0 : gimple_omp_task_set_copy_fn (copy, t);
2168 0 : t = unshare_expr (gimple_omp_task_arg_size (stmt));
2169 0 : gimple_omp_task_set_arg_size (copy, t);
2170 0 : t = unshare_expr (gimple_omp_task_arg_align (stmt));
2171 0 : gimple_omp_task_set_arg_align (copy, t);
2172 0 : goto copy_omp_body;
2173 :
2174 0 : case GIMPLE_OMP_CRITICAL:
2175 0 : t = unshare_expr (gimple_omp_critical_name
2176 0 : (as_a <gomp_critical *> (stmt)));
2177 0 : gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
2178 0 : t = unshare_expr (gimple_omp_critical_clauses
2179 0 : (as_a <gomp_critical *> (stmt)));
2180 0 : gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
2181 0 : goto copy_omp_body;
2182 :
2183 0 : case GIMPLE_OMP_ORDERED:
2184 0 : t = unshare_expr (gimple_omp_ordered_clauses
2185 0 : (as_a <gomp_ordered *> (stmt)));
2186 0 : gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
2187 0 : goto copy_omp_body;
2188 :
2189 0 : case GIMPLE_OMP_SCAN:
2190 0 : t = gimple_omp_scan_clauses (as_a <gomp_scan *> (stmt));
2191 0 : t = unshare_expr (t);
2192 0 : gimple_omp_scan_set_clauses (as_a <gomp_scan *> (copy), t);
2193 0 : goto copy_omp_body;
2194 :
2195 0 : case GIMPLE_OMP_TASKGROUP:
2196 0 : t = unshare_expr (gimple_omp_taskgroup_clauses (stmt));
2197 0 : gimple_omp_taskgroup_set_clauses (copy, t);
2198 0 : goto copy_omp_body;
2199 :
2200 0 : case GIMPLE_OMP_SECTIONS:
2201 0 : t = unshare_expr (gimple_omp_sections_clauses (stmt));
2202 0 : gimple_omp_sections_set_clauses (copy, t);
2203 0 : t = unshare_expr (gimple_omp_sections_control (stmt));
2204 0 : gimple_omp_sections_set_control (copy, t);
2205 0 : goto copy_omp_body;
2206 :
2207 0 : case GIMPLE_OMP_SINGLE:
2208 0 : {
2209 0 : gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
2210 0 : t = unshare_expr (gimple_omp_single_clauses (stmt));
2211 0 : gimple_omp_single_set_clauses (omp_single_copy, t);
2212 : }
2213 0 : goto copy_omp_body;
2214 :
2215 0 : case GIMPLE_OMP_SCOPE:
2216 0 : t = unshare_expr (gimple_omp_scope_clauses (stmt));
2217 0 : gimple_omp_scope_set_clauses (copy, t);
2218 0 : goto copy_omp_body;
2219 :
2220 0 : case GIMPLE_OMP_DISPATCH:
2221 0 : t = unshare_expr (gimple_omp_dispatch_clauses (stmt));
2222 0 : gimple_omp_dispatch_set_clauses (copy, t);
2223 0 : goto copy_omp_body;
2224 :
2225 0 : case GIMPLE_OMP_INTEROP:
2226 0 : t = unshare_expr (gimple_omp_interop_clauses (stmt));
2227 0 : gimple_omp_interop_set_clauses (copy, t);
2228 0 : break;
2229 :
2230 0 : case GIMPLE_OMP_TARGET:
2231 0 : {
2232 0 : gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
2233 0 : gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
2234 0 : t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
2235 0 : gimple_omp_target_set_clauses (omp_target_copy, t);
2236 0 : t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
2237 0 : gimple_omp_target_set_data_arg (omp_target_copy, t);
2238 : }
2239 0 : goto copy_omp_body;
2240 :
2241 0 : case GIMPLE_OMP_TEAMS:
2242 0 : {
2243 0 : gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
2244 0 : t = unshare_expr (gimple_omp_teams_clauses (stmt));
2245 0 : gimple_omp_teams_set_clauses (omp_teams_copy, t);
2246 : }
2247 : /* FALLTHRU */
2248 :
2249 276 : case GIMPLE_OMP_SECTION:
2250 276 : case GIMPLE_OMP_MASTER:
2251 276 : case GIMPLE_OMP_STRUCTURED_BLOCK:
2252 276 : copy_omp_body:
2253 276 : new_seq = gimple_seq_copy (gimple_omp_body (stmt));
2254 276 : gimple_omp_set_body (copy, new_seq);
2255 276 : break;
2256 :
2257 0 : case GIMPLE_OMP_MASKED:
2258 0 : t = unshare_expr (gimple_omp_masked_clauses (stmt));
2259 0 : gimple_omp_masked_set_clauses (copy, t);
2260 0 : goto copy_omp_body;
2261 :
2262 0 : case GIMPLE_ASSUME:
2263 0 : new_seq = gimple_seq_copy (gimple_assume_body (stmt));
2264 0 : *gimple_assume_body_ptr (copy) = new_seq;
2265 0 : gimple_assume_set_guard (copy,
2266 : unshare_expr (gimple_assume_guard (stmt)));
2267 0 : break;
2268 :
2269 6 : case GIMPLE_TRANSACTION:
2270 6 : new_seq = gimple_seq_copy (gimple_transaction_body (
2271 6 : as_a <gtransaction *> (stmt)));
2272 6 : gimple_transaction_set_body (as_a <gtransaction *> (copy),
2273 : new_seq);
2274 6 : break;
2275 :
2276 0 : case GIMPLE_WITH_CLEANUP_EXPR:
2277 0 : new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
2278 0 : gimple_wce_set_cleanup (copy, new_seq);
2279 0 : break;
2280 :
2281 0 : default:
2282 0 : gcc_unreachable ();
2283 : }
2284 : }
2285 :
2286 75523882 : switch (gimple_code (stmt))
2287 : {
2288 0 : case GIMPLE_OMP_ATOMIC_LOAD:
2289 0 : {
2290 0 : gomp_atomic_load *g = as_a <gomp_atomic_load *> (copy);
2291 0 : gimple_omp_atomic_load_set_lhs (g,
2292 : unshare_expr (gimple_omp_atomic_load_lhs (g)));
2293 0 : gimple_omp_atomic_load_set_rhs (g,
2294 : unshare_expr (gimple_omp_atomic_load_rhs (g)));
2295 0 : break;
2296 : }
2297 0 : case GIMPLE_OMP_ATOMIC_STORE:
2298 0 : {
2299 0 : gomp_atomic_store *g = as_a <gomp_atomic_store *> (copy);
2300 0 : gimple_omp_atomic_store_set_val (g,
2301 : unshare_expr (gimple_omp_atomic_store_val (g)));
2302 0 : break;
2303 : }
2304 : default:
2305 : break;
2306 : }
2307 :
2308 : /* Make copy of operands. */
2309 230369330 : for (i = 0; i < num_ops; i++)
2310 154845448 : gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
2311 :
2312 75523882 : if (gimple_has_mem_ops (stmt))
2313 : {
2314 34343277 : gimple_set_vdef (copy, gimple_vdef (stmt));
2315 34343277 : gimple_set_vuse (copy, gimple_vuse (stmt));
2316 : }
2317 :
2318 : /* Clear out SSA operand vectors on COPY. */
2319 75523882 : if (gimple_has_ops (stmt))
2320 : {
2321 75077656 : gimple_set_use_ops (copy, NULL);
2322 :
2323 : /* SSA operands need to be updated. */
2324 75077656 : gimple_set_modified (copy, true);
2325 : }
2326 :
2327 75523882 : if (gimple_debug_nonbind_marker_p (stmt))
2328 16701165 : cfun->debug_marker_count++;
2329 :
2330 75523882 : return copy;
2331 : }
2332 :
2333 : /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2334 : that OLD_STMT is about to be removed. */
2335 :
2336 : void
2337 748681 : gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
2338 : {
2339 748681 : tree vdef = gimple_vdef (old_stmt);
2340 1497362 : gimple_set_vuse (new_stmt, gimple_vuse (old_stmt));
2341 748681 : gimple_set_vdef (new_stmt, vdef);
2342 748681 : if (vdef && TREE_CODE (vdef) == SSA_NAME)
2343 261201 : SSA_NAME_DEF_STMT (vdef) = new_stmt;
2344 748681 : }
2345 :
2346 : /* Return true if statement S has side-effects. We consider a
2347 : statement to have side effects if:
2348 :
2349 : - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2350 : - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2351 :
2352 : bool
2353 888007796 : gimple_has_side_effects (const gimple *s)
2354 : {
2355 888007796 : if (is_gimple_debug (s))
2356 : return false;
2357 :
2358 : /* We don't have to scan the arguments to check for
2359 : volatile arguments, though, at present, we still
2360 : do a scan to check for TREE_SIDE_EFFECTS. */
2361 1334658787 : if (gimple_has_volatile_ops (s))
2362 : return true;
2363 :
2364 670956858 : if (gimple_code (s) == GIMPLE_ASM
2365 670956858 : && gimple_asm_volatile_p (as_a <const gasm *> (s)))
2366 : return true;
2367 :
2368 670422121 : if (is_gimple_call (s))
2369 : {
2370 95776924 : int flags = gimple_call_flags (s);
2371 :
2372 : /* An infinite loop is considered a side effect. */
2373 95776924 : if (!(flags & (ECF_CONST | ECF_PURE))
2374 19073123 : || (flags & ECF_LOOPING_CONST_OR_PURE))
2375 : return true;
2376 :
2377 16945781 : return false;
2378 : }
2379 :
2380 : return false;
2381 : }
2382 :
2383 : /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2384 : Return true if S can trap. When INCLUDE_MEM is true, check whether
2385 : the memory operations could trap. When INCLUDE_STORES is true, also
2386 : check a memory LHS with store semantics. */
2387 :
2388 : bool
2389 76805569 : gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores)
2390 : {
2391 76805569 : tree t, div = NULL_TREE;
2392 76805569 : enum tree_code op;
2393 :
2394 76805569 : if (include_mem)
2395 : {
2396 51973737 : unsigned i, start = 0;
2397 :
2398 : /* Use store semantics for the LHS. A call marked for return-slot
2399 : optimization can still use a temporary and a caller-side copy. */
2400 51973737 : if (include_stores
2401 47699287 : && gimple_store_p (s)
2402 56694732 : && lhs_could_trap_p (gimple_get_lhs (s)))
2403 : return true;
2404 :
2405 52301435 : if (gimple_has_lhs (s))
2406 51400824 : start = 1;
2407 :
2408 132990327 : for (i = start; i < gimple_num_ops (s); i++)
2409 86334581 : if (tree_could_trap_p (gimple_op (s, i)))
2410 : return true;
2411 : }
2412 :
2413 71487578 : switch (gimple_code (s))
2414 : {
2415 10396 : case GIMPLE_ASM:
2416 10396 : return gimple_asm_volatile_p (as_a <const gasm *> (s));
2417 :
2418 1590914 : case GIMPLE_CALL:
2419 1590914 : {
2420 1590914 : if (gimple_call_internal_p (s))
2421 : return false;
2422 1374744 : t = gimple_call_fndecl (s);
2423 : /* Assume that indirect and calls to weak functions may trap. */
2424 1374744 : if (!t || !DECL_P (t) || DECL_WEAK (t))
2425 : return true;
2426 :
2427 : /* Any floating point builtin operation could trap. */
2428 1348639 : if (gimple_call_builtin_p (s))
2429 : {
2430 988278 : if (fndecl_built_in_p (t, BUILT_IN_NORMAL))
2431 882533 : switch (DECL_FUNCTION_CODE (t))
2432 : {
2433 : CASE_FLT_FN (BUILT_IN_COPYSIGN):
2434 : CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN):
2435 : return false;
2436 : default:
2437 : break;
2438 : }
2439 938034 : tree type = TREE_TYPE (gimple_call_fntype (s));
2440 938034 : bool fp_operation = FLOAT_TYPE_P (type);
2441 51064 : return fp_operation && flag_trapping_math;
2442 : }
2443 : return false;
2444 : }
2445 58705280 : case GIMPLE_ASSIGN:
2446 58705280 : op = gimple_assign_rhs_code (s);
2447 :
2448 : /* COND_EXPR does not trap. */
2449 58705280 : if (op == COND_EXPR)
2450 : return false;
2451 :
2452 : /* For comparisons we need to check rhs operand types instead of lhs type
2453 : (which is BOOLEAN_TYPE). */
2454 58607113 : if (TREE_CODE_CLASS (op) == tcc_comparison)
2455 2773835 : t = TREE_TYPE (gimple_assign_rhs1 (s));
2456 : else
2457 55833278 : t = TREE_TYPE (gimple_assign_lhs (s));
2458 :
2459 58607113 : if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
2460 35501758 : div = gimple_assign_rhs2 (s);
2461 :
2462 61763050 : return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2463 58607113 : (INTEGRAL_TYPE_P (t)
2464 44725759 : && TYPE_OVERFLOW_TRAPS (t)),
2465 58607113 : div));
2466 :
2467 6395254 : case GIMPLE_COND:
2468 6395254 : t = TREE_TYPE (gimple_cond_lhs (s));
2469 6395254 : return operation_could_trap_p (gimple_cond_code (s),
2470 12790508 : FLOAT_TYPE_P (t), false, NULL_TREE);
2471 :
2472 : default:
2473 : break;
2474 : }
2475 :
2476 : return false;
2477 : }
2478 :
2479 : /* Return true if statement S can trap. */
2480 :
2481 : bool
2482 47699287 : gimple_could_trap_p (const gimple *s)
2483 : {
2484 47699287 : return gimple_could_trap_p_1 (s, true, true);
2485 : }
2486 :
2487 : /* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2488 :
2489 : bool
2490 3301654 : gimple_assign_rhs_could_trap_p (gimple *s)
2491 : {
2492 3301654 : gcc_assert (is_gimple_assign (s));
2493 3301654 : return gimple_could_trap_p_1 (s, true, false);
2494 : }
2495 :
2496 :
2497 : /* Print debugging information for gimple stmts generated. */
2498 :
2499 : void
2500 0 : dump_gimple_statistics (void)
2501 : {
2502 0 : int i;
2503 0 : uint64_t total_tuples = 0, total_bytes = 0;
2504 :
2505 0 : if (! GATHER_STATISTICS)
2506 : {
2507 0 : fprintf (stderr, "No GIMPLE statistics\n");
2508 0 : return;
2509 : }
2510 :
2511 : fprintf (stderr, "\nGIMPLE statements\n");
2512 : fprintf (stderr, "Kind Stmts Bytes\n");
2513 : fprintf (stderr, "---------------------------------------\n");
2514 : for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2515 : {
2516 : fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
2517 : gimple_alloc_kind_names[i],
2518 : SIZE_AMOUNT (gimple_alloc_counts[i]),
2519 : SIZE_AMOUNT (gimple_alloc_sizes[i]));
2520 : total_tuples += gimple_alloc_counts[i];
2521 : total_bytes += gimple_alloc_sizes[i];
2522 : }
2523 : fprintf (stderr, "---------------------------------------\n");
2524 : fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
2525 : SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
2526 : fprintf (stderr, "---------------------------------------\n");
2527 : }
2528 :
2529 :
2530 : /* Return the number of operands needed on the RHS of a GIMPLE
2531 : assignment for an expression with tree code CODE. */
2532 :
2533 : unsigned
2534 103494227 : get_gimple_rhs_num_ops (enum tree_code code)
2535 : {
2536 103494227 : switch (get_gimple_rhs_class (code))
2537 : {
2538 : case GIMPLE_UNARY_RHS:
2539 : case GIMPLE_SINGLE_RHS:
2540 : return 1;
2541 : case GIMPLE_BINARY_RHS:
2542 : return 2;
2543 : case GIMPLE_TERNARY_RHS:
2544 : return 3;
2545 0 : default:
2546 0 : gcc_unreachable ();
2547 : }
2548 : }
2549 :
2550 : #define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2551 : (unsigned char) \
2552 : ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2553 : : ((TYPE) == tcc_binary \
2554 : || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2555 : : ((TYPE) == tcc_constant \
2556 : || (TYPE) == tcc_declaration \
2557 : || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2558 : : ((SYM) == TRUTH_AND_EXPR \
2559 : || (SYM) == TRUTH_OR_EXPR \
2560 : || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2561 : : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2562 : : ((SYM) == COND_EXPR \
2563 : || (SYM) == WIDEN_MULT_PLUS_EXPR \
2564 : || (SYM) == WIDEN_MULT_MINUS_EXPR \
2565 : || (SYM) == DOT_PROD_EXPR \
2566 : || (SYM) == SAD_EXPR \
2567 : || (SYM) == REALIGN_LOAD_EXPR \
2568 : || (SYM) == VEC_COND_EXPR \
2569 : || (SYM) == VEC_PERM_EXPR \
2570 : || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2571 : : ((SYM) == CONSTRUCTOR \
2572 : || (SYM) == OBJ_TYPE_REF \
2573 : || (SYM) == ADDR_EXPR \
2574 : || (SYM) == WITH_SIZE_EXPR \
2575 : || (SYM) == SSA_NAME \
2576 : || (SYM) == OMP_NEXT_VARIANT \
2577 : || (SYM) == OMP_TARGET_DEVICE_MATCHES) ? GIMPLE_SINGLE_RHS \
2578 : : GIMPLE_INVALID_RHS),
2579 : #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2580 :
2581 : const unsigned char gimple_rhs_class_table[] = {
2582 : #include "all-tree.def"
2583 : };
2584 :
2585 : #undef DEFTREECODE
2586 : #undef END_OF_BASE_TREE_CODES
2587 :
2588 : /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2589 : the positions marked by the set ARGS_TO_SKIP. */
2590 :
2591 : gcall *
2592 0 : gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2593 : {
2594 0 : int i;
2595 0 : int nargs = gimple_call_num_args (stmt);
2596 0 : auto_vec<tree> vargs (nargs);
2597 0 : gcall *new_stmt;
2598 :
2599 0 : for (i = 0; i < nargs; i++)
2600 0 : if (!bitmap_bit_p (args_to_skip, i))
2601 0 : vargs.quick_push (gimple_call_arg (stmt, i));
2602 :
2603 0 : if (gimple_call_internal_p (stmt))
2604 0 : new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2605 : vargs);
2606 : else
2607 0 : new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2608 :
2609 0 : if (gimple_call_lhs (stmt))
2610 0 : gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2611 :
2612 0 : gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2613 0 : gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2614 :
2615 0 : if (gimple_has_location (stmt))
2616 0 : gimple_set_location (new_stmt, gimple_location (stmt));
2617 0 : gimple_call_copy_flags (new_stmt, stmt);
2618 0 : gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2619 :
2620 0 : gimple_set_modified (new_stmt, true);
2621 :
2622 0 : return new_stmt;
2623 0 : }
2624 :
2625 :
2626 :
2627 : /* Return true if the field decls F1 and F2 are at the same offset.
2628 :
2629 : This is intended to be used on GIMPLE types only. */
2630 :
2631 : bool
2632 62659827 : gimple_compare_field_offset (tree f1, tree f2)
2633 : {
2634 62659827 : if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2635 : {
2636 62659764 : tree offset1 = DECL_FIELD_OFFSET (f1);
2637 62659764 : tree offset2 = DECL_FIELD_OFFSET (f2);
2638 62659764 : return ((offset1 == offset2
2639 : /* Once gimplification is done, self-referential offsets are
2640 : instantiated as operand #2 of the COMPONENT_REF built for
2641 : each access and reset. Therefore, they are not relevant
2642 : anymore and fields are interchangeable provided that they
2643 : represent the same access. */
2644 0 : || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2645 0 : && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2646 0 : && (DECL_SIZE (f1) == DECL_SIZE (f2)
2647 0 : || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2648 0 : && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2649 0 : || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2650 0 : && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2651 0 : || operand_equal_p (offset1, offset2, 0))
2652 125319528 : && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2653 62659764 : DECL_FIELD_BIT_OFFSET (f2)));
2654 : }
2655 :
2656 : /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2657 : should be, so handle differing ones specially by decomposing
2658 : the offset into a byte and bit offset manually. */
2659 63 : if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2660 63 : && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2661 : {
2662 63 : unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2663 63 : unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2664 63 : bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2665 63 : byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2666 63 : + bit_offset1 / BITS_PER_UNIT);
2667 63 : bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2668 63 : byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2669 63 : + bit_offset2 / BITS_PER_UNIT);
2670 63 : if (byte_offset1 != byte_offset2)
2671 : return false;
2672 63 : return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2673 : }
2674 :
2675 : return false;
2676 : }
2677 :
2678 :
2679 : /* Return a type the same as TYPE except unsigned or
2680 : signed according to UNSIGNEDP. */
2681 :
2682 : static tree
2683 606993 : gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2684 : {
2685 606993 : tree type1;
2686 606993 : int i;
2687 :
2688 606993 : type1 = TYPE_MAIN_VARIANT (type);
2689 606993 : if (type1 == signed_char_type_node
2690 606993 : || type1 == char_type_node
2691 606993 : || type1 == unsigned_char_type_node)
2692 0 : return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2693 606993 : if (type1 == integer_type_node || type1 == unsigned_type_node)
2694 352679 : return unsignedp ? unsigned_type_node : integer_type_node;
2695 254314 : if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2696 232533 : return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2697 21781 : if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2698 30 : return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2699 21751 : if (type1 == long_long_integer_type_node
2700 21662 : || type1 == long_long_unsigned_type_node)
2701 89 : return unsignedp
2702 89 : ? long_long_unsigned_type_node
2703 0 : : long_long_integer_type_node;
2704 :
2705 35893 : for (i = 0; i < NUM_INT_N_ENTS; i ++)
2706 21662 : if (int_n_enabled_p[i]
2707 21662 : && (type1 == int_n_trees[i].unsigned_type
2708 14603 : || type1 == int_n_trees[i].signed_type))
2709 7431 : return unsignedp
2710 7431 : ? int_n_trees[i].unsigned_type
2711 7431 : : int_n_trees[i].signed_type;
2712 :
2713 : #if HOST_BITS_PER_WIDE_INT >= 64
2714 14231 : if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2715 0 : return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2716 : #endif
2717 14231 : if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2718 0 : return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2719 14231 : if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2720 0 : return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2721 14231 : if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2722 0 : return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2723 14231 : if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2724 0 : return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2725 :
2726 : #define GIMPLE_FIXED_TYPES(NAME) \
2727 : if (type1 == short_ ## NAME ## _type_node \
2728 : || type1 == unsigned_short_ ## NAME ## _type_node) \
2729 : return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2730 : : short_ ## NAME ## _type_node; \
2731 : if (type1 == NAME ## _type_node \
2732 : || type1 == unsigned_ ## NAME ## _type_node) \
2733 : return unsignedp ? unsigned_ ## NAME ## _type_node \
2734 : : NAME ## _type_node; \
2735 : if (type1 == long_ ## NAME ## _type_node \
2736 : || type1 == unsigned_long_ ## NAME ## _type_node) \
2737 : return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2738 : : long_ ## NAME ## _type_node; \
2739 : if (type1 == long_long_ ## NAME ## _type_node \
2740 : || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2741 : return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2742 : : long_long_ ## NAME ## _type_node;
2743 :
2744 : #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2745 : if (type1 == NAME ## _type_node \
2746 : || type1 == u ## NAME ## _type_node) \
2747 : return unsignedp ? u ## NAME ## _type_node \
2748 : : NAME ## _type_node;
2749 :
2750 : #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2751 : if (type1 == sat_ ## short_ ## NAME ## _type_node \
2752 : || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2753 : return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2754 : : sat_ ## short_ ## NAME ## _type_node; \
2755 : if (type1 == sat_ ## NAME ## _type_node \
2756 : || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2757 : return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2758 : : sat_ ## NAME ## _type_node; \
2759 : if (type1 == sat_ ## long_ ## NAME ## _type_node \
2760 : || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2761 : return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2762 : : sat_ ## long_ ## NAME ## _type_node; \
2763 : if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2764 : || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2765 : return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2766 : : sat_ ## long_long_ ## NAME ## _type_node;
2767 :
2768 : #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2769 : if (type1 == sat_ ## NAME ## _type_node \
2770 : || type1 == sat_ ## u ## NAME ## _type_node) \
2771 : return unsignedp ? sat_ ## u ## NAME ## _type_node \
2772 : : sat_ ## NAME ## _type_node;
2773 :
2774 14231 : GIMPLE_FIXED_TYPES (fract);
2775 14231 : GIMPLE_FIXED_TYPES_SAT (fract);
2776 14231 : GIMPLE_FIXED_TYPES (accum);
2777 14231 : GIMPLE_FIXED_TYPES_SAT (accum);
2778 :
2779 14231 : GIMPLE_FIXED_MODE_TYPES (qq);
2780 14231 : GIMPLE_FIXED_MODE_TYPES (hq);
2781 14231 : GIMPLE_FIXED_MODE_TYPES (sq);
2782 14231 : GIMPLE_FIXED_MODE_TYPES (dq);
2783 14231 : GIMPLE_FIXED_MODE_TYPES (tq);
2784 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2785 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2786 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2787 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2788 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2789 14231 : GIMPLE_FIXED_MODE_TYPES (ha);
2790 14231 : GIMPLE_FIXED_MODE_TYPES (sa);
2791 14231 : GIMPLE_FIXED_MODE_TYPES (da);
2792 14231 : GIMPLE_FIXED_MODE_TYPES (ta);
2793 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2794 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2795 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (da);
2796 14231 : GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2797 :
2798 : /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2799 : the precision; they have precision set to match their range, but
2800 : may use a wider mode to match an ABI. If we change modes, we may
2801 : wind up with bad conversions. For INTEGER_TYPEs in C, must check
2802 : the precision as well, so as to yield correct results for
2803 : bit-field types. C++ does not have these separate bit-field
2804 : types, and producing a signed or unsigned variant of an
2805 : ENUMERAL_TYPE may cause other problems as well. */
2806 14231 : if (!INTEGRAL_TYPE_P (type)
2807 14231 : || TYPE_UNSIGNED (type) == unsignedp)
2808 : return type;
2809 :
2810 : #define TYPE_OK(node) \
2811 : (TYPE_MODE (type) == TYPE_MODE (node) \
2812 : && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2813 14231 : if (TYPE_OK (signed_char_type_node))
2814 461 : return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2815 13770 : if (TYPE_OK (integer_type_node))
2816 3513 : return unsignedp ? unsigned_type_node : integer_type_node;
2817 10257 : if (TYPE_OK (short_integer_type_node))
2818 4752 : return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2819 5505 : if (TYPE_OK (long_integer_type_node))
2820 6 : return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2821 5499 : if (TYPE_OK (long_long_integer_type_node))
2822 0 : return (unsignedp
2823 0 : ? long_long_unsigned_type_node
2824 0 : : long_long_integer_type_node);
2825 :
2826 10971 : for (i = 0; i < NUM_INT_N_ENTS; i ++)
2827 5499 : if (int_n_enabled_p[i]
2828 5499 : && TYPE_MODE (type) == int_n_data[i].m
2829 5526 : && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2830 27 : return unsignedp
2831 27 : ? int_n_trees[i].unsigned_type
2832 27 : : int_n_trees[i].signed_type;
2833 :
2834 : #if HOST_BITS_PER_WIDE_INT >= 64
2835 5472 : if (TYPE_OK (intTI_type_node))
2836 0 : return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2837 : #endif
2838 5472 : if (TYPE_OK (intDI_type_node))
2839 0 : return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2840 5472 : if (TYPE_OK (intSI_type_node))
2841 0 : return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2842 5472 : if (TYPE_OK (intHI_type_node))
2843 0 : return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2844 5472 : if (TYPE_OK (intQI_type_node))
2845 0 : return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2846 :
2847 : #undef GIMPLE_FIXED_TYPES
2848 : #undef GIMPLE_FIXED_MODE_TYPES
2849 : #undef GIMPLE_FIXED_TYPES_SAT
2850 : #undef GIMPLE_FIXED_MODE_TYPES_SAT
2851 : #undef TYPE_OK
2852 :
2853 5472 : return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2854 : }
2855 :
2856 :
2857 : /* Return an unsigned type the same as TYPE in other respects. */
2858 :
2859 : tree
2860 0 : gimple_unsigned_type (tree type)
2861 : {
2862 0 : return gimple_signed_or_unsigned_type (true, type);
2863 : }
2864 :
2865 :
2866 : /* Return a signed type the same as TYPE in other respects. */
2867 :
2868 : tree
2869 606993 : gimple_signed_type (tree type)
2870 : {
2871 606993 : return gimple_signed_or_unsigned_type (false, type);
2872 : }
2873 :
2874 :
2875 : /* Return the typed-based alias set for T, which may be an expression
2876 : or a type. Return -1 if we don't do anything special. */
2877 :
2878 : alias_set_type
2879 8691961 : gimple_get_alias_set (tree t)
2880 : {
2881 : /* That's all the expressions we handle specially. */
2882 8691961 : if (!TYPE_P (t))
2883 : return -1;
2884 :
2885 : /* For convenience, follow the C standard when dealing with
2886 : character types. Any object may be accessed via an lvalue that
2887 : has character type. */
2888 2462906 : if (t == char_type_node
2889 1924512 : || t == signed_char_type_node
2890 1924512 : || t == unsigned_char_type_node)
2891 : return 0;
2892 :
2893 : /* Allow aliasing between signed and unsigned variants of the same
2894 : type. We treat the signed variant as canonical. */
2895 1924512 : if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2896 : {
2897 606085 : tree t1 = gimple_signed_type (t);
2898 :
2899 : /* t1 == t can happen for boolean nodes which are always unsigned. */
2900 606085 : if (t1 != t)
2901 606085 : return get_alias_set (t1);
2902 : }
2903 :
2904 : /* Allow aliasing between enumeral types and the underlying
2905 : integer type. This is required for C since those are
2906 : compatible types. */
2907 1318427 : else if (TREE_CODE (t) == ENUMERAL_TYPE)
2908 : {
2909 0 : tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
2910 : false /* short-cut above */);
2911 0 : return get_alias_set (t1);
2912 : }
2913 :
2914 : return -1;
2915 : }
2916 :
2917 :
2918 : /* Helper for gimple_ior_addresses_taken_1. */
2919 :
2920 : static bool
2921 54941131 : gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2922 : {
2923 54941131 : bitmap addresses_taken = (bitmap)data;
2924 54941131 : addr = get_base_address (addr);
2925 54941131 : if (addr
2926 54941131 : && DECL_P (addr))
2927 : {
2928 34853052 : bitmap_set_bit (addresses_taken, DECL_UID (addr));
2929 34853052 : return true;
2930 : }
2931 : return false;
2932 : }
2933 :
2934 : /* Set the bit for the uid of all decls that have their address taken
2935 : in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2936 : were any in this stmt. */
2937 :
2938 : bool
2939 892403338 : gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2940 : {
2941 892403338 : return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2942 892403338 : gimple_ior_addresses_taken_1);
2943 : }
2944 :
2945 :
2946 : /* Return true when STMTs arguments and return value match those of FNDECL,
2947 : a decl of a builtin function. */
2948 :
2949 : bool
2950 288699190 : gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2951 : {
2952 288699190 : gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2953 :
2954 288699190 : if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2955 286320082 : if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
2956 288699190 : fndecl = decl;
2957 :
2958 288699190 : tree ret = gimple_call_lhs (stmt);
2959 288699190 : if (ret
2960 465115540 : && !useless_type_conversion_p (TREE_TYPE (ret),
2961 176416350 : TREE_TYPE (TREE_TYPE (fndecl))))
2962 : return false;
2963 :
2964 288677207 : tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2965 288677207 : unsigned nargs = gimple_call_num_args (stmt);
2966 1184485204 : for (unsigned i = 0; i < nargs; ++i)
2967 : {
2968 : /* Variadic args follow. */
2969 640319868 : if (!targs)
2970 : return true;
2971 612146615 : tree arg = gimple_call_arg (stmt, i);
2972 612146615 : tree type = TREE_VALUE (targs);
2973 612146615 : if (!useless_type_conversion_p (type, TREE_TYPE (arg)))
2974 : return false;
2975 607130790 : targs = TREE_CHAIN (targs);
2976 : }
2977 510156306 : if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2978 7153 : return false;
2979 : return true;
2980 : }
2981 :
2982 : /* Return true when STMT is operator a replaceable delete call. */
2983 :
2984 : bool
2985 2683588 : gimple_call_operator_delete_p (const gcall *stmt)
2986 : {
2987 2683588 : tree fndecl;
2988 :
2989 2683588 : if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
2990 2683588 : return DECL_IS_OPERATOR_DELETE_P (fndecl);
2991 : return false;
2992 : }
2993 :
2994 : /* Return true when STMT is builtins call. */
2995 :
2996 : bool
2997 70778227 : gimple_call_builtin_p (const gimple *stmt)
2998 : {
2999 70778227 : tree fndecl;
3000 70778227 : if (is_gimple_call (stmt)
3001 22251427 : && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
3002 91767369 : && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
3003 4959410 : return gimple_builtin_call_types_compatible_p (stmt, fndecl);
3004 : return false;
3005 : }
3006 :
3007 : /* Return true when STMT is builtins call to CLASS. */
3008 :
3009 : bool
3010 1039617259 : gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
3011 : {
3012 1039617259 : tree fndecl;
3013 1039617259 : if (is_gimple_call (stmt)
3014 789825041 : && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
3015 1791860931 : && DECL_BUILT_IN_CLASS (fndecl) == klass)
3016 194537408 : return gimple_builtin_call_types_compatible_p (stmt, fndecl);
3017 : return false;
3018 : }
3019 :
3020 : /* Return true when STMT is builtins call to CODE of CLASS. */
3021 :
3022 : bool
3023 3004478290 : gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
3024 : {
3025 3004478290 : tree fndecl;
3026 3004478290 : if (is_gimple_call (stmt)
3027 893427052 : && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
3028 3854808894 : && fndecl_built_in_p (fndecl, code))
3029 2645254 : return gimple_builtin_call_types_compatible_p (stmt, fndecl);
3030 : return false;
3031 : }
3032 :
3033 : /* If CALL is a call to a combined_fn (i.e. an internal function or
3034 : a normal built-in function), return its code, otherwise return
3035 : CFN_LAST. */
3036 :
3037 : combined_fn
3038 184403833 : gimple_call_combined_fn (const gimple *stmt)
3039 : {
3040 184403833 : if (const gcall *call = dyn_cast <const gcall *> (stmt))
3041 : {
3042 184193055 : if (gimple_call_internal_p (call))
3043 8815290 : return as_combined_fn (gimple_call_internal_fn (call));
3044 :
3045 175377765 : tree fndecl = gimple_call_fndecl (stmt);
3046 175377765 : if (fndecl
3047 169172775 : && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
3048 244473038 : && gimple_builtin_call_types_compatible_p (stmt, fndecl))
3049 68537143 : return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
3050 : }
3051 : return CFN_LAST;
3052 : }
3053 :
3054 : /* Return true if STMT clobbers memory. STMT is required to be a
3055 : GIMPLE_ASM. */
3056 :
3057 : bool
3058 10685896 : gimple_asm_clobbers_memory_p (const gasm *stmt)
3059 : {
3060 10685896 : unsigned i;
3061 :
3062 14749530 : for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
3063 : {
3064 8406003 : tree op = gimple_asm_clobber_op (stmt, i);
3065 8406003 : if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
3066 : return true;
3067 : }
3068 :
3069 : /* Non-empty basic ASM implicitly clobbers memory. */
3070 6343527 : if (gimple_asm_basic_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
3071 78532 : return true;
3072 :
3073 : return false;
3074 : }
3075 :
3076 : /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
3077 :
3078 : void
3079 5338 : dump_decl_set (FILE *file, bitmap set)
3080 : {
3081 5338 : if (set)
3082 : {
3083 5338 : bitmap_iterator bi;
3084 5338 : unsigned i;
3085 :
3086 5338 : fprintf (file, "{ ");
3087 :
3088 22230 : EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
3089 : {
3090 16892 : fprintf (file, "D.%u", i);
3091 16892 : fprintf (file, " ");
3092 : }
3093 :
3094 5338 : fprintf (file, "}");
3095 : }
3096 : else
3097 0 : fprintf (file, "NIL");
3098 5338 : }
3099 :
3100 : /* Return true when CALL is a call stmt that definitely doesn't
3101 : free any memory or makes it unavailable otherwise. */
3102 : bool
3103 10113742 : nonfreeing_call_p (gimple *call)
3104 : {
3105 10113742 : if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
3106 10113742 : && gimple_call_flags (call) & ECF_LEAF)
3107 4425912 : switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
3108 : {
3109 : /* Just in case these become ECF_LEAF in the future. */
3110 : case BUILT_IN_FREE:
3111 : case BUILT_IN_TM_FREE:
3112 : case BUILT_IN_REALLOC:
3113 : case BUILT_IN_STACK_RESTORE:
3114 : case BUILT_IN_GOMP_FREE:
3115 : case BUILT_IN_GOMP_REALLOC:
3116 : return false;
3117 4224402 : default:
3118 4224402 : return true;
3119 : }
3120 5687830 : else if (gimple_call_internal_p (call))
3121 772908 : switch (gimple_call_internal_fn (call))
3122 : {
3123 : case IFN_ABNORMAL_DISPATCHER:
3124 : return true;
3125 35675 : case IFN_ASAN_MARK:
3126 35675 : return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
3127 731227 : default:
3128 731227 : if (gimple_call_flags (call) & ECF_LEAF)
3129 : return true;
3130 148466 : return false;
3131 : }
3132 :
3133 4914922 : tree fndecl = gimple_call_fndecl (call);
3134 4914922 : if (!fndecl)
3135 : return false;
3136 4753367 : struct cgraph_node *n = cgraph_node::get (fndecl);
3137 4753367 : if (!n)
3138 : return false;
3139 4751989 : enum availability availability;
3140 4751989 : n = n->function_symbol (&availability);
3141 4751989 : if (!n || availability <= AVAIL_INTERPOSABLE)
3142 : return false;
3143 1151865 : return n->nonfreeing_fn;
3144 : }
3145 :
3146 : /* Return true when CALL is a call stmt that definitely need not
3147 : be considered to be a memory barrier. */
3148 : bool
3149 1665143 : nonbarrier_call_p (gimple *call)
3150 : {
3151 1665143 : if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
3152 650011 : return true;
3153 : /* Should extend this to have a nonbarrier_fn flag, just as above in
3154 : the nonfreeing case. */
3155 : return false;
3156 : }
3157 :
3158 : /* Callback for walk_stmt_load_store_ops.
3159 :
3160 : Return TRUE if OP will dereference the tree stored in DATA, FALSE
3161 : otherwise.
3162 :
3163 : This routine only makes a superficial check for a dereference. Thus
3164 : it must only be used if it is safe to return a false negative. */
3165 : static bool
3166 77734473 : check_loadstore (gimple *stmt, tree op, tree, void *data)
3167 : {
3168 155468946 : if (TREE_CODE (op) == MEM_REF
3169 77734473 : || (TREE_CODE (op) == TARGET_MEM_REF
3170 1375573 : && !TMR_INDEX2 (op)
3171 1359262 : && (!TMR_INDEX (op)
3172 645467 : || (TMR_STEP (op)
3173 585831 : && expr_not_equal_to (TMR_STEP (op),
3174 78320304 : wi::one (TYPE_PRECISION (TREE_TYPE
3175 : (TMR_STEP (op)))),
3176 : stmt)))))
3177 : {
3178 : /* Some address spaces may legitimately dereference zero. */
3179 40243813 : addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
3180 40243813 : if (targetm.addr_space.zero_address_valid (as))
3181 : return false;
3182 :
3183 40242709 : return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
3184 : }
3185 : return false;
3186 : }
3187 :
3188 :
3189 : /* Return true if OP can be inferred to be non-NULL after STMT executes,
3190 : either by using a pointer dereference or attributes. */
3191 : bool
3192 0 : infer_nonnull_range (gimple *stmt, tree op)
3193 : {
3194 0 : return (infer_nonnull_range_by_dereference (stmt, op)
3195 0 : || infer_nonnull_range_by_attribute (stmt, op));
3196 : }
3197 :
3198 : /* Return true if OP can be inferred to be non-NULL after STMT
3199 : executes by using a pointer dereference. */
3200 : bool
3201 347709657 : infer_nonnull_range_by_dereference (gimple *stmt, tree op)
3202 : {
3203 : /* We can only assume that a pointer dereference will yield
3204 : non-NULL if -fdelete-null-pointer-checks is enabled. */
3205 347709657 : if (!flag_delete_null_pointer_checks
3206 347495430 : || !POINTER_TYPE_P (TREE_TYPE (op))
3207 347495430 : || gimple_code (stmt) == GIMPLE_ASM
3208 694779854 : || gimple_clobber_p (stmt))
3209 : return false;
3210 :
3211 339776396 : if (walk_stmt_load_store_ops (stmt, (void *)op,
3212 : check_loadstore, check_loadstore))
3213 : return true;
3214 :
3215 : return false;
3216 : }
3217 :
3218 : /* Return true if OP can be inferred to be a non-NULL after STMT
3219 : executes by using attributes. If OP2 and OP3 are non-NULL and
3220 : nonnull_if_nonzero is the only attribute implying OP being non-NULL
3221 : and the corresponding argument(s) aren't non-zero INTEGER_CST, set *OP2
3222 : and *OP3 to the corresponding arguments and return true (in that case
3223 : returning true doesn't mean OP can be unconditionally inferred to be
3224 : non-NULL, but conditionally). */
3225 : bool
3226 79125741 : infer_nonnull_range_by_attribute (gimple *stmt, tree op, tree *op2, tree *op3)
3227 : {
3228 79125741 : if (op2)
3229 : {
3230 3934 : *op2 = NULL_TREE;
3231 3934 : *op3 = NULL_TREE;
3232 : }
3233 :
3234 : /* We can only assume that a pointer dereference will yield
3235 : non-NULL if -fdelete-null-pointer-checks is enabled. */
3236 79125741 : if (!flag_delete_null_pointer_checks
3237 79096986 : || !POINTER_TYPE_P (TREE_TYPE (op))
3238 158222727 : || gimple_code (stmt) == GIMPLE_ASM)
3239 : return false;
3240 :
3241 79046670 : if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
3242 : {
3243 4505431 : tree fntype = gimple_call_fntype (stmt);
3244 4505431 : tree attrs = TYPE_ATTRIBUTES (fntype);
3245 4602944 : for (; attrs; attrs = TREE_CHAIN (attrs))
3246 : {
3247 1176699 : attrs = lookup_attribute ("nonnull", attrs);
3248 :
3249 : /* If "nonnull" wasn't specified, we know nothing about
3250 : the argument, unless "nonnull_if_nonzero" attribute is
3251 : present. */
3252 1176699 : if (attrs == NULL_TREE)
3253 : break;
3254 :
3255 : /* If "nonnull" applies to all the arguments, then ARG
3256 : is non-null if it's in the argument list. */
3257 256814 : if (TREE_VALUE (attrs) == NULL_TREE)
3258 : {
3259 462503 : for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
3260 : {
3261 312086 : if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
3262 304410 : && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
3263 : return true;
3264 : }
3265 : return false;
3266 : }
3267 :
3268 : /* Now see if op appears in the nonnull list. */
3269 245774 : for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
3270 : {
3271 148261 : unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
3272 148261 : if (idx < gimple_call_num_args (stmt))
3273 : {
3274 148260 : tree arg = gimple_call_arg (stmt, idx);
3275 148260 : if (operand_equal_p (op, arg, 0))
3276 : return true;
3277 : }
3278 : }
3279 : }
3280 :
3281 4346130 : for (attrs = TYPE_ATTRIBUTES (fntype);
3282 4550628 : (attrs = lookup_attribute ("nonnull_if_nonzero", attrs));
3283 204498 : attrs = TREE_CHAIN (attrs))
3284 : {
3285 205301 : tree args = TREE_VALUE (attrs);
3286 205301 : unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
3287 205301 : unsigned int idx2
3288 205301 : = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
3289 205301 : unsigned int idx3 = idx2;
3290 205301 : if (tree chain2 = TREE_CHAIN (TREE_CHAIN (args)))
3291 4348 : idx3 = TREE_INT_CST_LOW (TREE_VALUE (chain2)) - 1;
3292 205301 : if (idx < gimple_call_num_args (stmt)
3293 205289 : && idx2 < gimple_call_num_args (stmt)
3294 205278 : && idx3 < gimple_call_num_args (stmt)
3295 410579 : && operand_equal_p (op, gimple_call_arg (stmt, idx), 0))
3296 : {
3297 803 : tree arg2 = gimple_call_arg (stmt, idx2);
3298 803 : tree arg3 = gimple_call_arg (stmt, idx3);
3299 1606 : if (!INTEGRAL_TYPE_P (TREE_TYPE (arg2))
3300 1606 : || !INTEGRAL_TYPE_P (TREE_TYPE (arg3)))
3301 : return false;
3302 803 : if (integer_nonzerop (arg2) && integer_nonzerop (arg3))
3303 : return true;
3304 581 : if (integer_zerop (arg2) || integer_zerop (arg3))
3305 : return false;
3306 491 : if (op2)
3307 : {
3308 : /* This case is meant for ubsan instrumentation.
3309 : The caller can check at runtime if *OP2 and *OP3 are
3310 : non-zero and OP is null. */
3311 132 : *op2 = arg2;
3312 132 : *op3 = arg3;
3313 132 : return true;
3314 : }
3315 359 : return tree_expr_nonzero_p (arg2) && tree_expr_nonzero_p (arg3);
3316 : }
3317 : }
3318 : }
3319 :
3320 : /* If this function is marked as returning non-null, then we can
3321 : infer OP is non-null if it is used in the return statement. */
3322 78886566 : if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
3323 966279 : if (gimple_return_retval (return_stmt)
3324 556288 : && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
3325 1059479 : && lookup_attribute ("returns_nonnull",
3326 93200 : TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
3327 : return true;
3328 :
3329 : return false;
3330 : }
3331 :
3332 : /* Compare two case labels. Because the front end should already have
3333 : made sure that case ranges do not overlap, it is enough to only compare
3334 : the CASE_LOW values of each case label. */
3335 :
3336 : static int
3337 43753911 : compare_case_labels (const void *p1, const void *p2)
3338 : {
3339 43753911 : const_tree const case1 = *(const_tree const*)p1;
3340 43753911 : const_tree const case2 = *(const_tree const*)p2;
3341 :
3342 : /* The 'default' case label always goes first. */
3343 43753911 : if (!CASE_LOW (case1))
3344 : return -1;
3345 43753911 : else if (!CASE_LOW (case2))
3346 : return 1;
3347 : else
3348 43753911 : return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
3349 : }
3350 :
3351 : /* Sort the case labels in LABEL_VEC in place in ascending order. */
3352 :
3353 : void
3354 70110 : sort_case_labels (vec<tree> &label_vec)
3355 : {
3356 70110 : label_vec.qsort (compare_case_labels);
3357 70110 : }
3358 :
3359 : /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3360 :
3361 : LABELS is a vector that contains all case labels to look at.
3362 :
3363 : INDEX_TYPE is the type of the switch index expression. Case labels
3364 : in LABELS are discarded if their values are not in the value range
3365 : covered by INDEX_TYPE. The remaining case label values are folded
3366 : to INDEX_TYPE.
3367 :
3368 : If a default case exists in LABELS, it is removed from LABELS and
3369 : returned in DEFAULT_CASEP. If no default case exists, but the
3370 : case labels already cover the whole range of INDEX_TYPE, a default
3371 : case is returned pointing to one of the existing case labels.
3372 : Otherwise DEFAULT_CASEP is set to NULL_TREE.
3373 :
3374 : DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3375 : apply and no action is taken regardless of whether a default case is
3376 : found or not. */
3377 :
3378 : void
3379 61956 : preprocess_case_label_vec_for_gimple (vec<tree> &labels,
3380 : tree index_type,
3381 : tree *default_casep)
3382 : {
3383 61956 : tree min_value, max_value;
3384 61956 : tree default_case = NULL_TREE;
3385 61956 : size_t i, len;
3386 :
3387 61956 : i = 0;
3388 61956 : min_value = TYPE_MIN_VALUE (index_type);
3389 61956 : max_value = TYPE_MAX_VALUE (index_type);
3390 1152758 : while (i < labels.length ())
3391 : {
3392 1090802 : tree elt = labels[i];
3393 1090802 : tree low = CASE_LOW (elt);
3394 1090802 : tree high = CASE_HIGH (elt);
3395 1090802 : bool remove_element = false;
3396 :
3397 1090802 : if (low)
3398 : {
3399 1055516 : gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
3400 1055516 : gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
3401 :
3402 : /* This is a non-default case label, i.e. it has a value.
3403 :
3404 : See if the case label is reachable within the range of
3405 : the index type. Remove out-of-range case values. Turn
3406 : case ranges into a canonical form (high > low strictly)
3407 : and convert the case label values to the index type.
3408 :
3409 : NB: The type of gimple_switch_index() may be the promoted
3410 : type, but the case labels retain the original type. */
3411 :
3412 12789 : if (high)
3413 : {
3414 : /* This is a case range. Discard empty ranges.
3415 : If the bounds or the range are equal, turn this
3416 : into a simple (one-value) case. */
3417 12789 : int cmp = tree_int_cst_compare (high, low);
3418 12789 : if (cmp < 0)
3419 : remove_element = true;
3420 12789 : else if (cmp == 0)
3421 : high = NULL_TREE;
3422 : }
3423 :
3424 1044367 : if (! high)
3425 : {
3426 : /* If the simple case value is unreachable, ignore it. */
3427 1053876 : if ((TREE_CODE (min_value) == INTEGER_CST
3428 1053876 : && tree_int_cst_compare (low, min_value) < 0)
3429 2107709 : || (TREE_CODE (max_value) == INTEGER_CST
3430 1053833 : && tree_int_cst_compare (low, max_value) > 0))
3431 : remove_element = true;
3432 : else
3433 1053715 : low = fold_convert (index_type, low);
3434 : }
3435 : else
3436 : {
3437 : /* If the entire case range is unreachable, ignore it. */
3438 1640 : if ((TREE_CODE (min_value) == INTEGER_CST
3439 1640 : && tree_int_cst_compare (high, min_value) < 0)
3440 3268 : || (TREE_CODE (max_value) == INTEGER_CST
3441 1628 : && tree_int_cst_compare (low, max_value) > 0))
3442 : remove_element = true;
3443 : else
3444 : {
3445 : /* If the lower bound is less than the index type's
3446 : minimum value, truncate the range bounds. */
3447 1628 : if (TREE_CODE (min_value) == INTEGER_CST
3448 1628 : && tree_int_cst_compare (low, min_value) < 0)
3449 : low = min_value;
3450 1628 : low = fold_convert (index_type, low);
3451 :
3452 : /* If the upper bound is greater than the index type's
3453 : maximum value, truncate the range bounds. */
3454 1628 : if (TREE_CODE (max_value) == INTEGER_CST
3455 1628 : && tree_int_cst_compare (high, max_value) > 0)
3456 : high = max_value;
3457 1628 : high = fold_convert (index_type, high);
3458 :
3459 : /* We may have folded a case range to a one-value case. */
3460 1628 : if (tree_int_cst_equal (low, high))
3461 0 : high = NULL_TREE;
3462 : }
3463 : }
3464 :
3465 1055516 : CASE_LOW (elt) = low;
3466 1055516 : CASE_HIGH (elt) = high;
3467 : }
3468 : else
3469 : {
3470 35286 : gcc_assert (!default_case);
3471 35286 : default_case = elt;
3472 : /* The default case must be passed separately to the
3473 : gimple_build_switch routine. But if DEFAULT_CASEP
3474 : is NULL, we do not remove the default case (it would
3475 : be completely lost). */
3476 35286 : if (default_casep)
3477 : remove_element = true;
3478 : }
3479 :
3480 1055516 : if (remove_element)
3481 35459 : labels.ordered_remove (i);
3482 : else
3483 1055343 : i++;
3484 : }
3485 61956 : len = i;
3486 :
3487 61956 : if (!labels.is_empty ())
3488 61076 : sort_case_labels (labels);
3489 :
3490 61956 : if (default_casep && !default_case)
3491 : {
3492 : /* If the switch has no default label, add one, so that we jump
3493 : around the switch body. If the labels already cover the whole
3494 : range of the switch index_type, add the default label pointing
3495 : to one of the existing labels. */
3496 14962 : if (len
3497 14481 : && TYPE_MIN_VALUE (index_type)
3498 14481 : && TYPE_MAX_VALUE (index_type)
3499 29443 : && tree_int_cst_equal (CASE_LOW (labels[0]),
3500 14481 : TYPE_MIN_VALUE (index_type)))
3501 : {
3502 4358 : tree low, high = CASE_HIGH (labels[len - 1]);
3503 4358 : if (!high)
3504 4315 : high = CASE_LOW (labels[len - 1]);
3505 4358 : if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3506 : {
3507 62 : tree widest_label = labels[0];
3508 131 : for (i = 1; i < len; i++)
3509 : {
3510 83 : high = CASE_LOW (labels[i]);
3511 83 : low = CASE_HIGH (labels[i - 1]);
3512 83 : if (!low)
3513 53 : low = CASE_LOW (labels[i - 1]);
3514 :
3515 83 : if (CASE_HIGH (labels[i]) != NULL_TREE
3516 114 : && (CASE_HIGH (widest_label) == NULL_TREE
3517 26 : || (wi::gtu_p
3518 52 : (wi::to_wide (CASE_HIGH (labels[i]))
3519 78 : - wi::to_wide (CASE_LOW (labels[i])),
3520 26 : wi::to_wide (CASE_HIGH (widest_label))
3521 161 : - wi::to_wide (CASE_LOW (widest_label))))))
3522 17 : widest_label = labels[i];
3523 :
3524 83 : if (wi::to_wide (low) + 1 != wi::to_wide (high))
3525 : break;
3526 : }
3527 62 : if (i == len)
3528 : {
3529 : /* Designate the label with the widest range to be the
3530 : default label. */
3531 48 : tree label = CASE_LABEL (widest_label);
3532 48 : default_case = build_case_label (NULL_TREE, NULL_TREE,
3533 : label);
3534 : }
3535 : }
3536 : }
3537 : }
3538 :
3539 61956 : if (default_casep)
3540 50248 : *default_casep = default_case;
3541 61956 : }
3542 :
3543 : /* Set the location of all statements in SEQ to LOC. */
3544 :
3545 : void
3546 1049207 : gimple_seq_set_location (gimple_seq seq, location_t loc)
3547 : {
3548 2128556 : for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3549 1079349 : gimple_set_location (gsi_stmt (i), loc);
3550 1049207 : }
3551 :
3552 : /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3553 :
3554 : void
3555 807793901 : gimple_seq_discard (gimple_seq seq)
3556 : {
3557 807793901 : gimple_stmt_iterator gsi;
3558 :
3559 808377945 : for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3560 : {
3561 394867 : gimple *stmt = gsi_stmt (gsi);
3562 394867 : gsi_remove (&gsi, true);
3563 394867 : release_defs (stmt);
3564 394867 : ggc_free (stmt);
3565 : }
3566 807793901 : }
3567 :
3568 : /* See if STMT now calls function that takes no parameters and if so, drop
3569 : call arguments. This is used when devirtualization machinery redirects
3570 : to __builtin_unreachable or __cxa_pure_virtual. */
3571 :
3572 : void
3573 1177972 : maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3574 : {
3575 1177972 : tree decl = gimple_call_fndecl (stmt);
3576 1177972 : if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3577 1177134 : && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3578 1416205 : && gimple_call_num_args (stmt))
3579 : {
3580 121394 : gimple_set_num_ops (stmt, 3);
3581 121394 : update_stmt_fn (fn, stmt);
3582 : }
3583 1177972 : }
3584 :
3585 : /* Return false if STMT will likely expand to real function call. */
3586 :
3587 : bool
3588 3385380 : gimple_inexpensive_call_p (gcall *stmt)
3589 : {
3590 3385380 : if (gimple_call_internal_p (stmt))
3591 : return true;
3592 3328183 : tree decl = gimple_call_fndecl (stmt);
3593 3328183 : if (decl && is_inexpensive_builtin (decl))
3594 : return true;
3595 : return false;
3596 : }
3597 :
3598 : /* Return a non-artificial location for STMT. If STMT does not have
3599 : location information, get the location from EXPR. */
3600 :
3601 : location_t
3602 122885 : gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
3603 : {
3604 122885 : location_t loc = gimple_nonartificial_location (stmt);
3605 122885 : if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
3606 46 : loc = tree_nonartificial_location (expr);
3607 122885 : return expansion_point_location_if_in_system_header (loc);
3608 : }
3609 :
3610 :
3611 : #if CHECKING_P
3612 :
3613 : namespace selftest {
3614 :
3615 : /* Selftests for core gimple structures. */
3616 :
3617 : /* Verify that STMT is pretty-printed as EXPECTED.
3618 : Helper function for selftests. */
3619 :
3620 : static void
3621 20 : verify_gimple_pp (const char *expected, gimple *stmt)
3622 : {
3623 20 : pretty_printer pp;
3624 20 : pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
3625 20 : ASSERT_STREQ (expected, pp_formatted_text (&pp));
3626 20 : }
3627 :
3628 : /* Build a GIMPLE_ASSIGN equivalent to
3629 : tmp = 5;
3630 : and verify various properties of it. */
3631 :
3632 : static void
3633 4 : test_assign_single ()
3634 : {
3635 4 : tree type = integer_type_node;
3636 4 : tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3637 : get_identifier ("tmp"),
3638 : type);
3639 4 : tree rhs = build_int_cst (type, 5);
3640 4 : gassign *stmt = gimple_build_assign (lhs, rhs);
3641 4 : verify_gimple_pp ("tmp = 5;", stmt);
3642 :
3643 4 : ASSERT_TRUE (is_gimple_assign (stmt));
3644 4 : ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3645 4 : ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3646 4 : ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3647 4 : ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3648 4 : ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3649 4 : ASSERT_TRUE (gimple_assign_single_p (stmt));
3650 8 : ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3651 4 : }
3652 :
3653 : /* Build a GIMPLE_ASSIGN equivalent to
3654 : tmp = a * b;
3655 : and verify various properties of it. */
3656 :
3657 : static void
3658 4 : test_assign_binop ()
3659 : {
3660 4 : tree type = integer_type_node;
3661 4 : tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3662 : get_identifier ("tmp"),
3663 : type);
3664 4 : tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3665 : get_identifier ("a"),
3666 : type);
3667 4 : tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3668 : get_identifier ("b"),
3669 : type);
3670 4 : gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3671 4 : verify_gimple_pp ("tmp = a * b;", stmt);
3672 :
3673 4 : ASSERT_TRUE (is_gimple_assign (stmt));
3674 4 : ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3675 4 : ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3676 4 : ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3677 8 : ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3678 4 : ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3679 4 : ASSERT_FALSE (gimple_assign_single_p (stmt));
3680 4 : ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3681 4 : }
3682 :
3683 : /* Verify that GIMPLE trap queries distinguish a register definition and a
3684 : trapping store from their nontrapping right-hand sides. */
3685 :
3686 : static void
3687 4 : test_could_trap ()
3688 : {
3689 4 : tree reg_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3690 : get_identifier ("readonly_reg"),
3691 : integer_type_node);
3692 4 : TREE_READONLY (reg_lhs) = 1;
3693 4 : gassign *stmt = gimple_build_assign (reg_lhs, integer_one_node);
3694 :
3695 4 : ASSERT_FALSE (gimple_store_p (stmt));
3696 4 : ASSERT_FALSE (gimple_could_trap_p (stmt));
3697 4 : ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt));
3698 :
3699 4 : tree mem_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3700 : get_identifier ("readonly_mem"),
3701 : integer_type_node);
3702 4 : TREE_READONLY (mem_lhs) = 1;
3703 4 : TREE_STATIC (mem_lhs) = 1;
3704 4 : TREE_ADDRESSABLE (mem_lhs) = 1;
3705 4 : stmt = gimple_build_assign (mem_lhs, integer_one_node);
3706 :
3707 4 : ASSERT_TRUE (gimple_store_p (stmt));
3708 4 : ASSERT_TRUE (gimple_could_trap_p (stmt));
3709 4 : ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt));
3710 :
3711 4 : tree record_type = make_node (RECORD_TYPE);
3712 4 : tree field = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
3713 : get_identifier ("value"), integer_type_node);
3714 4 : DECL_CONTEXT (field) = record_type;
3715 4 : TYPE_FIELDS (record_type) = field;
3716 4 : layout_type (record_type);
3717 :
3718 4 : tree call_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3719 : get_identifier ("readonly_call_mem"),
3720 : record_type);
3721 4 : TREE_READONLY (call_lhs) = 1;
3722 4 : TREE_STATIC (call_lhs) = 1;
3723 4 : TREE_ADDRESSABLE (call_lhs) = 1;
3724 :
3725 4 : tree fn_type = build_function_type_list (record_type, NULL_TREE);
3726 4 : tree fn = build_fn_decl ("nothrow_call", fn_type);
3727 4 : gcall *call = gimple_build_call (fn, 0);
3728 4 : gimple_call_set_lhs (call, call_lhs);
3729 4 : gimple_call_set_nothrow (call, true);
3730 :
3731 4 : ASSERT_TRUE (gimple_store_p (call));
3732 4 : ASSERT_TRUE (gimple_could_trap_p (call));
3733 4 : ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false));
3734 :
3735 4 : gimple_call_set_return_slot_opt (call, true);
3736 4 : ASSERT_TRUE (gimple_could_trap_p (call));
3737 4 : ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false));
3738 4 : }
3739 :
3740 : /* Build a GIMPLE_NOP and verify various properties of it. */
3741 :
3742 : static void
3743 4 : test_nop_stmt ()
3744 : {
3745 4 : gimple *stmt = gimple_build_nop ();
3746 4 : verify_gimple_pp ("GIMPLE_NOP", stmt);
3747 4 : ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3748 4 : ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3749 4 : ASSERT_FALSE (gimple_assign_single_p (stmt));
3750 4 : }
3751 :
3752 : /* Build a GIMPLE_RETURN equivalent to
3753 : return 7;
3754 : and verify various properties of it. */
3755 :
3756 : static void
3757 4 : test_return_stmt ()
3758 : {
3759 4 : tree type = integer_type_node;
3760 4 : tree val = build_int_cst (type, 7);
3761 4 : greturn *stmt = gimple_build_return (val);
3762 4 : verify_gimple_pp ("return 7;", stmt);
3763 :
3764 4 : ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3765 4 : ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3766 4 : ASSERT_EQ (val, gimple_return_retval (stmt));
3767 4 : ASSERT_FALSE (gimple_assign_single_p (stmt));
3768 4 : }
3769 :
3770 : /* Build a GIMPLE_RETURN equivalent to
3771 : return;
3772 : and verify various properties of it. */
3773 :
3774 : static void
3775 4 : test_return_without_value ()
3776 : {
3777 4 : greturn *stmt = gimple_build_return (NULL);
3778 4 : verify_gimple_pp ("return;", stmt);
3779 :
3780 4 : ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3781 4 : ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3782 4 : ASSERT_EQ (NULL, gimple_return_retval (stmt));
3783 4 : ASSERT_FALSE (gimple_assign_single_p (stmt));
3784 4 : }
3785 :
3786 : /* Run all of the selftests within this file. */
3787 :
3788 : void
3789 4 : gimple_cc_tests ()
3790 : {
3791 4 : test_assign_single ();
3792 4 : test_assign_binop ();
3793 4 : test_could_trap ();
3794 4 : test_nop_stmt ();
3795 4 : test_return_stmt ();
3796 4 : test_return_without_value ();
3797 4 : }
3798 :
3799 : } // namespace selftest
3800 :
3801 :
3802 : #endif /* CHECKING_P */
|
