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