Line data Source code
1 : /* Gimple IR definitions.
2 :
3 : Copyright (C) 2007-2026 Free Software Foundation, Inc.
4 : Contributed by Aldy Hernandez <aldyh@redhat.com>
5 :
6 : This file is part of GCC.
7 :
8 : GCC is free software; you can redistribute it and/or modify it under
9 : the terms of the GNU General Public License as published by the Free
10 : Software Foundation; either version 3, or (at your option) any later
11 : version.
12 :
13 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : for more details.
17 :
18 : You should have received a copy of the GNU General Public License
19 : along with GCC; see the file COPYING3. If not see
20 : <http://www.gnu.org/licenses/>. */
21 :
22 : #ifndef GCC_GIMPLE_H
23 : #define GCC_GIMPLE_H
24 :
25 : #include "tree-ssa-alias.h"
26 : #include "gimple-expr.h"
27 : #include "bitmap.h"
28 : #include "value-range.h"
29 : #include "value-range-storage.h"
30 : #include "value-query.h"
31 :
32 : typedef gimple *gimple_seq_node;
33 :
34 : enum gimple_code {
35 : #define DEFGSCODE(SYM, STRING, STRUCT) SYM,
36 : #include "gimple.def"
37 : #undef DEFGSCODE
38 : LAST_AND_UNUSED_GIMPLE_CODE
39 : };
40 :
41 : extern const char *const gimple_code_name[];
42 : extern const unsigned char gimple_rhs_class_table[];
43 :
44 : /* Error out if a gimple tuple is addressed incorrectly. */
45 : #if defined ENABLE_GIMPLE_CHECKING
46 : #define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
47 : extern void gimple_check_failed (const gimple *, const char *, int, \
48 : const char *, enum gimple_code, \
49 : enum tree_code) ATTRIBUTE_NORETURN \
50 : ATTRIBUTE_COLD;
51 :
52 : #define GIMPLE_CHECK(GS, CODE) \
53 : do { \
54 : const gimple *__gs = (GS); \
55 : if (gimple_code (__gs) != (CODE)) \
56 : gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \
57 : (CODE), ERROR_MARK); \
58 : } while (0)
59 : template <typename T>
60 : inline T
61 >11982*10^7 : GIMPLE_CHECK2(const gimple *gs,
62 : #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
63 : const char *file = __builtin_FILE (),
64 : int line = __builtin_LINE (),
65 : const char *fun = __builtin_FUNCTION ())
66 : #else
67 : const char *file = __FILE__,
68 : int line = __LINE__,
69 : const char *fun = NULL)
70 : #endif
71 : {
72 >11982*10^7 : T ret = dyn_cast <T> (gs);
73 : if (!ret)
74 0 : gimple_check_failed (gs, file, line, fun,
75 : std::remove_pointer<T>::type::code_, ERROR_MARK);
76 >11982*10^7 : return ret;
77 : }
78 : template <typename T>
79 : inline T
80 7539410022 : GIMPLE_CHECK2(gimple *gs,
81 : #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
82 : const char *file = __builtin_FILE (),
83 : int line = __builtin_LINE (),
84 : const char *fun = __builtin_FUNCTION ())
85 : #else
86 : const char *file = __FILE__,
87 : int line = __LINE__,
88 : const char *fun = NULL)
89 : #endif
90 : {
91 7539410022 : T ret = dyn_cast <T> (gs);
92 : if (!ret)
93 0 : gimple_check_failed (gs, file, line, fun,
94 : std::remove_pointer<T>::type::code_, ERROR_MARK);
95 7539410022 : return ret;
96 : }
97 : #else /* not ENABLE_GIMPLE_CHECKING */
98 : #define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
99 : #define GIMPLE_CHECK(GS, CODE) (void)0
100 : template <typename T>
101 : inline T
102 : GIMPLE_CHECK2(gimple *gs)
103 : {
104 : return as_a <T> (gs);
105 : }
106 : template <typename T>
107 : inline T
108 : GIMPLE_CHECK2(const gimple *gs)
109 : {
110 : return as_a <T> (gs);
111 : }
112 : #endif
113 :
114 : /* Class of GIMPLE expressions suitable for the RHS of assignments. See
115 : get_gimple_rhs_class. */
116 : enum gimple_rhs_class
117 : {
118 : GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */
119 : GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */
120 : GIMPLE_BINARY_RHS, /* The expression is a binary operation. */
121 : GIMPLE_UNARY_RHS, /* The expression is a unary operation. */
122 : GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA
123 : name, a _DECL, a _REF, etc. */
124 : };
125 :
126 : /* Specific flags for individual GIMPLE statements. These flags are
127 : always stored in gimple.subcode and they may only be
128 : defined for statement codes that do not use subcodes.
129 :
130 : Values for the masks can overlap as long as the overlapping values
131 : are never used in the same statement class.
132 :
133 : The maximum mask value that can be defined is 1 << 15 (i.e., each
134 : statement code can hold up to 16 bitflags).
135 :
136 : Keep this list sorted. */
137 : enum gf_mask {
138 : GF_ASM_BASIC = 1 << 0,
139 : GF_ASM_VOLATILE = 1 << 1,
140 : GF_ASM_INLINE = 1 << 2,
141 : GF_CALL_FROM_THUNK = 1 << 0,
142 : GF_CALL_RETURN_SLOT_OPT = 1 << 1,
143 : GF_CALL_TAILCALL = 1 << 2,
144 : GF_CALL_VA_ARG_PACK = 1 << 3,
145 : GF_CALL_NOTHROW = 1 << 4,
146 : GF_CALL_ALLOCA_FOR_VAR = 1 << 5,
147 : GF_CALL_INTERNAL = 1 << 6,
148 : GF_CALL_CTRL_ALTERING = 1 << 7,
149 : GF_CALL_MUST_TAIL_CALL = 1 << 9,
150 : GF_CALL_BY_DESCRIPTOR = 1 << 10,
151 : GF_CALL_NOCF_CHECK = 1 << 11,
152 : GF_CALL_FROM_NEW_OR_DELETE = 1 << 12,
153 : GF_CALL_XTHROW = 1 << 13,
154 : GF_OMP_PARALLEL_COMBINED = 1 << 0,
155 : GF_OMP_TASK_TASKLOOP = 1 << 0,
156 : GF_OMP_TASK_TASKWAIT = 1 << 1,
157 : GF_OMP_FOR_KIND_MASK = (1 << 3) - 1,
158 : GF_OMP_FOR_KIND_FOR = 0,
159 : GF_OMP_FOR_KIND_DISTRIBUTE = 1,
160 : GF_OMP_FOR_KIND_TASKLOOP = 2,
161 : GF_OMP_FOR_KIND_OACC_LOOP = 4,
162 : GF_OMP_FOR_KIND_SIMD = 5,
163 : GF_OMP_FOR_COMBINED = 1 << 3,
164 : GF_OMP_FOR_COMBINED_INTO = 1 << 4,
165 : GF_OMP_TARGET_KIND_MASK = (1 << 5) - 1,
166 : GF_OMP_TARGET_KIND_REGION = 0,
167 : GF_OMP_TARGET_KIND_DATA = 1,
168 : GF_OMP_TARGET_KIND_UPDATE = 2,
169 : GF_OMP_TARGET_KIND_ENTER_DATA = 3,
170 : GF_OMP_TARGET_KIND_EXIT_DATA = 4,
171 : GF_OMP_TARGET_KIND_OACC_PARALLEL = 5,
172 : GF_OMP_TARGET_KIND_OACC_KERNELS = 6,
173 : GF_OMP_TARGET_KIND_OACC_SERIAL = 7,
174 : GF_OMP_TARGET_KIND_OACC_DATA = 8,
175 : GF_OMP_TARGET_KIND_OACC_UPDATE = 9,
176 : GF_OMP_TARGET_KIND_OACC_ENTER_DATA = 10,
177 : GF_OMP_TARGET_KIND_OACC_EXIT_DATA = 11,
178 : GF_OMP_TARGET_KIND_OACC_DECLARE = 12,
179 : GF_OMP_TARGET_KIND_OACC_HOST_DATA = 13,
180 : /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
181 : decomposed part, parallelized. */
182 : GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED = 14,
183 : /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
184 : decomposed part, "gang-single". */
185 : GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE = 15,
186 : /* A 'GF_OMP_TARGET_KIND_OACC_DATA' representing an OpenACC 'kernels'
187 : decomposed parts' 'data' construct. */
188 : GF_OMP_TARGET_KIND_OACC_DATA_KERNELS = 16,
189 : GF_OMP_TEAMS_HOST = 1 << 0,
190 :
191 : /* True on an GIMPLE_OMP_RETURN statement if the return does not require
192 : a thread synchronization via some sort of barrier. The exact barrier
193 : that would otherwise be emitted is dependent on the OMP statement with
194 : which this return is associated. */
195 : GF_OMP_RETURN_NOWAIT = 1 << 0,
196 :
197 : GF_OMP_SECTION_LAST = 1 << 0,
198 : GF_OMP_ORDERED_STANDALONE = 1 << 0,
199 : GF_OMP_ATOMIC_MEMORY_ORDER = (1 << 6) - 1,
200 : GF_OMP_ATOMIC_NEED_VALUE = 1 << 6,
201 : GF_OMP_ATOMIC_WEAK = 1 << 7,
202 : GF_PREDICT_TAKEN = 1 << 15
203 : };
204 :
205 : /* This subcode tells apart different kinds of stmts that are not used
206 : for codegen, but rather to retain debug information. */
207 : enum gimple_debug_subcode {
208 : GIMPLE_DEBUG_BIND = 0,
209 : GIMPLE_DEBUG_SOURCE_BIND = 1,
210 : GIMPLE_DEBUG_BEGIN_STMT = 2,
211 : GIMPLE_DEBUG_INLINE_ENTRY = 3
212 : };
213 :
214 : /* Masks for selecting a pass local flag (PLF) to work on. These
215 : masks are used by gimple_set_plf and gimple_plf. */
216 : enum plf_mask {
217 : GF_PLF_1 = 1 << 0,
218 : GF_PLF_2 = 1 << 1
219 : };
220 :
221 : /* Data structure definitions for GIMPLE tuples. NOTE: word markers
222 : are for 64 bit hosts. */
223 :
224 : struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
225 : chain_next ("%h.next"), variable_size))
226 : gimple
227 : {
228 : /* [ WORD 1 ]
229 : Main identifying code for a tuple. */
230 : enum gimple_code code : 8;
231 :
232 : /* Nonzero if a warning should not be emitted on this tuple. */
233 : unsigned int no_warning : 1;
234 :
235 : /* Nonzero if this tuple has been visited. Passes are responsible
236 : for clearing this bit before using it. */
237 : unsigned int visited : 1;
238 :
239 : /* Nonzero if this tuple represents a non-temporal move; currently
240 : only stores are supported. */
241 : unsigned int nontemporal_move : 1;
242 :
243 : /* Pass local flags. These flags are free for any pass to use as
244 : they see fit. Passes should not assume that these flags contain
245 : any useful value when the pass starts. Any initial state that
246 : the pass requires should be set on entry to the pass. See
247 : gimple_set_plf and gimple_plf for usage. */
248 : unsigned int plf : 2;
249 :
250 : /* Nonzero if this statement has been modified and needs to have its
251 : operands rescanned. */
252 : unsigned modified : 1;
253 :
254 : /* Nonzero if this statement contains volatile operands. */
255 : unsigned has_volatile_ops : 1;
256 :
257 : /* Infrastructure local flag. Always clear. */
258 : unsigned ilf : 1;
259 :
260 : /* The SUBCODE field can be used for tuple-specific flags for tuples
261 : that do not require subcodes. Note that SUBCODE should be at
262 : least as wide as tree codes, as several tuples store tree codes
263 : in there. */
264 : unsigned int subcode : 16;
265 :
266 : /* UID of this statement. This is used by passes that want to assign IDs
267 : to statements. It must be assigned and used by each pass. By default
268 : it should be assumed to contain garbage. */
269 : unsigned uid;
270 :
271 : /* [ WORD 2 ]
272 : Number of operands in this tuple. */
273 : unsigned num_ops;
274 :
275 : /* Unused 32 bits padding on 64-bit hosts. */
276 :
277 : /* [ WORD 3 ]
278 : Locus information for debug info. */
279 : location_t location;
280 :
281 : /* [ WORD 4 ]
282 : Basic block holding this statement. */
283 : basic_block bb;
284 :
285 : /* [ WORD 5-6 ]
286 : Linked lists of gimple statements. The next pointers form
287 : a NULL terminated list, the prev pointers are a cyclic list.
288 : A gimple statement is hence also a double-ended list of
289 : statements, with the pointer itself being the first element,
290 : and the prev pointer being the last. */
291 : gimple *next;
292 : gimple *GTY((skip)) prev;
293 : };
294 :
295 :
296 : /* Base structure for tuples with operands. */
297 :
298 : /* This gimple subclass has no tag value. */
299 : struct GTY(())
300 : gimple_statement_with_ops_base : public gimple
301 : {
302 : /* [ WORD 1-6 ] : base class */
303 :
304 : /* [ WORD 7 ]
305 : SSA operand vectors. NOTE: It should be possible to
306 : amalgamate these vectors with the operand vector OP. However,
307 : the SSA operand vectors are organized differently and contain
308 : more information (like immediate use chaining). */
309 : struct use_optype_d GTY((skip (""))) *use_ops;
310 : };
311 :
312 :
313 : /* Statements that take register operands. */
314 :
315 : struct GTY((tag("GSS_WITH_OPS")))
316 : gimple_statement_with_ops : public gimple_statement_with_ops_base
317 : {
318 : /* [ WORD 1-7 ] : base class */
319 :
320 : /* [ WORD 8 ]
321 : Operand vector. NOTE! This must always be the last field
322 : of this structure. In particular, this means that this
323 : structure cannot be embedded inside another one. */
324 : tree GTY((length ("%h.num_ops"))) op[1];
325 : };
326 :
327 :
328 : /* Base for statements that take both memory and register operands. */
329 :
330 : struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
331 : gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
332 : {
333 : /* [ WORD 1-7 ] : base class */
334 :
335 : /* [ WORD 8-9 ]
336 : Virtual operands for this statement. The GC will pick them
337 : up via the ssa_names array. */
338 : tree GTY((skip (""))) vdef;
339 : tree GTY((skip (""))) vuse;
340 : };
341 :
342 :
343 : /* Statements that take both memory and register operands. */
344 :
345 : struct GTY((tag("GSS_WITH_MEM_OPS")))
346 : gimple_statement_with_memory_ops :
347 : public gimple_statement_with_memory_ops_base
348 : {
349 : /* [ WORD 1-9 ] : base class */
350 :
351 : /* [ WORD 10 ]
352 : Operand vector. NOTE! This must always be the last field
353 : of this structure. In particular, this means that this
354 : structure cannot be embedded inside another one. */
355 : tree GTY((length ("%h.num_ops"))) op[1];
356 : };
357 :
358 :
359 : /* Call statements that take both memory and register operands. */
360 :
361 : struct GTY((tag("GSS_CALL")))
362 : gcall : public gimple_statement_with_memory_ops_base
363 : {
364 : /* [ WORD 1-9 ] : base class */
365 :
366 : /* [ WORD 10-13 ] */
367 : struct pt_solution call_used;
368 : struct pt_solution call_clobbered;
369 :
370 : /* [ WORD 14 ] */
371 : union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
372 : tree GTY ((tag ("0"))) fntype;
373 : enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
374 : } u;
375 :
376 : /* [ WORD 15 ]
377 : Operand vector. NOTE! This must always be the last field
378 : of this structure. In particular, this means that this
379 : structure cannot be embedded inside another one. */
380 : tree GTY((length ("%h.num_ops"))) op[1];
381 :
382 : static const enum gimple_code code_ = GIMPLE_CALL;
383 : };
384 :
385 :
386 : /* OMP statements. */
387 :
388 : struct GTY((tag("GSS_OMP")))
389 : gimple_statement_omp : public gimple
390 : {
391 : /* [ WORD 1-6 ] : base class */
392 :
393 : /* [ WORD 7 ] */
394 : gimple_seq body;
395 : };
396 :
397 :
398 : /* GIMPLE_BIND */
399 :
400 : struct GTY((tag("GSS_BIND")))
401 : gbind : public gimple
402 : {
403 : /* [ WORD 1-6 ] : base class */
404 :
405 : /* [ WORD 7 ]
406 : Variables declared in this scope. */
407 : tree vars;
408 :
409 : /* [ WORD 8 ]
410 : This is different than the BLOCK field in gimple,
411 : which is analogous to TREE_BLOCK (i.e., the lexical block holding
412 : this statement). This field is the equivalent of BIND_EXPR_BLOCK
413 : in tree land (i.e., the lexical scope defined by this bind). See
414 : gimple-low.cc. */
415 : tree block;
416 :
417 : /* [ WORD 9 ] */
418 : gimple_seq body;
419 : };
420 :
421 :
422 : /* GIMPLE_CATCH */
423 :
424 : struct GTY((tag("GSS_CATCH")))
425 : gcatch : public gimple
426 : {
427 : /* [ WORD 1-6 ] : base class */
428 :
429 : /* [ WORD 7 ] */
430 : tree types;
431 :
432 : /* [ WORD 8 ] */
433 : gimple_seq handler;
434 : };
435 :
436 :
437 : /* GIMPLE_EH_FILTER */
438 :
439 : struct GTY((tag("GSS_EH_FILTER")))
440 : geh_filter : public gimple
441 : {
442 : /* [ WORD 1-6 ] : base class */
443 :
444 : /* [ WORD 7 ]
445 : Filter types. */
446 : tree types;
447 :
448 : /* [ WORD 8 ]
449 : Failure actions. */
450 : gimple_seq failure;
451 : };
452 :
453 : /* GIMPLE_EH_ELSE */
454 :
455 : struct GTY((tag("GSS_EH_ELSE")))
456 : geh_else : public gimple
457 : {
458 : /* [ WORD 1-6 ] : base class */
459 :
460 : /* [ WORD 7,8 ] */
461 : gimple_seq n_body, e_body;
462 : };
463 :
464 : /* GIMPLE_EH_MUST_NOT_THROW */
465 :
466 : struct GTY((tag("GSS_EH_MNT")))
467 : geh_mnt : public gimple
468 : {
469 : /* [ WORD 1-6 ] : base class */
470 :
471 : /* [ WORD 7 ] Abort function decl. */
472 : tree fndecl;
473 : };
474 :
475 : /* GIMPLE_PHI */
476 :
477 : struct GTY((tag("GSS_PHI")))
478 : gphi : public gimple
479 : {
480 : /* [ WORD 1-6 ] : base class */
481 :
482 : /* [ WORD 7 ] */
483 : unsigned capacity;
484 : unsigned nargs;
485 :
486 : /* [ WORD 8 ] */
487 : tree result;
488 :
489 : /* [ WORD 9-14 ] */
490 : struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
491 : };
492 :
493 :
494 : /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
495 :
496 : struct GTY((tag("GSS_EH_CTRL")))
497 : gimple_statement_eh_ctrl : public gimple
498 : {
499 : /* [ WORD 1-6 ] : base class */
500 :
501 : /* [ WORD 7 ]
502 : Exception region number. */
503 : int region;
504 : };
505 :
506 : struct GTY((tag("GSS_EH_CTRL")))
507 : gresx : public gimple_statement_eh_ctrl
508 : {
509 : /* No extra fields; adds invariant:
510 : stmt->code == GIMPLE_RESX. */
511 : };
512 :
513 : struct GTY((tag("GSS_EH_CTRL")))
514 : geh_dispatch : public gimple_statement_eh_ctrl
515 : {
516 : /* No extra fields; adds invariant:
517 : stmt->code == GIMPLE_EH_DISPATH. */
518 : };
519 :
520 :
521 : /* GIMPLE_TRY */
522 :
523 : struct GTY((tag("GSS_TRY")))
524 : gtry : public gimple
525 : {
526 : /* [ WORD 1-6 ] : base class */
527 :
528 : /* [ WORD 7 ]
529 : Expression to evaluate. */
530 : gimple_seq eval;
531 :
532 : /* [ WORD 8 ]
533 : Cleanup expression. */
534 : gimple_seq cleanup;
535 : };
536 :
537 : /* Kind of GIMPLE_TRY statements. */
538 : enum gimple_try_flags
539 : {
540 : /* A try/catch. */
541 : GIMPLE_TRY_CATCH = 1 << 0,
542 :
543 : /* A try/finally. */
544 : GIMPLE_TRY_FINALLY = 1 << 1,
545 : GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
546 :
547 : /* Analogous to TRY_CATCH_IS_CLEANUP. */
548 : GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
549 : };
550 :
551 : /* GIMPLE_WITH_CLEANUP_EXPR */
552 :
553 : struct GTY((tag("GSS_WCE")))
554 : gimple_statement_wce : public gimple
555 : {
556 : /* [ WORD 1-6 ] : base class */
557 :
558 : /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
559 : executed if an exception is thrown, not on normal exit of its
560 : scope. This flag is analogous to the CLEANUP_EH_ONLY flag
561 : in TARGET_EXPRs. */
562 :
563 : /* [ WORD 7 ]
564 : Cleanup expression. */
565 : gimple_seq cleanup;
566 : };
567 :
568 :
569 : /* GIMPLE_ASM */
570 :
571 : struct GTY((tag("GSS_ASM")))
572 : gasm : public gimple_statement_with_memory_ops_base
573 : {
574 : /* [ WORD 1-9 ] : base class */
575 :
576 : /* [ WORD 10 ]
577 : __asm__ statement. */
578 : const char *string;
579 :
580 : /* [ WORD 11 ]
581 : Number of inputs, outputs, clobbers, labels. */
582 : unsigned char ni;
583 : unsigned char no;
584 : unsigned char nc;
585 : unsigned char nl;
586 :
587 : /* [ WORD 12 ]
588 : Operand vector. NOTE! This must always be the last field
589 : of this structure. In particular, this means that this
590 : structure cannot be embedded inside another one. */
591 : tree GTY((length ("%h.num_ops"))) op[1];
592 : };
593 :
594 : /* GIMPLE_OMP_CRITICAL */
595 :
596 : struct GTY((tag("GSS_OMP_CRITICAL")))
597 : gomp_critical : public gimple_statement_omp
598 : {
599 : /* [ WORD 1-7 ] : base class */
600 :
601 : /* [ WORD 8 ] */
602 : tree clauses;
603 :
604 : /* [ WORD 9 ]
605 : Critical section name. */
606 : tree name;
607 : };
608 :
609 :
610 : struct GTY(()) gimple_omp_for_iter {
611 : /* Condition code. */
612 : enum tree_code cond;
613 :
614 : /* Index variable. */
615 : tree index;
616 :
617 : /* Initial value. */
618 : tree initial;
619 :
620 : /* Final value. */
621 : tree final;
622 :
623 : /* Increment. */
624 : tree incr;
625 : };
626 :
627 : /* GIMPLE_OMP_FOR */
628 :
629 : struct GTY((tag("GSS_OMP_FOR")))
630 : gomp_for : public gimple_statement_omp
631 : {
632 : /* [ WORD 1-7 ] : base class */
633 :
634 : /* [ WORD 8 ] */
635 : tree clauses;
636 :
637 : /* [ WORD 9 ]
638 : Number of elements in iter array. */
639 : size_t collapse;
640 :
641 : /* [ WORD 10 ] */
642 : struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
643 :
644 : /* [ WORD 11 ]
645 : Pre-body evaluated before the loop body begins. */
646 : gimple_seq pre_body;
647 : };
648 :
649 :
650 : /* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
651 :
652 : struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
653 : gimple_statement_omp_parallel_layout : public gimple_statement_omp
654 : {
655 : /* [ WORD 1-7 ] : base class */
656 :
657 : /* [ WORD 8 ]
658 : Clauses. */
659 : tree clauses;
660 :
661 : /* [ WORD 9 ]
662 : Child function holding the body of the parallel region. */
663 : tree child_fn;
664 :
665 : /* [ WORD 10 ]
666 : Shared data argument. */
667 : tree data_arg;
668 : };
669 :
670 : /* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
671 : struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
672 : gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
673 : {
674 : /* No extra fields; adds invariant:
675 : stmt->code == GIMPLE_OMP_PARALLEL
676 : || stmt->code == GIMPLE_OMP_TASK
677 : || stmt->code == GIMPLE_OMP_TEAMS. */
678 : };
679 :
680 : /* GIMPLE_OMP_PARALLEL */
681 : struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
682 : gomp_parallel : public gimple_statement_omp_taskreg
683 : {
684 : /* No extra fields; adds invariant:
685 : stmt->code == GIMPLE_OMP_PARALLEL. */
686 : };
687 :
688 : /* GIMPLE_OMP_TARGET */
689 : struct GTY((tag("GSS_OMP_TARGET")))
690 : gomp_target : public gimple_statement_omp_parallel_layout
691 : {
692 : /* [ WORD 1-10 ] : base class */
693 :
694 : /* [ WORD 11 ]
695 : Iterator loops. */
696 : gimple_seq iterator_loops;
697 : };
698 :
699 : /* GIMPLE_OMP_TASK */
700 :
701 : struct GTY((tag("GSS_OMP_TASK")))
702 : gomp_task : public gimple_statement_omp_taskreg
703 : {
704 : /* [ WORD 1-10 ] : base class */
705 :
706 : /* [ WORD 11 ]
707 : Child function holding firstprivate initialization if needed. */
708 : tree copy_fn;
709 :
710 : /* [ WORD 12-13 ]
711 : Size and alignment in bytes of the argument data block. */
712 : tree arg_size;
713 : tree arg_align;
714 : };
715 :
716 :
717 : /* GIMPLE_OMP_SECTION */
718 : /* Uses struct gimple_statement_omp. */
719 :
720 :
721 : /* GIMPLE_OMP_SECTIONS */
722 :
723 : struct GTY((tag("GSS_OMP_SECTIONS")))
724 : gomp_sections : public gimple_statement_omp
725 : {
726 : /* [ WORD 1-7 ] : base class */
727 :
728 : /* [ WORD 8 ] */
729 : tree clauses;
730 :
731 : /* [ WORD 9 ]
732 : The control variable used for deciding which of the sections to
733 : execute. */
734 : tree control;
735 : };
736 :
737 : /* GIMPLE_OMP_CONTINUE.
738 :
739 : Note: This does not inherit from gimple_statement_omp, because we
740 : do not need the body field. */
741 :
742 : struct GTY((tag("GSS_OMP_CONTINUE")))
743 : gomp_continue : public gimple
744 : {
745 : /* [ WORD 1-6 ] : base class */
746 :
747 : /* [ WORD 7 ] */
748 : tree control_def;
749 :
750 : /* [ WORD 8 ] */
751 : tree control_use;
752 : };
753 :
754 : /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
755 : GIMPLE_OMP_SCAN, GIMPLE_OMP_MASKED, GIMPLE_OMP_SCOPE, GIMPLE_OMP_DISPATCH,
756 : GIMPLE_OMP_INTEROP. */
757 :
758 : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
759 : gimple_statement_omp_single_layout : public gimple_statement_omp
760 : {
761 : /* [ WORD 1-7 ] : base class */
762 :
763 : /* [ WORD 8 ] */
764 : tree clauses;
765 : };
766 :
767 : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
768 : gomp_single : public gimple_statement_omp_single_layout
769 : {
770 : /* No extra fields; adds invariant:
771 : stmt->code == GIMPLE_OMP_SINGLE. */
772 : };
773 :
774 : struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
775 : gomp_teams : public gimple_statement_omp_taskreg
776 : {
777 : /* No extra fields; adds invariant:
778 : stmt->code == GIMPLE_OMP_TEAMS. */
779 : };
780 :
781 : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
782 : gomp_ordered : public gimple_statement_omp_single_layout
783 : {
784 : /* No extra fields; adds invariant:
785 : stmt->code == GIMPLE_OMP_ORDERED. */
786 : };
787 :
788 : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
789 : gomp_scan : public gimple_statement_omp_single_layout
790 : {
791 : /* No extra fields; adds invariant:
792 : stmt->code == GIMPLE_OMP_SCAN. */
793 : };
794 :
795 :
796 : /* GIMPLE_OMP_ATOMIC_LOAD.
797 : Note: This is based on gimple, not g_s_omp, because g_s_omp
798 : contains a sequence, which we don't need here. */
799 :
800 : struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
801 : gomp_atomic_load : public gimple
802 : {
803 : /* [ WORD 1-6 ] : base class */
804 :
805 : /* [ WORD 7-8 ] */
806 : tree rhs, lhs;
807 : };
808 :
809 : /* GIMPLE_OMP_ATOMIC_STORE.
810 : See note on GIMPLE_OMP_ATOMIC_LOAD. */
811 :
812 : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
813 : gimple_statement_omp_atomic_store_layout : public gimple
814 : {
815 : /* [ WORD 1-6 ] : base class */
816 :
817 : /* [ WORD 7 ] */
818 : tree val;
819 : };
820 :
821 : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
822 : gomp_atomic_store :
823 : public gimple_statement_omp_atomic_store_layout
824 : {
825 : /* No extra fields; adds invariant:
826 : stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
827 : };
828 :
829 : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
830 : gimple_statement_omp_return :
831 : public gimple_statement_omp_atomic_store_layout
832 : {
833 : /* No extra fields; adds invariant:
834 : stmt->code == GIMPLE_OMP_RETURN. */
835 : };
836 :
837 : /* Assumptions. */
838 :
839 : struct GTY((tag("GSS_ASSUME")))
840 : gimple_statement_assume : public gimple
841 : {
842 : /* [ WORD 1-6 ] : base class */
843 :
844 : /* [ WORD 7 ] */
845 : tree guard;
846 :
847 : /* [ WORD 8 ] */
848 : gimple_seq body;
849 : };
850 :
851 : /* GIMPLE_TRANSACTION. */
852 :
853 : /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
854 :
855 : /* The __transaction_atomic was declared [[outer]] or it is
856 : __transaction_relaxed. */
857 : #define GTMA_IS_OUTER (1u << 0)
858 : #define GTMA_IS_RELAXED (1u << 1)
859 : #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
860 :
861 : /* The transaction is seen to not have an abort. */
862 : #define GTMA_HAVE_ABORT (1u << 2)
863 : /* The transaction is seen to have loads or stores. */
864 : #define GTMA_HAVE_LOAD (1u << 3)
865 : #define GTMA_HAVE_STORE (1u << 4)
866 : /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
867 : #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
868 : /* The transaction WILL enter serial irrevocable mode.
869 : An irrevocable block post-dominates the entire transaction, such
870 : that all invocations of the transaction will go serial-irrevocable.
871 : In such case, we don't bother instrumenting the transaction, and
872 : tell the runtime that it should begin the transaction in
873 : serial-irrevocable mode. */
874 : #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
875 : /* The transaction contains no instrumentation code whatsoever, most
876 : likely because it is guaranteed to go irrevocable upon entry. */
877 : #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
878 :
879 : struct GTY((tag("GSS_TRANSACTION")))
880 : gtransaction : public gimple_statement_with_memory_ops_base
881 : {
882 : /* [ WORD 1-9 ] : base class */
883 :
884 : /* [ WORD 10 ] */
885 : gimple_seq body;
886 :
887 : /* [ WORD 11-13 ] */
888 : tree label_norm;
889 : tree label_uninst;
890 : tree label_over;
891 : };
892 :
893 : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
894 : enum gimple_statement_structure_enum {
895 : #include "gsstruct.def"
896 : LAST_GSS_ENUM
897 : };
898 : #undef DEFGSSTRUCT
899 :
900 : /* A statement with the invariant that
901 : stmt->code == GIMPLE_COND
902 : i.e. a conditional jump statement. */
903 :
904 : struct GTY((tag("GSS_WITH_OPS")))
905 : gcond : public gimple_statement_with_ops
906 : {
907 : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
908 : static const enum gimple_code code_ = GIMPLE_COND;
909 : };
910 :
911 : /* A statement with the invariant that
912 : stmt->code == GIMPLE_DEBUG
913 : i.e. a debug statement. */
914 :
915 : struct GTY((tag("GSS_WITH_OPS")))
916 : gdebug : public gimple_statement_with_ops
917 : {
918 : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
919 : };
920 :
921 : /* A statement with the invariant that
922 : stmt->code == GIMPLE_GOTO
923 : i.e. a goto statement. */
924 :
925 : struct GTY((tag("GSS_WITH_OPS")))
926 : ggoto : public gimple_statement_with_ops
927 : {
928 : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
929 : };
930 :
931 : /* A statement with the invariant that
932 : stmt->code == GIMPLE_LABEL
933 : i.e. a label statement. */
934 :
935 : struct GTY((tag("GSS_WITH_OPS")))
936 : glabel : public gimple_statement_with_ops
937 : {
938 : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
939 : };
940 :
941 : /* A statement with the invariant that
942 : stmt->code == GIMPLE_SWITCH
943 : i.e. a switch statement. */
944 :
945 : struct GTY((tag("GSS_WITH_OPS")))
946 : gswitch : public gimple_statement_with_ops
947 : {
948 : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
949 : };
950 :
951 : /* A statement with the invariant that
952 : stmt->code == GIMPLE_ASSIGN
953 : i.e. an assignment statement. */
954 :
955 : struct GTY((tag("GSS_WITH_MEM_OPS")))
956 : gassign : public gimple_statement_with_memory_ops
957 : {
958 : static const enum gimple_code code_ = GIMPLE_ASSIGN;
959 : /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
960 : };
961 :
962 : /* A statement with the invariant that
963 : stmt->code == GIMPLE_RETURN
964 : i.e. a return statement. */
965 :
966 : struct GTY((tag("GSS_WITH_MEM_OPS")))
967 : greturn : public gimple_statement_with_memory_ops
968 : {
969 : /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
970 : };
971 :
972 : template <>
973 : template <>
974 : inline bool
975 88525928 : is_a_helper <gasm *>::test (gimple *gs)
976 : {
977 88525928 : return gs->code == GIMPLE_ASM;
978 : }
979 :
980 : template <>
981 : template <>
982 : inline bool
983 14782226775 : is_a_helper <gassign *>::test (gimple *gs)
984 : {
985 14782120567 : return gs->code == GIMPLE_ASSIGN;
986 : }
987 :
988 : template <>
989 : template <>
990 : inline bool
991 82521402128 : is_a_helper <const gassign *>::test (const gimple *gs)
992 : {
993 82521402128 : return gs->code == GIMPLE_ASSIGN;
994 : }
995 :
996 : template <>
997 : template <>
998 : inline bool
999 43700206 : is_a_helper <gbind *>::test (gimple *gs)
1000 : {
1001 43700206 : return gs->code == GIMPLE_BIND;
1002 : }
1003 :
1004 : template <>
1005 : template <>
1006 : inline bool
1007 18760143479 : is_a_helper <gcall *>::test (gimple *gs)
1008 : {
1009 18760143479 : return gs->code == GIMPLE_CALL;
1010 : }
1011 :
1012 : template <>
1013 : template <>
1014 : inline bool
1015 553352 : is_a_helper <gcatch *>::test (gimple *gs)
1016 : {
1017 553352 : return gs->code == GIMPLE_CATCH;
1018 : }
1019 :
1020 : template <>
1021 : template <>
1022 : inline bool
1023 3038771188 : is_a_helper <gcond *>::test (gimple *gs)
1024 : {
1025 3038771188 : return gs->code == GIMPLE_COND;
1026 : }
1027 :
1028 : template <>
1029 : template <>
1030 : inline bool
1031 2044511403 : is_a_helper <const gcond *>::test (const gimple *gs)
1032 : {
1033 2044511403 : return gs->code == GIMPLE_COND;
1034 : }
1035 :
1036 : template <>
1037 : template <>
1038 : inline bool
1039 90529329 : is_a_helper <gdebug *>::test (gimple *gs)
1040 : {
1041 90529329 : return gs->code == GIMPLE_DEBUG;
1042 : }
1043 :
1044 : template <>
1045 : template <>
1046 : inline bool
1047 40126 : is_a_helper <const gdebug *>::test (const gimple *gs)
1048 : {
1049 40126 : return gs->code == GIMPLE_DEBUG;
1050 : }
1051 :
1052 : template <>
1053 : template <>
1054 : inline bool
1055 39800743 : is_a_helper <ggoto *>::test (gimple *gs)
1056 : {
1057 39800743 : return gs->code == GIMPLE_GOTO;
1058 : }
1059 :
1060 : template <>
1061 : template <>
1062 : inline bool
1063 4647 : is_a_helper <const ggoto *>::test (const gimple *gs)
1064 : {
1065 4647 : return gs->code == GIMPLE_GOTO;
1066 : }
1067 :
1068 : template <>
1069 : template <>
1070 : inline bool
1071 15599841858 : is_a_helper <glabel *>::test (gimple *gs)
1072 : {
1073 15599841858 : return gs->code == GIMPLE_LABEL;
1074 : }
1075 :
1076 : template <>
1077 : template <>
1078 : inline bool
1079 181522 : is_a_helper <const glabel *>::test (const gimple *gs)
1080 : {
1081 181522 : return gs->code == GIMPLE_LABEL;
1082 : }
1083 :
1084 : template <>
1085 : template <>
1086 : inline bool
1087 9829414 : is_a_helper <gresx *>::test (gimple *gs)
1088 : {
1089 9829414 : return gs->code == GIMPLE_RESX;
1090 : }
1091 :
1092 : template <>
1093 : template <>
1094 : inline bool
1095 2243725 : is_a_helper <geh_dispatch *>::test (gimple *gs)
1096 : {
1097 2243725 : return gs->code == GIMPLE_EH_DISPATCH;
1098 : }
1099 :
1100 : template <>
1101 : template <>
1102 : inline bool
1103 11954 : is_a_helper <geh_else *>::test (gimple *gs)
1104 : {
1105 11954 : return gs->code == GIMPLE_EH_ELSE;
1106 : }
1107 :
1108 : template <>
1109 : template <>
1110 : inline bool
1111 0 : is_a_helper <const geh_else *>::test (const gimple *gs)
1112 : {
1113 0 : return gs->code == GIMPLE_EH_ELSE;
1114 : }
1115 :
1116 : template <>
1117 : template <>
1118 : inline bool
1119 45777 : is_a_helper <geh_filter *>::test (gimple *gs)
1120 : {
1121 45777 : return gs->code == GIMPLE_EH_FILTER;
1122 : }
1123 :
1124 : template <>
1125 : template <>
1126 : inline bool
1127 2686131 : is_a_helper <geh_mnt *>::test (gimple *gs)
1128 : {
1129 2686131 : return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1130 : }
1131 :
1132 : template <>
1133 : template <>
1134 : inline bool
1135 879 : is_a_helper <const geh_mnt *>::test (const gimple *gs)
1136 : {
1137 879 : return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1138 : }
1139 :
1140 : template <>
1141 : template <>
1142 : inline bool
1143 73579 : is_a_helper <gomp_atomic_load *>::test (gimple *gs)
1144 : {
1145 73579 : return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1146 : }
1147 :
1148 : template <>
1149 : template <>
1150 : inline bool
1151 70695 : is_a_helper <gomp_atomic_store *>::test (gimple *gs)
1152 : {
1153 70695 : return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1154 : }
1155 :
1156 : template <>
1157 : template <>
1158 : inline bool
1159 406881 : is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
1160 : {
1161 406881 : return gs->code == GIMPLE_OMP_RETURN;
1162 : }
1163 :
1164 : template <>
1165 : template <>
1166 : inline bool
1167 286530 : is_a_helper <gomp_continue *>::test (gimple *gs)
1168 : {
1169 286530 : return gs->code == GIMPLE_OMP_CONTINUE;
1170 : }
1171 :
1172 : template <>
1173 : template <>
1174 : inline bool
1175 3156 : is_a_helper <gomp_critical *>::test (gimple *gs)
1176 : {
1177 3156 : return gs->code == GIMPLE_OMP_CRITICAL;
1178 : }
1179 :
1180 : template <>
1181 : template <>
1182 : inline bool
1183 12970 : is_a_helper <gomp_ordered *>::test (gimple *gs)
1184 : {
1185 12970 : return gs->code == GIMPLE_OMP_ORDERED;
1186 : }
1187 :
1188 : template <>
1189 : template <>
1190 : inline bool
1191 5479 : is_a_helper <gomp_scan *>::test (gimple *gs)
1192 : {
1193 5479 : return gs->code == GIMPLE_OMP_SCAN;
1194 : }
1195 :
1196 : template <>
1197 : template <>
1198 : inline bool
1199 2975191 : is_a_helper <gomp_for *>::test (gimple *gs)
1200 : {
1201 2975191 : return gs->code == GIMPLE_OMP_FOR;
1202 : }
1203 :
1204 : template <>
1205 : template <>
1206 : inline bool
1207 40893 : is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
1208 : {
1209 40893 : return (gs->code == GIMPLE_OMP_PARALLEL
1210 : || gs->code == GIMPLE_OMP_TASK
1211 40893 : || gs->code == GIMPLE_OMP_TEAMS);
1212 : }
1213 :
1214 : template <>
1215 : template <>
1216 : inline bool
1217 64712237 : is_a_helper <gomp_parallel *>::test (gimple *gs)
1218 : {
1219 64712237 : return gs->code == GIMPLE_OMP_PARALLEL;
1220 : }
1221 :
1222 : template <>
1223 : template <>
1224 : inline bool
1225 491071 : is_a_helper <gomp_target *>::test (gimple *gs)
1226 : {
1227 491071 : return gs->code == GIMPLE_OMP_TARGET;
1228 : }
1229 :
1230 : template <>
1231 : template <>
1232 : inline bool
1233 6665 : is_a_helper <gomp_sections *>::test (gimple *gs)
1234 : {
1235 6665 : return gs->code == GIMPLE_OMP_SECTIONS;
1236 : }
1237 :
1238 : template <>
1239 : template <>
1240 : inline bool
1241 8811 : is_a_helper <gomp_single *>::test (gimple *gs)
1242 : {
1243 8811 : return gs->code == GIMPLE_OMP_SINGLE;
1244 : }
1245 :
1246 : template <>
1247 : template <>
1248 : inline bool
1249 155221 : is_a_helper <gomp_teams *>::test (gimple *gs)
1250 : {
1251 155221 : return gs->code == GIMPLE_OMP_TEAMS;
1252 : }
1253 :
1254 : template <>
1255 : template <>
1256 : inline bool
1257 164954 : is_a_helper <gomp_task *>::test (gimple *gs)
1258 : {
1259 164954 : return gs->code == GIMPLE_OMP_TASK;
1260 : }
1261 :
1262 : template <>
1263 : template <>
1264 : inline bool
1265 10540019784 : is_a_helper <gphi *>::test (gimple *gs)
1266 : {
1267 10540017346 : return gs->code == GIMPLE_PHI;
1268 : }
1269 :
1270 : template <>
1271 : template <>
1272 : inline bool
1273 510025199 : is_a_helper <greturn *>::test (gimple *gs)
1274 : {
1275 510025199 : return gs->code == GIMPLE_RETURN;
1276 : }
1277 :
1278 : template <>
1279 : template <>
1280 : inline bool
1281 368349323 : is_a_helper <gswitch *>::test (gimple *gs)
1282 : {
1283 368349323 : return gs->code == GIMPLE_SWITCH;
1284 : }
1285 :
1286 : template <>
1287 : template <>
1288 : inline bool
1289 237549 : is_a_helper <const gswitch *>::test (const gimple *gs)
1290 : {
1291 237549 : return gs->code == GIMPLE_SWITCH;
1292 : }
1293 :
1294 : template <>
1295 : template <>
1296 : inline bool
1297 721 : is_a_helper <gimple_statement_assume *>::test (gimple *gs)
1298 : {
1299 721 : return gs->code == GIMPLE_ASSUME;
1300 : }
1301 :
1302 : template <>
1303 : template <>
1304 : inline bool
1305 115903 : is_a_helper <gtransaction *>::test (gimple *gs)
1306 : {
1307 115903 : return gs->code == GIMPLE_TRANSACTION;
1308 : }
1309 :
1310 : template <>
1311 : template <>
1312 : inline bool
1313 114139421 : is_a_helper <gtry *>::test (gimple *gs)
1314 : {
1315 112669457 : return gs->code == GIMPLE_TRY;
1316 : }
1317 :
1318 : template <>
1319 : template <>
1320 : inline bool
1321 5721 : is_a_helper <const gtry *>::test (const gimple *gs)
1322 : {
1323 5721 : return gs->code == GIMPLE_TRY;
1324 : }
1325 :
1326 : template <>
1327 : template <>
1328 : inline bool
1329 1300982 : is_a_helper <gimple_statement_wce *>::test (gimple *gs)
1330 : {
1331 1300982 : return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
1332 : }
1333 :
1334 : template <>
1335 : template <>
1336 : inline bool
1337 626947 : is_a_helper <const gasm *>::test (const gimple *gs)
1338 : {
1339 626947 : return gs->code == GIMPLE_ASM;
1340 : }
1341 :
1342 : template <>
1343 : template <>
1344 : inline bool
1345 21293 : is_a_helper <const gbind *>::test (const gimple *gs)
1346 : {
1347 21293 : return gs->code == GIMPLE_BIND;
1348 : }
1349 :
1350 : template <>
1351 : template <>
1352 : inline bool
1353 38543652231 : is_a_helper <const gcall *>::test (const gimple *gs)
1354 : {
1355 38543652231 : return gs->code == GIMPLE_CALL;
1356 : }
1357 :
1358 : template <>
1359 : template <>
1360 : inline bool
1361 0 : is_a_helper <const gcatch *>::test (const gimple *gs)
1362 : {
1363 0 : return gs->code == GIMPLE_CATCH;
1364 : }
1365 :
1366 : template <>
1367 : template <>
1368 : inline bool
1369 2372 : is_a_helper <const gresx *>::test (const gimple *gs)
1370 : {
1371 2372 : return gs->code == GIMPLE_RESX;
1372 : }
1373 :
1374 : template <>
1375 : template <>
1376 : inline bool
1377 36 : is_a_helper <const geh_dispatch *>::test (const gimple *gs)
1378 : {
1379 36 : return gs->code == GIMPLE_EH_DISPATCH;
1380 : }
1381 :
1382 : template <>
1383 : template <>
1384 : inline bool
1385 4515 : is_a_helper <const geh_filter *>::test (const gimple *gs)
1386 : {
1387 4515 : return gs->code == GIMPLE_EH_FILTER;
1388 : }
1389 :
1390 : template <>
1391 : template <>
1392 : inline bool
1393 527 : is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
1394 : {
1395 527 : return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1396 : }
1397 :
1398 : template <>
1399 : template <>
1400 : inline bool
1401 527 : is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
1402 : {
1403 527 : return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1404 : }
1405 :
1406 : template <>
1407 : template <>
1408 : inline bool
1409 10327 : is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs)
1410 : {
1411 10327 : return gs->code == GIMPLE_OMP_RETURN;
1412 : }
1413 :
1414 : template <>
1415 : template <>
1416 : inline bool
1417 344 : is_a_helper <const gomp_continue *>::test (const gimple *gs)
1418 : {
1419 344 : return gs->code == GIMPLE_OMP_CONTINUE;
1420 : }
1421 :
1422 : template <>
1423 : template <>
1424 : inline bool
1425 16 : is_a_helper <const gomp_critical *>::test (const gimple *gs)
1426 : {
1427 16 : return gs->code == GIMPLE_OMP_CRITICAL;
1428 : }
1429 :
1430 : template <>
1431 : template <>
1432 : inline bool
1433 37 : is_a_helper <const gomp_ordered *>::test (const gimple *gs)
1434 : {
1435 37 : return gs->code == GIMPLE_OMP_ORDERED;
1436 : }
1437 :
1438 : template <>
1439 : template <>
1440 : inline bool
1441 0 : is_a_helper <const gomp_scan *>::test (const gimple *gs)
1442 : {
1443 0 : return gs->code == GIMPLE_OMP_SCAN;
1444 : }
1445 :
1446 : template <>
1447 : template <>
1448 : inline bool
1449 2622406 : is_a_helper <const gomp_for *>::test (const gimple *gs)
1450 : {
1451 2622406 : return gs->code == GIMPLE_OMP_FOR;
1452 : }
1453 :
1454 : template <>
1455 : template <>
1456 : inline bool
1457 107590 : is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs)
1458 : {
1459 107590 : return (gs->code == GIMPLE_OMP_PARALLEL
1460 : || gs->code == GIMPLE_OMP_TASK
1461 107590 : || gs->code == GIMPLE_OMP_TEAMS);
1462 : }
1463 :
1464 : template <>
1465 : template <>
1466 : inline bool
1467 118677 : is_a_helper <const gomp_parallel *>::test (const gimple *gs)
1468 : {
1469 118677 : return gs->code == GIMPLE_OMP_PARALLEL;
1470 : }
1471 :
1472 : template <>
1473 : template <>
1474 : inline bool
1475 192003 : is_a_helper <const gomp_target *>::test (const gimple *gs)
1476 : {
1477 192003 : return gs->code == GIMPLE_OMP_TARGET;
1478 : }
1479 :
1480 : template <>
1481 : template <>
1482 : inline bool
1483 3454 : is_a_helper <const gomp_sections *>::test (const gimple *gs)
1484 : {
1485 3454 : return gs->code == GIMPLE_OMP_SECTIONS;
1486 : }
1487 :
1488 : template <>
1489 : template <>
1490 : inline bool
1491 3708 : is_a_helper <const gomp_single *>::test (const gimple *gs)
1492 : {
1493 3708 : return gs->code == GIMPLE_OMP_SINGLE;
1494 : }
1495 :
1496 : template <>
1497 : template <>
1498 : inline bool
1499 36299 : is_a_helper <const gomp_teams *>::test (const gimple *gs)
1500 : {
1501 36299 : return gs->code == GIMPLE_OMP_TEAMS;
1502 : }
1503 :
1504 : template <>
1505 : template <>
1506 : inline bool
1507 45539 : is_a_helper <const gomp_task *>::test (const gimple *gs)
1508 : {
1509 45539 : return gs->code == GIMPLE_OMP_TASK;
1510 : }
1511 :
1512 : template <>
1513 : template <>
1514 : inline bool
1515 9465557144 : is_a_helper <const gphi *>::test (const gimple *gs)
1516 : {
1517 9465557144 : return gs->code == GIMPLE_PHI;
1518 : }
1519 :
1520 : template <>
1521 : template <>
1522 : inline bool
1523 100611 : is_a_helper <const greturn *>::test (const gimple *gs)
1524 : {
1525 100611 : return gs->code == GIMPLE_RETURN;
1526 : }
1527 :
1528 : template <>
1529 : template <>
1530 : inline bool
1531 846 : is_a_helper <const gimple_statement_assume *>::test (const gimple *gs)
1532 : {
1533 846 : return gs->code == GIMPLE_ASSUME;
1534 : }
1535 :
1536 : template <>
1537 : template <>
1538 : inline bool
1539 77 : is_a_helper <const gtransaction *>::test (const gimple *gs)
1540 : {
1541 77 : return gs->code == GIMPLE_TRANSACTION;
1542 : }
1543 :
1544 : /* Offset in bytes to the location of the operand vector.
1545 : Zero if there is no operand vector for this tuple structure. */
1546 : extern size_t const gimple_ops_offset_[];
1547 :
1548 : /* Map GIMPLE codes to GSS codes. */
1549 : extern enum gimple_statement_structure_enum const gss_for_code_[];
1550 :
1551 : /* This variable holds the currently expanded gimple statement for purposes
1552 : of communicating the profile info to the builtin expanders. */
1553 : extern gimple *currently_expanding_gimple_stmt;
1554 :
1555 : size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
1556 : void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
1557 : gimple *gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO);
1558 : greturn *gimple_build_return (tree);
1559 : void gimple_call_reset_alias_info (gcall *);
1560 : gcall *gimple_build_call_vec (tree, const vec<tree> &);
1561 : gcall *gimple_build_call (tree, unsigned, ...);
1562 : gcall *gimple_build_call_valist (tree, unsigned, va_list);
1563 : gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
1564 : gcall *gimple_build_call_internal_vec (enum internal_fn, const vec<tree> &);
1565 : gcall *gimple_build_call_from_tree (tree, tree);
1566 : gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO);
1567 : gassign *gimple_build_assign (tree, enum tree_code,
1568 : tree, tree, tree CXX_MEM_STAT_INFO);
1569 : gassign *gimple_build_assign (tree, enum tree_code,
1570 : tree, tree CXX_MEM_STAT_INFO);
1571 : gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
1572 : gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
1573 : gcond *gimple_build_cond_from_tree (tree, tree, tree);
1574 : void gimple_cond_set_condition_from_tree (gcond *, tree);
1575 : glabel *gimple_build_label (tree label);
1576 : ggoto *gimple_build_goto (tree dest);
1577 : gimple *gimple_build_nop (void);
1578 : gbind *gimple_build_bind (tree, gimple_seq, tree);
1579 : gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
1580 : vec<tree, va_gc> *, vec<tree, va_gc> *,
1581 : vec<tree, va_gc> *);
1582 : gcatch *gimple_build_catch (tree, gimple_seq);
1583 : geh_filter *gimple_build_eh_filter (tree, gimple_seq);
1584 : geh_mnt *gimple_build_eh_must_not_throw (tree);
1585 : geh_else *gimple_build_eh_else (gimple_seq, gimple_seq);
1586 : gtry *gimple_build_try (gimple_seq, gimple_seq,
1587 : enum gimple_try_flags);
1588 : gimple *gimple_build_wce (gimple_seq);
1589 : gresx *gimple_build_resx (int);
1590 : gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
1591 : gswitch *gimple_build_switch (tree, tree, const vec<tree> &);
1592 : geh_dispatch *gimple_build_eh_dispatch (int);
1593 : gdebug *gimple_build_debug_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1594 : gdebug *gimple_build_debug_source_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1595 : gdebug *gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO);
1596 : gdebug *gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO);
1597 : gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree);
1598 : gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
1599 : gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
1600 : gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree,
1601 : tree, tree);
1602 : gimple *gimple_build_omp_section (gimple_seq);
1603 : gimple *gimple_build_omp_structured_block (gimple_seq);
1604 : gimple *gimple_build_omp_scope (gimple_seq, tree);
1605 : gimple *gimple_build_omp_dispatch (gimple_seq, tree);
1606 : gimple *gimple_build_omp_interop (tree);
1607 : gimple *gimple_build_omp_master (gimple_seq);
1608 : gimple *gimple_build_omp_masked (gimple_seq, tree);
1609 : gimple *gimple_build_omp_taskgroup (gimple_seq, tree);
1610 : gomp_continue *gimple_build_omp_continue (tree, tree);
1611 : gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree);
1612 : gimple *gimple_build_omp_return (bool);
1613 : gomp_scan *gimple_build_omp_scan (gimple_seq, tree);
1614 : gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
1615 : gimple *gimple_build_omp_sections_switch (void);
1616 : gomp_single *gimple_build_omp_single (gimple_seq, tree);
1617 : gomp_target *gimple_build_omp_target (gimple_seq, int, tree, gimple_seq = NULL);
1618 : gomp_teams *gimple_build_omp_teams (gimple_seq, tree);
1619 : gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree,
1620 : enum omp_memory_order);
1621 : gomp_atomic_store *gimple_build_omp_atomic_store (tree, enum omp_memory_order);
1622 : gimple *gimple_build_assume (tree, gimple_seq);
1623 : gtransaction *gimple_build_transaction (gimple_seq);
1624 : extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
1625 : extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
1626 : void gimple_seq_add_seq (gimple_seq *, gimple_seq);
1627 : void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq);
1628 : extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
1629 : location_t);
1630 : extern void annotate_all_with_location (gimple_seq, location_t);
1631 : bool empty_body_p (gimple_seq);
1632 : gimple_seq gimple_seq_copy (gimple_seq);
1633 : bool gimple_call_same_target_p (const gimple *, const gimple *);
1634 : int gimple_call_flags (const gimple *);
1635 : int gimple_call_arg_flags (const gcall *, unsigned);
1636 : int gimple_call_retslot_flags (const gcall *);
1637 : int gimple_call_static_chain_flags (const gcall *);
1638 : int gimple_call_return_flags (const gcall *);
1639 : bool gimple_call_nonnull_result_p (gcall *);
1640 : tree gimple_call_nonnull_arg (gcall *);
1641 : bool gimple_assign_copy_p (gimple *);
1642 : bool gimple_assign_ssa_name_copy_p (gimple *);
1643 : bool gimple_assign_unary_nop_p (gimple *);
1644 : bool gimple_assign_load_p (const gimple *);
1645 : void gimple_set_bb (gimple *, basic_block);
1646 : void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
1647 : void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
1648 : tree, tree, tree);
1649 : tree gimple_get_lhs (const gimple *);
1650 : void gimple_set_lhs (gimple *, tree);
1651 : gimple *gimple_copy (gimple *);
1652 : void gimple_move_vops (gimple *, gimple *);
1653 : bool gimple_has_side_effects (const gimple *);
1654 : bool gimple_could_trap_p_1 (const gimple *, bool, bool);
1655 : bool gimple_could_trap_p (const gimple *);
1656 : bool gimple_assign_rhs_could_trap_p (gimple *);
1657 : extern void dump_gimple_statistics (void);
1658 : unsigned get_gimple_rhs_num_ops (enum tree_code);
1659 : gcall *gimple_call_copy_skip_args (gcall *, bitmap);
1660 : extern bool gimple_compare_field_offset (tree, tree);
1661 : extern tree gimple_unsigned_type (tree);
1662 : extern tree gimple_signed_type (tree);
1663 : extern alias_set_type gimple_get_alias_set (tree);
1664 : extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
1665 : extern combined_fn gimple_call_combined_fn (const gimple *);
1666 : extern bool gimple_call_operator_delete_p (const gcall *);
1667 : extern bool gimple_call_builtin_p (const gimple *);
1668 : extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
1669 : extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
1670 : extern bool gimple_asm_clobbers_memory_p (const gasm *);
1671 : extern void dump_decl_set (FILE *, bitmap);
1672 : extern bool nonfreeing_call_p (gimple *);
1673 : extern bool nonbarrier_call_p (gimple *);
1674 : extern bool infer_nonnull_range (gimple *, tree);
1675 : extern bool infer_nonnull_range_by_dereference (gimple *, tree);
1676 : extern bool infer_nonnull_range_by_attribute (gimple *, tree, tree * = NULL,
1677 : tree * = NULL);
1678 : extern void sort_case_labels (vec<tree> &);
1679 : extern void preprocess_case_label_vec_for_gimple (vec<tree> &, tree, tree *);
1680 : extern void gimple_seq_set_location (gimple_seq, location_t);
1681 : extern void gimple_seq_discard (gimple_seq);
1682 : extern void maybe_remove_unused_call_args (struct function *, gimple *);
1683 : extern bool gimple_inexpensive_call_p (gcall *);
1684 : extern bool stmt_can_terminate_bb_p (gimple *);
1685 : extern location_t gimple_or_expr_nonartificial_location (gimple *, tree);
1686 : gcall *gimple_build_builtin_unreachable (location_t);
1687 :
1688 : /* Return the disposition for a warning (or all warnings by default)
1689 : for a statement. */
1690 : extern bool warning_suppressed_p (const gimple *, opt_code = all_warnings)
1691 : ATTRIBUTE_NONNULL (1);
1692 : /* Set the disposition for a warning (or all warnings by default)
1693 : at a location to enabled by default. */
1694 : extern void suppress_warning (gimple *, opt_code = all_warnings,
1695 : bool = true) ATTRIBUTE_NONNULL (1);
1696 :
1697 : /* Copy the warning disposition mapping from one statement to another. */
1698 : extern void copy_warning (gimple *, const gimple *)
1699 : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1700 : /* Copy the warning disposition mapping from an expression to a statement. */
1701 : extern void copy_warning (gimple *, const_tree)
1702 : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1703 : /* Copy the warning disposition mapping from a statement to an expression. */
1704 : extern void copy_warning (tree, const gimple *)
1705 : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1706 :
1707 : /* Formal (expression) temporary table handling: multiple occurrences of
1708 : the same scalar expression are evaluated into the same temporary. */
1709 :
1710 : typedef struct gimple_temp_hash_elt
1711 : {
1712 : tree val; /* Key */
1713 : tree temp; /* Value */
1714 : } elt_t;
1715 :
1716 : /* Get the number of the next statement uid to be allocated. */
1717 : inline unsigned int
1718 8812015 : gimple_stmt_max_uid (struct function *fn)
1719 : {
1720 8812015 : return fn->last_stmt_uid;
1721 : }
1722 :
1723 : /* Set the number of the next statement uid to be allocated. */
1724 : inline void
1725 21211277 : set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
1726 : {
1727 21211277 : fn->last_stmt_uid = maxid;
1728 : }
1729 :
1730 : /* Set the number of the next statement uid to be allocated. */
1731 : inline unsigned int
1732 1166066694 : inc_gimple_stmt_max_uid (struct function *fn)
1733 : {
1734 1166066694 : return fn->last_stmt_uid++;
1735 : }
1736 :
1737 : /* Return the first node in GIMPLE sequence S. */
1738 :
1739 : inline gimple_seq_node
1740 : gimple_seq_first (gimple_seq s)
1741 : {
1742 : return s;
1743 : }
1744 :
1745 :
1746 : /* Return the first statement in GIMPLE sequence S. */
1747 :
1748 : inline gimple *
1749 : gimple_seq_first_stmt (gimple_seq s)
1750 : {
1751 10349069 : gimple_seq_node n = gimple_seq_first (s);
1752 : return n;
1753 : }
1754 :
1755 : /* Return the first statement in GIMPLE sequence S as a gbind *,
1756 : verifying that it has code GIMPLE_BIND in a checked build. */
1757 :
1758 : inline gbind *
1759 25384 : gimple_seq_first_stmt_as_a_bind (gimple_seq s)
1760 : {
1761 25384 : gimple_seq_node n = gimple_seq_first (s);
1762 25384 : return as_a <gbind *> (n);
1763 : }
1764 :
1765 :
1766 : /* Return the last node in GIMPLE sequence S. */
1767 :
1768 : inline gimple_seq_node
1769 7559686020 : gimple_seq_last (gimple_seq s)
1770 : {
1771 7557317682 : return s ? s->prev : NULL;
1772 : }
1773 :
1774 :
1775 : /* Return the last statement in GIMPLE sequence S. */
1776 :
1777 : inline gimple *
1778 2616855 : gimple_seq_last_stmt (gimple_seq s)
1779 : {
1780 1108934 : gimple_seq_node n = gimple_seq_last (s);
1781 1698102 : return n;
1782 : }
1783 :
1784 :
1785 : /* Set the last node in GIMPLE sequence *PS to LAST. */
1786 :
1787 : inline void
1788 490573521 : gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
1789 : {
1790 489926155 : (*ps)->prev = last;
1791 : }
1792 :
1793 :
1794 : /* Set the first node in GIMPLE sequence *PS to FIRST. */
1795 :
1796 : inline void
1797 225664228 : gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
1798 : {
1799 226311594 : *ps = first;
1800 : }
1801 :
1802 :
1803 : /* Return true if GIMPLE sequence S is empty. */
1804 :
1805 : inline bool
1806 141031742 : gimple_seq_empty_p (gimple_seq s)
1807 : {
1808 141031742 : return s == NULL;
1809 : }
1810 :
1811 : /* Allocate a new sequence and initialize its first element with STMT. */
1812 :
1813 : inline gimple_seq
1814 14033395 : gimple_seq_alloc_with_stmt (gimple *stmt)
1815 : {
1816 14033395 : gimple_seq seq = NULL;
1817 14033395 : gimple_seq_add_stmt (&seq, stmt);
1818 14033395 : return seq;
1819 : }
1820 :
1821 :
1822 : /* Returns the sequence of statements in BB. */
1823 :
1824 : inline gimple_seq
1825 101490555 : bb_seq (const_basic_block bb)
1826 : {
1827 101490555 : return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL;
1828 : }
1829 :
1830 : inline gimple_seq *
1831 20052119308 : bb_seq_addr (basic_block bb)
1832 : {
1833 20018947365 : return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL;
1834 : }
1835 :
1836 : /* Sets the sequence of statements in BB to SEQ. */
1837 :
1838 : inline void
1839 97279589 : set_bb_seq (basic_block bb, gimple_seq seq)
1840 : {
1841 97279589 : gcc_checking_assert (!(bb->flags & BB_RTL));
1842 97279589 : bb->il.gimple.seq = seq;
1843 97279589 : }
1844 :
1845 :
1846 : /* Return the code for GIMPLE statement G. */
1847 :
1848 : inline enum gimple_code
1849 >63487*10^7 : gimple_code (const gimple *g)
1850 : {
1851 >21146*10^7 : return g->code;
1852 : }
1853 :
1854 :
1855 : /* Return the GSS code used by a GIMPLE code. */
1856 :
1857 : inline enum gimple_statement_structure_enum
1858 >10878*10^7 : gss_for_code (enum gimple_code code)
1859 : {
1860 >10878*10^7 : gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
1861 >10878*10^7 : return gss_for_code_[code];
1862 : }
1863 :
1864 :
1865 : /* Return which GSS code is used by GS. */
1866 :
1867 : inline enum gimple_statement_structure_enum
1868 >10837*10^7 : gimple_statement_structure (gimple *gs)
1869 : {
1870 59339245821 : return gss_for_code (gimple_code (gs));
1871 : }
1872 :
1873 :
1874 : /* Return true if statement G has sub-statements. This is only true for
1875 : High GIMPLE statements. */
1876 :
1877 : inline bool
1878 420087797 : gimple_has_substatements (gimple *g)
1879 : {
1880 420087797 : switch (gimple_code (g))
1881 : {
1882 : case GIMPLE_ASSUME:
1883 : case GIMPLE_BIND:
1884 : case GIMPLE_CATCH:
1885 : case GIMPLE_EH_FILTER:
1886 : case GIMPLE_EH_ELSE:
1887 : case GIMPLE_TRY:
1888 : case GIMPLE_OMP_FOR:
1889 : case GIMPLE_OMP_MASTER:
1890 : case GIMPLE_OMP_MASKED:
1891 : case GIMPLE_OMP_TASKGROUP:
1892 : case GIMPLE_OMP_ORDERED:
1893 : case GIMPLE_OMP_SECTION:
1894 : case GIMPLE_OMP_STRUCTURED_BLOCK:
1895 : case GIMPLE_OMP_PARALLEL:
1896 : case GIMPLE_OMP_TASK:
1897 : case GIMPLE_OMP_SCOPE:
1898 : case GIMPLE_OMP_DISPATCH:
1899 : case GIMPLE_OMP_SECTIONS:
1900 : case GIMPLE_OMP_SINGLE:
1901 : case GIMPLE_OMP_TARGET:
1902 : case GIMPLE_OMP_TEAMS:
1903 : case GIMPLE_OMP_CRITICAL:
1904 : case GIMPLE_WITH_CLEANUP_EXPR:
1905 : case GIMPLE_TRANSACTION:
1906 : return true;
1907 :
1908 419999571 : default:
1909 419999571 : return false;
1910 : }
1911 : }
1912 :
1913 :
1914 : /* Return the basic block holding statement G. */
1915 :
1916 : inline basic_block
1917 37449887725 : gimple_bb (const gimple *g)
1918 : {
1919 35303764299 : return g->bb;
1920 : }
1921 :
1922 :
1923 : /* Return the lexical scope block holding statement G. */
1924 :
1925 : inline tree
1926 1632763973 : gimple_block (const gimple *g)
1927 : {
1928 1632763973 : return LOCATION_BLOCK (g->location);
1929 : }
1930 :
1931 : /* Forward declare. */
1932 : inline void gimple_set_location (gimple *, location_t);
1933 :
1934 : /* Set BLOCK to be the lexical scope block holding statement G. */
1935 :
1936 : inline void
1937 191316204 : gimple_set_block (gimple *g, tree block)
1938 : {
1939 191316204 : gimple_set_location (g, set_block (g->location, block));
1940 191316204 : }
1941 :
1942 : /* Return location information for statement G. */
1943 :
1944 : inline location_t
1945 16485803979 : gimple_location (const gimple *g)
1946 : {
1947 16389340297 : return g->location;
1948 : }
1949 :
1950 : /* Return location information for statement G if g is not NULL.
1951 : Otherwise, UNKNOWN_LOCATION is returned. */
1952 :
1953 : inline location_t
1954 : gimple_location_safe (const gimple *g)
1955 : {
1956 : return g ? gimple_location (g) : UNKNOWN_LOCATION;
1957 : }
1958 :
1959 : /* Set location information for statement G. */
1960 :
1961 : inline void
1962 478327567 : gimple_set_location (gimple *g, location_t location)
1963 : {
1964 : /* Copy the no-warning data to the statement location. */
1965 454282325 : if (g->location != UNKNOWN_LOCATION)
1966 256341756 : copy_warning (location, g->location);
1967 292900865 : g->location = location;
1968 : }
1969 :
1970 : /* Return address of the location information for statement G. */
1971 :
1972 : inline location_t *
1973 1446135 : gimple_location_ptr (gimple *g)
1974 : {
1975 1446135 : return &g->location;
1976 : }
1977 :
1978 :
1979 : /* Return true if G contains location information. */
1980 :
1981 : inline bool
1982 766624369 : gimple_has_location (const gimple *g)
1983 : {
1984 766624369 : return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
1985 : }
1986 :
1987 :
1988 : /* Return non-artificial location information for statement G. */
1989 :
1990 : inline location_t
1991 172519 : gimple_nonartificial_location (const gimple *g)
1992 : {
1993 172519 : location_t *ploc = NULL;
1994 :
1995 172519 : if (tree block = gimple_block (g))
1996 170609 : ploc = block_nonartificial_location (block);
1997 :
1998 172519 : return ploc ? *ploc : gimple_location (g);
1999 : }
2000 :
2001 :
2002 : /* Return the file name of the location of STMT. */
2003 :
2004 : inline const char *
2005 15190 : gimple_filename (const gimple *stmt)
2006 : {
2007 15190 : return LOCATION_FILE (gimple_location (stmt));
2008 : }
2009 :
2010 :
2011 : /* Return the line number of the location of STMT. */
2012 :
2013 : inline int
2014 29901 : gimple_lineno (const gimple *stmt)
2015 : {
2016 15199 : return LOCATION_LINE (gimple_location (stmt));
2017 : }
2018 :
2019 :
2020 : /* Determine whether SEQ is a singleton. */
2021 :
2022 : inline bool
2023 455925 : gimple_seq_singleton_p (gimple_seq seq)
2024 : {
2025 455925 : return ((gimple_seq_first (seq) != NULL)
2026 455925 : && (gimple_seq_first (seq) == gimple_seq_last (seq)));
2027 : }
2028 :
2029 : /* Return true if no warnings should be emitted for statement STMT. */
2030 :
2031 : inline bool
2032 1731191 : gimple_no_warning_p (const gimple *stmt)
2033 : {
2034 1731191 : return stmt->no_warning;
2035 : }
2036 :
2037 : /* Set the no_warning flag of STMT to NO_WARNING. */
2038 :
2039 : inline void
2040 : gimple_set_no_warning (gimple *stmt, bool no_warning)
2041 : {
2042 : stmt->no_warning = (unsigned) no_warning;
2043 : }
2044 :
2045 : /* Set the visited status on statement STMT to VISITED_P.
2046 :
2047 : Please note that this 'visited' property of the gimple statement is
2048 : supposed to be undefined at pass boundaries. This means that a
2049 : given pass should not assume it contains any useful value when the
2050 : pass starts and thus can set it to any value it sees fit.
2051 :
2052 : You can learn more about the visited property of the gimple
2053 : statement by reading the comments of the 'visited' data member of
2054 : struct gimple.
2055 : */
2056 :
2057 : inline void
2058 2435868446 : gimple_set_visited (gimple *stmt, bool visited_p)
2059 : {
2060 2435868446 : stmt->visited = (unsigned) visited_p;
2061 : }
2062 :
2063 :
2064 : /* Return the visited status for statement STMT.
2065 :
2066 : Please note that this 'visited' property of the gimple statement is
2067 : supposed to be undefined at pass boundaries. This means that a
2068 : given pass should not assume it contains any useful value when the
2069 : pass starts and thus can set it to any value it sees fit.
2070 :
2071 : You can learn more about the visited property of the gimple
2072 : statement by reading the comments of the 'visited' data member of
2073 : struct gimple. */
2074 :
2075 : inline bool
2076 7362210407 : gimple_visited_p (gimple *stmt)
2077 : {
2078 7362210407 : return stmt->visited;
2079 : }
2080 :
2081 :
2082 : /* Set pass local flag PLF on statement STMT to VAL_P.
2083 :
2084 : Please note that this PLF property of the gimple statement is
2085 : supposed to be undefined at pass boundaries. This means that a
2086 : given pass should not assume it contains any useful value when the
2087 : pass starts and thus can set it to any value it sees fit.
2088 :
2089 : You can learn more about the PLF property by reading the comment of
2090 : the 'plf' data member of struct gimple_statement_structure. */
2091 :
2092 : inline void
2093 3207817140 : gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
2094 : {
2095 3207817140 : if (val_p)
2096 1313459647 : stmt->plf |= (unsigned int) plf;
2097 : else
2098 1894357493 : stmt->plf &= ~((unsigned int) plf);
2099 : }
2100 :
2101 :
2102 : /* Return the value of pass local flag PLF on statement STMT.
2103 :
2104 : Please note that this 'plf' property of the gimple statement is
2105 : supposed to be undefined at pass boundaries. This means that a
2106 : given pass should not assume it contains any useful value when the
2107 : pass starts and thus can set it to any value it sees fit.
2108 :
2109 : You can learn more about the plf property by reading the comment of
2110 : the 'plf' data member of struct gimple_statement_structure. */
2111 :
2112 : inline unsigned int
2113 5192509115 : gimple_plf (gimple *stmt, enum plf_mask plf)
2114 : {
2115 5151719603 : return stmt->plf & ((unsigned int) plf);
2116 : }
2117 :
2118 :
2119 : /* Set the UID of statement.
2120 :
2121 : Please note that this UID property is supposed to be undefined at
2122 : pass boundaries. This means that a given pass should not assume it
2123 : contains any useful value when the pass starts and thus can set it
2124 : to any value it sees fit. */
2125 :
2126 : inline void
2127 2073971281 : gimple_set_uid (gimple *g, unsigned uid)
2128 : {
2129 2073915538 : g->uid = uid;
2130 : }
2131 :
2132 :
2133 : /* Return the UID of statement.
2134 :
2135 : Please note that this UID property is supposed to be undefined at
2136 : pass boundaries. This means that a given pass should not assume it
2137 : contains any useful value when the pass starts and thus can set it
2138 : to any value it sees fit. */
2139 :
2140 : inline unsigned
2141 2219184830 : gimple_uid (const gimple *g)
2142 : {
2143 2212136228 : return g->uid;
2144 : }
2145 :
2146 :
2147 : /* Make statement G a singleton sequence. */
2148 :
2149 : inline void
2150 433574719 : gimple_init_singleton (gimple *g)
2151 : {
2152 433574719 : g->next = NULL;
2153 99254380 : g->prev = g;
2154 : }
2155 :
2156 :
2157 : /* Return true if GIMPLE statement G has register or memory operands. */
2158 :
2159 : inline bool
2160 >13810*10^7 : gimple_has_ops (const gimple *g)
2161 : {
2162 >13810*10^7 : return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
2163 : }
2164 :
2165 : template <>
2166 : template <>
2167 : inline bool
2168 28497867479 : is_a_helper <const gimple_statement_with_ops *>::test (const gimple *gs)
2169 : {
2170 71271794550 : return gimple_has_ops (gs);
2171 : }
2172 :
2173 : template <>
2174 : template <>
2175 : inline bool
2176 491097623 : is_a_helper <gimple_statement_with_ops *>::test (gimple *gs)
2177 : {
2178 982195246 : return gimple_has_ops (gs);
2179 : }
2180 :
2181 : /* Return true if GIMPLE statement G has memory operands. */
2182 :
2183 : inline bool
2184 >11700*10^7 : gimple_has_mem_ops (const gimple *g)
2185 : {
2186 61511131900 : return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
2187 : }
2188 :
2189 : template <>
2190 : template <>
2191 : inline bool
2192 42489355408 : is_a_helper <const gimple_statement_with_memory_ops *>::test (const gimple *gs)
2193 : {
2194 >14300*10^7 : return gimple_has_mem_ops (gs);
2195 : }
2196 :
2197 : template <>
2198 : template <>
2199 : inline bool
2200 600179728 : is_a_helper <gimple_statement_with_memory_ops *>::test (gimple *gs)
2201 : {
2202 2802665411 : return gimple_has_mem_ops (gs);
2203 : }
2204 :
2205 : /* Return the set of USE operands for statement G. */
2206 :
2207 : inline struct use_optype_d *
2208 28497881905 : gimple_use_ops (const gimple *g)
2209 : {
2210 28497867479 : const gimple_statement_with_ops *ops_stmt =
2211 42773921294 : dyn_cast <const gimple_statement_with_ops *> (g);
2212 28354129808 : if (!ops_stmt)
2213 : return NULL;
2214 28354129808 : return ops_stmt->use_ops;
2215 : }
2216 :
2217 :
2218 : /* Set USE to be the set of USE operands for statement G. */
2219 :
2220 : inline void
2221 491097623 : gimple_set_use_ops (gimple *g, struct use_optype_d *use)
2222 : {
2223 491097623 : gimple_statement_with_ops *ops_stmt =
2224 491097623 : as_a <gimple_statement_with_ops *> (g);
2225 74892960 : ops_stmt->use_ops = use;
2226 : }
2227 :
2228 :
2229 : /* Return the single VUSE operand of the statement G. */
2230 :
2231 : inline tree
2232 49918775612 : gimple_vuse (const gimple *g)
2233 : {
2234 53002761751 : const gimple_statement_with_memory_ops *mem_ops_stmt =
2235 57533390451 : dyn_cast <const gimple_statement_with_memory_ops *> (g);
2236 24856025754 : if (!mem_ops_stmt)
2237 : return NULL_TREE;
2238 24743222339 : return mem_ops_stmt->vuse;
2239 : }
2240 :
2241 : /* Return the single VDEF operand of the statement G. */
2242 :
2243 : inline tree
2244 25098208008 : gimple_vdef (const gimple *g)
2245 : {
2246 36725726484 : const gimple_statement_with_memory_ops *mem_ops_stmt =
2247 46774686266 : dyn_cast <const gimple_statement_with_memory_ops *> (g);
2248 16400770146 : if (!mem_ops_stmt)
2249 : return NULL_TREE;
2250 16366417543 : return mem_ops_stmt->vdef;
2251 : }
2252 :
2253 : /* Return the single VUSE operand of the statement G. */
2254 :
2255 : inline tree *
2256 102379161 : gimple_vuse_ptr (gimple *g)
2257 : {
2258 102379161 : gimple_statement_with_memory_ops *mem_ops_stmt =
2259 102379161 : dyn_cast <gimple_statement_with_memory_ops *> (g);
2260 102379161 : if (!mem_ops_stmt)
2261 : return NULL;
2262 102379161 : return &mem_ops_stmt->vuse;
2263 : }
2264 :
2265 : /* Return the single VDEF operand of the statement G. */
2266 :
2267 : inline tree *
2268 168323917 : gimple_vdef_ptr (gimple *g)
2269 : {
2270 168323917 : gimple_statement_with_memory_ops *mem_ops_stmt =
2271 1661519385 : dyn_cast <gimple_statement_with_memory_ops *> (g);
2272 168323917 : if (!mem_ops_stmt)
2273 : return NULL;
2274 168323917 : return &mem_ops_stmt->vdef;
2275 : }
2276 :
2277 : /* Set the single VUSE operand of the statement G. */
2278 :
2279 : inline void
2280 220102383 : gimple_set_vuse (gimple *g, tree vuse)
2281 : {
2282 220102383 : gimple_statement_with_memory_ops *mem_ops_stmt =
2283 220167423 : as_a <gimple_statement_with_memory_ops *> (g);
2284 220102383 : mem_ops_stmt->vuse = vuse;
2285 : }
2286 :
2287 : /* Set the single VDEF operand of the statement G. */
2288 :
2289 : inline void
2290 109374267 : gimple_set_vdef (gimple *g, tree vdef)
2291 : {
2292 109374267 : gimple_statement_with_memory_ops *mem_ops_stmt =
2293 109440560 : as_a <gimple_statement_with_memory_ops *> (g);
2294 109374267 : mem_ops_stmt->vdef = vdef;
2295 : }
2296 :
2297 :
2298 : /* Return true if statement G has operands and the modified field has
2299 : been set. */
2300 :
2301 : inline bool
2302 15951157359 : gimple_modified_p (const gimple *g)
2303 : {
2304 31886258418 : return (gimple_has_ops (g)) ? (bool) g->modified : false;
2305 : }
2306 :
2307 :
2308 : /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2309 : a MODIFIED field. */
2310 :
2311 : inline void
2312 865198061 : gimple_set_modified (gimple *s, bool modifiedp)
2313 : {
2314 1281402724 : if (gimple_has_ops (s))
2315 : {
2316 860262538 : s->modified = (unsigned) modifiedp;
2317 : // Mark the LHS as out of date with the current range query.
2318 860262538 : if (modifiedp)
2319 : {
2320 444057875 : tree def = gimple_get_lhs (s);
2321 444057875 : if (def && TREE_CODE (def) == SSA_NAME)
2322 253229946 : get_range_query (cfun)->update_range_info (def);
2323 : }
2324 : }
2325 448993398 : }
2326 :
2327 :
2328 : /* Return true if statement STMT contains volatile operands. */
2329 :
2330 : inline bool
2331 25794267048 : gimple_has_volatile_ops (const gimple *stmt)
2332 : {
2333 36827903450 : if (gimple_has_mem_ops (stmt))
2334 11046736664 : return stmt->has_volatile_ops;
2335 : else
2336 : return false;
2337 : }
2338 :
2339 :
2340 : /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2341 :
2342 : inline void
2343 12466085723 : gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
2344 : {
2345 23115395440 : if (gimple_has_mem_ops (stmt))
2346 5137724917 : stmt->has_volatile_ops = (unsigned) volatilep;
2347 : }
2348 :
2349 : /* Return true if STMT is in a transaction. */
2350 :
2351 : inline bool
2352 434 : gimple_in_transaction (const gimple *stmt)
2353 : {
2354 434 : return bb_in_transaction (gimple_bb (stmt));
2355 : }
2356 :
2357 : /* Return true if statement STMT may access memory. */
2358 :
2359 : inline bool
2360 99945105 : gimple_references_memory_p (gimple *stmt)
2361 : {
2362 412164458 : return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
2363 : }
2364 :
2365 :
2366 : /* Return the subcode for OMP statement S. */
2367 :
2368 : inline unsigned
2369 3451352 : gimple_omp_subcode (const gimple *s)
2370 : {
2371 3451352 : gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
2372 : && gimple_code (s) <= GIMPLE_OMP_ORDERED);
2373 3451352 : return s->subcode;
2374 : }
2375 :
2376 : /* Set the subcode for OMP statement S to SUBCODE. */
2377 :
2378 : inline void
2379 12601 : gimple_omp_set_subcode (gimple *s, unsigned int subcode)
2380 : {
2381 : /* We only have 16 bits for the subcode. Assert that we are not
2382 : overflowing it. */
2383 12601 : gcc_gimple_checking_assert (subcode < (1 << 16));
2384 12601 : s->subcode = subcode;
2385 0 : }
2386 :
2387 : /* Set the nowait flag on OMP_RETURN statement S. */
2388 :
2389 : inline void
2390 38426 : gimple_omp_return_set_nowait (gimple *s)
2391 : {
2392 38426 : GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
2393 38426 : s->subcode |= GF_OMP_RETURN_NOWAIT;
2394 38426 : }
2395 :
2396 :
2397 : /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2398 : flag set. */
2399 :
2400 : inline bool
2401 84805 : gimple_omp_return_nowait_p (const gimple *g)
2402 : {
2403 84805 : GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
2404 84805 : return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
2405 : }
2406 :
2407 :
2408 : /* Set the LHS of OMP return. */
2409 :
2410 : inline void
2411 65 : gimple_omp_return_set_lhs (gimple *g, tree lhs)
2412 : {
2413 65 : gimple_statement_omp_return *omp_return_stmt =
2414 65 : as_a <gimple_statement_omp_return *> (g);
2415 65 : omp_return_stmt->val = lhs;
2416 : }
2417 :
2418 :
2419 : /* Get the LHS of OMP return. */
2420 :
2421 : inline tree
2422 10327 : gimple_omp_return_lhs (const gimple *g)
2423 : {
2424 10327 : const gimple_statement_omp_return *omp_return_stmt =
2425 10327 : as_a <const gimple_statement_omp_return *> (g);
2426 10327 : return omp_return_stmt->val;
2427 : }
2428 :
2429 :
2430 : /* Return a pointer to the LHS of OMP return. */
2431 :
2432 : inline tree *
2433 406816 : gimple_omp_return_lhs_ptr (gimple *g)
2434 : {
2435 406816 : gimple_statement_omp_return *omp_return_stmt =
2436 406816 : as_a <gimple_statement_omp_return *> (g);
2437 406816 : return &omp_return_stmt->val;
2438 : }
2439 :
2440 :
2441 : /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2442 : flag set. */
2443 :
2444 : inline bool
2445 0 : gimple_omp_section_last_p (const gimple *g)
2446 : {
2447 0 : GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2448 0 : return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
2449 : }
2450 :
2451 :
2452 : /* Set the GF_OMP_SECTION_LAST flag on G. */
2453 :
2454 : inline void
2455 386 : gimple_omp_section_set_last (gimple *g)
2456 : {
2457 386 : GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2458 386 : g->subcode |= GF_OMP_SECTION_LAST;
2459 386 : }
2460 :
2461 :
2462 : /* Return true if OMP ordered construct is stand-alone
2463 : (G has the GF_OMP_ORDERED_STANDALONE flag set). */
2464 :
2465 : inline bool
2466 5888 : gimple_omp_ordered_standalone_p (const gimple *g)
2467 : {
2468 5888 : GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2469 5888 : return (gimple_omp_subcode (g) & GF_OMP_ORDERED_STANDALONE) != 0;
2470 : }
2471 :
2472 :
2473 : /* Set the GF_OMP_ORDERED_STANDALONE flag on G. */
2474 :
2475 : inline void
2476 1025 : gimple_omp_ordered_standalone (gimple *g)
2477 : {
2478 1025 : GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2479 1025 : g->subcode |= GF_OMP_ORDERED_STANDALONE;
2480 1025 : }
2481 :
2482 :
2483 : /* Return true if OMP parallel statement G has the
2484 : GF_OMP_PARALLEL_COMBINED flag set. */
2485 :
2486 : inline bool
2487 35913 : gimple_omp_parallel_combined_p (const gimple *g)
2488 : {
2489 35913 : GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2490 35913 : return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
2491 : }
2492 :
2493 :
2494 : /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2495 : value of COMBINED_P. */
2496 :
2497 : inline void
2498 385 : gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
2499 : {
2500 385 : GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2501 385 : if (combined_p)
2502 385 : g->subcode |= GF_OMP_PARALLEL_COMBINED;
2503 : else
2504 0 : g->subcode &= ~GF_OMP_PARALLEL_COMBINED;
2505 385 : }
2506 :
2507 :
2508 : /* Return true if OMP atomic load/store statement G has the
2509 : GF_OMP_ATOMIC_NEED_VALUE flag set. */
2510 :
2511 : inline bool
2512 13050 : gimple_omp_atomic_need_value_p (const gimple *g)
2513 : {
2514 13050 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2515 6085 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2516 13050 : return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0;
2517 : }
2518 :
2519 :
2520 : /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2521 :
2522 : inline void
2523 2953 : gimple_omp_atomic_set_need_value (gimple *g)
2524 : {
2525 2953 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2526 868 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2527 2953 : g->subcode |= GF_OMP_ATOMIC_NEED_VALUE;
2528 2953 : }
2529 :
2530 :
2531 : /* Return true if OMP atomic load/store statement G has the
2532 : GF_OMP_ATOMIC_WEAK flag set. */
2533 :
2534 : inline bool
2535 1346 : gimple_omp_atomic_weak_p (const gimple *g)
2536 : {
2537 1346 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2538 527 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2539 1346 : return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_WEAK) != 0;
2540 : }
2541 :
2542 :
2543 : /* Set the GF_OMP_ATOMIC_WEAK flag on G. */
2544 :
2545 : inline void
2546 76 : gimple_omp_atomic_set_weak (gimple *g)
2547 : {
2548 76 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2549 38 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2550 76 : g->subcode |= GF_OMP_ATOMIC_WEAK;
2551 76 : }
2552 :
2553 :
2554 : /* Return the memory order of the OMP atomic load/store statement G. */
2555 :
2556 : inline enum omp_memory_order
2557 11193 : gimple_omp_atomic_memory_order (const gimple *g)
2558 : {
2559 11193 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2560 1407 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2561 11193 : return (enum omp_memory_order)
2562 11193 : (gimple_omp_subcode (g) & GF_OMP_ATOMIC_MEMORY_ORDER);
2563 : }
2564 :
2565 :
2566 : /* Set the memory order on G. */
2567 :
2568 : inline void
2569 20794 : gimple_omp_atomic_set_memory_order (gimple *g, enum omp_memory_order mo)
2570 : {
2571 20794 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2572 10397 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2573 20794 : g->subcode = ((g->subcode & ~GF_OMP_ATOMIC_MEMORY_ORDER)
2574 20794 : | (int (mo) & GF_OMP_ATOMIC_MEMORY_ORDER));
2575 20794 : }
2576 :
2577 :
2578 : /* Return the number of operands for statement GS. */
2579 :
2580 : inline unsigned
2581 >20089*10^7 : gimple_num_ops (const gimple *gs)
2582 : {
2583 87607248923 : return gs->num_ops;
2584 : }
2585 :
2586 :
2587 : /* Set the number of operands for statement GS. */
2588 :
2589 : inline void
2590 342516939 : gimple_set_num_ops (gimple *gs, unsigned num_ops)
2591 : {
2592 8196600 : gs->num_ops = num_ops;
2593 : }
2594 :
2595 :
2596 : /* Return the array of operands for statement GS. */
2597 :
2598 : inline tree *
2599 92004233054 : gimple_ops (gimple *gs)
2600 : {
2601 92004233054 : size_t off;
2602 :
2603 : /* All the tuples have their operand vector at the very bottom
2604 : of the structure. Note that those structures that do not
2605 : have an operand vector have a zero offset. */
2606 92004233054 : off = gimple_ops_offset_[gimple_statement_structure (gs)];
2607 92004233054 : gcc_gimple_checking_assert (off != 0);
2608 :
2609 92004233054 : return (tree *) ((char *) gs + off);
2610 : }
2611 :
2612 :
2613 : /* Return operand I for statement GS. */
2614 :
2615 : inline tree
2616 22826050469 : gimple_op (const gimple *gs, unsigned i)
2617 : {
2618 22826050469 : if (gimple_has_ops (gs))
2619 : {
2620 22826050469 : gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2621 22826050469 : return gimple_ops (const_cast<gimple *> (gs))[i];
2622 : }
2623 : else
2624 : return NULL_TREE;
2625 : }
2626 :
2627 : /* Return a pointer to operand I for statement GS. */
2628 :
2629 : inline tree *
2630 68807287710 : gimple_op_ptr (gimple *gs, unsigned i)
2631 : {
2632 68807287710 : if (gimple_has_ops (gs))
2633 : {
2634 68807287710 : gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2635 68807287710 : return gimple_ops (gs) + i;
2636 : }
2637 : else
2638 : return NULL;
2639 : }
2640 :
2641 : /* Set operand I of statement GS to OP. */
2642 :
2643 : inline void
2644 370894875 : gimple_set_op (gimple *gs, unsigned i, tree op)
2645 : {
2646 741789750 : gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
2647 :
2648 : /* Note. It may be tempting to assert that OP matches
2649 : is_gimple_operand, but that would be wrong. Different tuples
2650 : accept slightly different sets of tree operands. Each caller
2651 : should perform its own validation. */
2652 370894875 : gimple_ops (gs)[i] = op;
2653 370894875 : }
2654 :
2655 : /* Return true if GS is a GIMPLE_ASSIGN. */
2656 :
2657 : inline bool
2658 24358559718 : is_gimple_assign (const gimple *gs)
2659 : {
2660 15778401998 : return gimple_code (gs) == GIMPLE_ASSIGN;
2661 : }
2662 :
2663 : /* Determine if expression CODE is one of the valid expressions that can
2664 : be used on the RHS of GIMPLE assignments. */
2665 :
2666 : inline enum gimple_rhs_class
2667 82203566789 : get_gimple_rhs_class (enum tree_code code)
2668 : {
2669 74512308665 : return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
2670 : }
2671 :
2672 : /* Return the LHS of assignment statement GS. */
2673 :
2674 : inline tree
2675 26813435451 : gimple_assign_lhs (const gassign *gs)
2676 : {
2677 21376919712 : return gs->op[0];
2678 : }
2679 :
2680 : inline tree
2681 19756984560 : gimple_assign_lhs (const gimple *gs)
2682 : {
2683 19756984560 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2684 19756984560 : return gimple_assign_lhs (ass);
2685 : }
2686 :
2687 :
2688 : /* Return a pointer to the LHS of assignment statement GS. */
2689 :
2690 : inline tree *
2691 194461643 : gimple_assign_lhs_ptr (gassign *gs)
2692 : {
2693 194461643 : return &gs->op[0];
2694 : }
2695 :
2696 : inline tree *
2697 194461643 : gimple_assign_lhs_ptr (gimple *gs)
2698 : {
2699 194461643 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2700 194461643 : return gimple_assign_lhs_ptr (ass);
2701 : }
2702 :
2703 :
2704 : /* Set LHS to be the LHS operand of assignment statement GS. */
2705 :
2706 : inline void
2707 101766722 : gimple_assign_set_lhs (gassign *gs, tree lhs)
2708 : {
2709 101766722 : gs->op[0] = lhs;
2710 :
2711 101766722 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
2712 47422314 : SSA_NAME_DEF_STMT (lhs) = gs;
2713 : }
2714 :
2715 : inline void
2716 4170997 : gimple_assign_set_lhs (gimple *gs, tree lhs)
2717 : {
2718 4170997 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2719 4170997 : gimple_assign_set_lhs (ass, lhs);
2720 4170997 : }
2721 :
2722 :
2723 : /* Return the first operand on the RHS of assignment statement GS. */
2724 :
2725 : inline tree
2726 27584456179 : gimple_assign_rhs1 (const gassign *gs)
2727 : {
2728 24177675490 : return gs->op[1];
2729 : }
2730 :
2731 : inline tree
2732 21786361815 : gimple_assign_rhs1 (const gimple *gs)
2733 : {
2734 21786361815 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2735 21786361815 : return gimple_assign_rhs1 (ass);
2736 : }
2737 :
2738 :
2739 : /* Return a pointer to the first operand on the RHS of assignment
2740 : statement GS. */
2741 :
2742 : inline tree *
2743 208123719 : gimple_assign_rhs1_ptr (gassign *gs)
2744 : {
2745 208123719 : return &gs->op[1];
2746 : }
2747 :
2748 : inline tree *
2749 207818210 : gimple_assign_rhs1_ptr (gimple *gs)
2750 : {
2751 207818210 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2752 207818210 : return gimple_assign_rhs1_ptr (ass);
2753 : }
2754 :
2755 : /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2756 :
2757 : inline void
2758 108759355 : gimple_assign_set_rhs1 (gassign *gs, tree rhs)
2759 : {
2760 98046825 : gs->op[1] = rhs;
2761 : }
2762 :
2763 : inline void
2764 11213361 : gimple_assign_set_rhs1 (gimple *gs, tree rhs)
2765 : {
2766 11213361 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2767 11213361 : gimple_assign_set_rhs1 (ass, rhs);
2768 11213361 : }
2769 :
2770 :
2771 : /* Return the second operand on the RHS of assignment statement GS.
2772 : If GS does not have two operands, NULL is returned instead. */
2773 :
2774 : inline tree
2775 4859147940 : gimple_assign_rhs2 (const gassign *gs)
2776 : {
2777 3842231486 : if (gimple_num_ops (gs) >= 3)
2778 3242561224 : return gs->op[2];
2779 : else
2780 : return NULL_TREE;
2781 : }
2782 :
2783 : inline tree
2784 1755596736 : gimple_assign_rhs2 (const gimple *gs)
2785 : {
2786 1755596736 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2787 1755596736 : return gimple_assign_rhs2 (ass);
2788 : }
2789 :
2790 :
2791 : /* Return a pointer to the second operand on the RHS of assignment
2792 : statement GS. */
2793 :
2794 : inline tree *
2795 703887 : gimple_assign_rhs2_ptr (gassign *gs)
2796 : {
2797 703887 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2798 703887 : return &gs->op[2];
2799 : }
2800 :
2801 : inline tree *
2802 703241 : gimple_assign_rhs2_ptr (gimple *gs)
2803 : {
2804 703241 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2805 703241 : return gimple_assign_rhs2_ptr (ass);
2806 : }
2807 :
2808 :
2809 : /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2810 :
2811 : inline void
2812 20845225 : gimple_assign_set_rhs2 (gassign *gs, tree rhs)
2813 : {
2814 20845225 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2815 20845225 : gs->op[2] = rhs;
2816 20845225 : }
2817 :
2818 : inline void
2819 4127381 : gimple_assign_set_rhs2 (gimple *gs, tree rhs)
2820 : {
2821 4127381 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2822 4127381 : return gimple_assign_set_rhs2 (ass, rhs);
2823 : }
2824 :
2825 : /* Return the third operand on the RHS of assignment statement GS.
2826 : If GS does not have two operands, NULL is returned instead. */
2827 :
2828 : inline tree
2829 20986230 : gimple_assign_rhs3 (const gassign *gs)
2830 : {
2831 15685631 : if (gimple_num_ops (gs) >= 4)
2832 15940824 : return gs->op[3];
2833 : else
2834 : return NULL_TREE;
2835 : }
2836 :
2837 : inline tree
2838 8358005 : gimple_assign_rhs3 (const gimple *gs)
2839 : {
2840 8358005 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2841 8358005 : return gimple_assign_rhs3 (ass);
2842 : }
2843 :
2844 : /* Return a pointer to the third operand on the RHS of assignment
2845 : statement GS. */
2846 :
2847 : inline tree *
2848 644 : gimple_assign_rhs3_ptr (gimple *gs)
2849 : {
2850 644 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2851 644 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2852 644 : return &ass->op[3];
2853 : }
2854 :
2855 :
2856 : /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2857 :
2858 : inline void
2859 457411 : gimple_assign_set_rhs3 (gassign *gs, tree rhs)
2860 : {
2861 457411 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2862 457411 : gs->op[3] = rhs;
2863 457411 : }
2864 :
2865 : inline void
2866 36981 : gimple_assign_set_rhs3 (gimple *gs, tree rhs)
2867 : {
2868 36981 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2869 36981 : gimple_assign_set_rhs3 (ass, rhs);
2870 36981 : }
2871 :
2872 :
2873 : /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2874 : which expect to see only two operands. */
2875 :
2876 : inline void
2877 332185 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2878 : tree op1, tree op2)
2879 : {
2880 332185 : gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
2881 : }
2882 :
2883 : /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2884 : which expect to see only one operands. */
2885 :
2886 : inline void
2887 70765 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2888 : tree op1)
2889 : {
2890 70765 : gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
2891 : }
2892 :
2893 : /* Returns true if GS is a nontemporal move. */
2894 :
2895 : inline bool
2896 4729468173 : gimple_assign_nontemporal_move_p (const gassign *gs)
2897 : {
2898 4729468173 : return gs->nontemporal_move;
2899 : }
2900 :
2901 : /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2902 :
2903 : inline void
2904 3 : gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
2905 : {
2906 3 : GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
2907 3 : gs->nontemporal_move = nontemporal;
2908 3 : }
2909 :
2910 :
2911 : /* Return the code of the expression computed on the rhs of assignment
2912 : statement GS. In case that the RHS is a single object, returns the
2913 : tree code of the object. */
2914 :
2915 : inline enum tree_code
2916 49705105135 : gimple_assign_rhs_code (const gassign *gs)
2917 : {
2918 49749649094 : enum tree_code code = (enum tree_code) gs->subcode;
2919 : /* While we initially set subcode to the TREE_CODE of the rhs for
2920 : GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2921 : in sync when we rewrite stmts into SSA form or do SSA propagations. */
2922 38614079424 : if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
2923 30460283400 : code = TREE_CODE (gs->op[1]);
2924 :
2925 38500854206 : return code;
2926 : }
2927 :
2928 : inline enum tree_code
2929 36125921698 : gimple_assign_rhs_code (const gimple *gs)
2930 : {
2931 36125921698 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2932 36125921698 : return gimple_assign_rhs_code (ass);
2933 : }
2934 :
2935 :
2936 : /* Set CODE to be the code for the expression computed on the RHS of
2937 : assignment S. */
2938 :
2939 : inline void
2940 2042073 : gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
2941 : {
2942 2042073 : GIMPLE_CHECK (s, GIMPLE_ASSIGN);
2943 2042073 : s->subcode = code;
2944 2042073 : }
2945 :
2946 :
2947 : /* Return the gimple rhs class of the code of the expression computed on
2948 : the rhs of assignment statement GS.
2949 : This will never return GIMPLE_INVALID_RHS. */
2950 :
2951 : inline enum gimple_rhs_class
2952 29958739629 : gimple_assign_rhs_class (const gimple *gs)
2953 : {
2954 29950689495 : return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
2955 : }
2956 :
2957 : /* Return true if GS is an assignment with a singleton RHS, i.e.,
2958 : there is no operator associated with the assignment itself.
2959 : Unlike gimple_assign_copy_p, this predicate returns true for
2960 : any RHS operand, including those that perform an operation
2961 : and do not have the semantics of a copy, such as COND_EXPR. */
2962 :
2963 : inline bool
2964 17110897828 : gimple_assign_single_p (const gimple *gs)
2965 : {
2966 17110897828 : return (is_gimple_assign (gs)
2967 29517400739 : && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
2968 : }
2969 :
2970 : /* Return true if GS performs a store to its lhs. */
2971 :
2972 : inline bool
2973 1352099604 : gimple_store_p (const gimple *gs)
2974 : {
2975 1352099604 : tree lhs = gimple_get_lhs (gs);
2976 1352099604 : return lhs && !is_gimple_reg (lhs);
2977 : }
2978 :
2979 : /* Return true if S is a type-cast assignment. */
2980 :
2981 : inline bool
2982 21893047 : gimple_assign_cast_p (const gimple *s)
2983 : {
2984 21893047 : if (is_gimple_assign (s))
2985 : {
2986 9851815 : enum tree_code sc = gimple_assign_rhs_code (s);
2987 9851815 : return CONVERT_EXPR_CODE_P (sc)
2988 8042769 : || sc == VIEW_CONVERT_EXPR
2989 9851815 : || sc == FIX_TRUNC_EXPR;
2990 : }
2991 :
2992 : return false;
2993 : }
2994 :
2995 : /* Return true if S is a clobber statement. */
2996 :
2997 : inline bool
2998 8436111957 : gimple_clobber_p (const gimple *s)
2999 : {
3000 8436111957 : return gimple_assign_single_p (s)
3001 8436111957 : && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
3002 : }
3003 :
3004 : /* Return true if S is a clobber statement. */
3005 :
3006 : inline bool
3007 93659504 : gimple_clobber_p (const gimple *s, enum clobber_kind kind)
3008 : {
3009 93659504 : return gimple_clobber_p (s)
3010 93659504 : && CLOBBER_KIND (gimple_assign_rhs1 (s)) == kind;
3011 : }
3012 :
3013 : /* Return true if GS is a GIMPLE_CALL. */
3014 :
3015 : inline bool
3016 21927766034 : is_gimple_call (const gimple *gs)
3017 : {
3018 23816598495 : return gimple_code (gs) == GIMPLE_CALL;
3019 : }
3020 :
3021 : /* Return the LHS of call statement GS. */
3022 :
3023 : inline tree
3024 6035408580 : gimple_call_lhs (const gcall *gs)
3025 : {
3026 1757145775 : return gs->op[0];
3027 : }
3028 :
3029 : inline tree
3030 4438167180 : gimple_call_lhs (const gimple *gs)
3031 : {
3032 4438167180 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3033 4438167180 : return gimple_call_lhs (gc);
3034 : }
3035 :
3036 :
3037 : /* Return a pointer to the LHS of call statement GS. */
3038 :
3039 : inline tree *
3040 887382247 : gimple_call_lhs_ptr (gcall *gs)
3041 : {
3042 887382247 : return &gs->op[0];
3043 : }
3044 :
3045 : inline tree *
3046 826968003 : gimple_call_lhs_ptr (gimple *gs)
3047 : {
3048 826968003 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3049 826968003 : return gimple_call_lhs_ptr (gc);
3050 : }
3051 :
3052 :
3053 : /* Set LHS to be the LHS operand of call statement GS. */
3054 :
3055 : inline void
3056 7105230 : gimple_call_set_lhs (gcall *gs, tree lhs)
3057 : {
3058 7105230 : gs->op[0] = lhs;
3059 7020517 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
3060 2954067 : SSA_NAME_DEF_STMT (lhs) = gs;
3061 : }
3062 :
3063 : inline void
3064 1493188 : gimple_call_set_lhs (gimple *gs, tree lhs)
3065 : {
3066 1493188 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3067 1493188 : gimple_call_set_lhs (gc, lhs);
3068 1493188 : }
3069 :
3070 :
3071 : /* Return true if call GS calls an internal-only function, as enumerated
3072 : by internal_fn. */
3073 :
3074 : inline bool
3075 17449381680 : gimple_call_internal_p (const gcall *gs)
3076 : {
3077 7324251017 : return (gs->subcode & GF_CALL_INTERNAL) != 0;
3078 : }
3079 :
3080 : inline bool
3081 8252473174 : gimple_call_internal_p (const gimple *gs)
3082 : {
3083 8252473174 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3084 8252473174 : return gimple_call_internal_p (gc);
3085 : }
3086 :
3087 : /* Return true if call GS is marked as nocf_check. */
3088 :
3089 : inline bool
3090 8734066 : gimple_call_nocf_check_p (const gcall *gs)
3091 : {
3092 8734066 : return (gs->subcode & GF_CALL_NOCF_CHECK) != 0;
3093 : }
3094 :
3095 : /* Mark statement GS as nocf_check call. */
3096 :
3097 : inline void
3098 21 : gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
3099 : {
3100 21 : if (nocf_check)
3101 21 : gs->subcode |= GF_CALL_NOCF_CHECK;
3102 : else
3103 : gs->subcode &= ~GF_CALL_NOCF_CHECK;
3104 : }
3105 :
3106 : /* Return the target of internal call GS. */
3107 :
3108 : inline enum internal_fn
3109 339774223 : gimple_call_internal_fn (const gcall *gs)
3110 : {
3111 339774223 : gcc_gimple_checking_assert (gimple_call_internal_p (gs));
3112 339774223 : return gs->u.internal_fn;
3113 : }
3114 :
3115 : inline enum internal_fn
3116 270255204 : gimple_call_internal_fn (const gimple *gs)
3117 : {
3118 270255204 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3119 270255204 : return gimple_call_internal_fn (gc);
3120 : }
3121 :
3122 : /* Return true, if this internal gimple call is unique. */
3123 :
3124 : inline bool
3125 1110965 : gimple_call_internal_unique_p (const gcall *gs)
3126 : {
3127 2213651 : return gimple_call_internal_fn (gs) == IFN_UNIQUE;
3128 : }
3129 :
3130 : inline bool
3131 1102686 : gimple_call_internal_unique_p (const gimple *gs)
3132 : {
3133 1102686 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3134 1102686 : return gimple_call_internal_unique_p (gc);
3135 : }
3136 :
3137 : /* Return true if GS is an internal function FN. */
3138 :
3139 : inline bool
3140 5383844548 : gimple_call_internal_p (const gimple *gs, internal_fn fn)
3141 : {
3142 5383844548 : return (is_gimple_call (gs)
3143 3519064088 : && gimple_call_internal_p (gs)
3144 5517376015 : && gimple_call_internal_fn (gs) == fn);
3145 : }
3146 :
3147 : /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
3148 : that could alter control flow. */
3149 :
3150 : inline void
3151 35329650 : gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
3152 : {
3153 35329650 : if (ctrl_altering_p)
3154 25630499 : s->subcode |= GF_CALL_CTRL_ALTERING;
3155 : else
3156 9699151 : s->subcode &= ~GF_CALL_CTRL_ALTERING;
3157 : }
3158 :
3159 : inline void
3160 35056637 : gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
3161 : {
3162 35056637 : gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3163 35056637 : gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
3164 35056637 : }
3165 :
3166 : /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
3167 : flag is set. Such call could not be a stmt in the middle of a bb. */
3168 :
3169 : inline bool
3170 2406469716 : gimple_call_ctrl_altering_p (const gcall *gs)
3171 : {
3172 1278669533 : return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
3173 : }
3174 :
3175 : inline bool
3176 1206030622 : gimple_call_ctrl_altering_p (const gimple *gs)
3177 : {
3178 1206030622 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3179 1206030622 : return gimple_call_ctrl_altering_p (gc);
3180 : }
3181 :
3182 :
3183 : /* Return the function type of the function called by GS. */
3184 :
3185 : inline tree
3186 5924782794 : gimple_call_fntype (const gcall *gs)
3187 : {
3188 1238633544 : if (gimple_call_internal_p (gs))
3189 : return NULL_TREE;
3190 5865202667 : return gs->u.fntype;
3191 : }
3192 :
3193 : inline tree
3194 4314471307 : gimple_call_fntype (const gimple *gs)
3195 : {
3196 4314471307 : const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
3197 4314471307 : return gimple_call_fntype (call_stmt);
3198 : }
3199 :
3200 : /* Set the type of the function called by CALL_STMT to FNTYPE. */
3201 :
3202 : inline void
3203 24426098 : gimple_call_set_fntype (gcall *call_stmt, tree fntype)
3204 : {
3205 24426098 : gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt));
3206 24426098 : call_stmt->u.fntype = fntype;
3207 24426098 : }
3208 :
3209 :
3210 : /* Return the tree node representing the function called by call
3211 : statement GS. */
3212 :
3213 : inline tree
3214 10482365376 : gimple_call_fn (const gcall *gs)
3215 : {
3216 2333849047 : return gs->op[1];
3217 : }
3218 :
3219 : inline tree
3220 91059635 : gimple_call_fn (const gimple *gs)
3221 : {
3222 91059635 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3223 91059635 : return gimple_call_fn (gc);
3224 : }
3225 :
3226 : /* Return a pointer to the tree node representing the function called by call
3227 : statement GS. */
3228 :
3229 : inline tree *
3230 2084984663 : gimple_call_fn_ptr (gcall *gs)
3231 : {
3232 2084984663 : return &gs->op[1];
3233 : }
3234 :
3235 : inline tree *
3236 2084984663 : gimple_call_fn_ptr (gimple *gs)
3237 : {
3238 2084984663 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3239 2084984663 : return gimple_call_fn_ptr (gc);
3240 : }
3241 :
3242 :
3243 : /* Set FN to be the function called by call statement GS. */
3244 :
3245 : inline void
3246 3794 : gimple_call_set_fn (gcall *gs, tree fn)
3247 : {
3248 3794 : gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3249 3794 : gs->op[1] = fn;
3250 3794 : }
3251 :
3252 :
3253 : /* Set FNDECL to be the function called by call statement GS. */
3254 :
3255 : inline void
3256 722946 : gimple_call_set_fndecl (gcall *gs, tree decl)
3257 : {
3258 722946 : gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3259 722946 : gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
3260 722946 : build_pointer_type (TREE_TYPE (decl)), decl);
3261 722946 : }
3262 :
3263 : inline void
3264 38179 : gimple_call_set_fndecl (gimple *gs, tree decl)
3265 : {
3266 38179 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3267 38179 : gimple_call_set_fndecl (gc, decl);
3268 38179 : }
3269 :
3270 :
3271 : /* Set internal function FN to be the function called by call statement CALL_STMT. */
3272 :
3273 : inline void
3274 912779 : gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
3275 : {
3276 912779 : gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt));
3277 912779 : call_stmt->u.internal_fn = fn;
3278 912779 : }
3279 :
3280 :
3281 : /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
3282 : Otherwise return NULL. This function is analogous to
3283 : get_callee_fndecl in tree land. */
3284 :
3285 : inline tree
3286 9159404690 : gimple_call_fndecl (const gcall *gs)
3287 : {
3288 2702674581 : return gimple_call_addr_fndecl (gimple_call_fn (gs));
3289 : }
3290 :
3291 : inline tree
3292 6733035227 : gimple_call_fndecl (const gimple *gs)
3293 : {
3294 6733035227 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3295 6733035227 : return gimple_call_fndecl (gc);
3296 : }
3297 :
3298 :
3299 : /* Return the type returned by call statement GS. */
3300 :
3301 : inline tree
3302 13114442 : gimple_call_return_type (const gcall *gs)
3303 : {
3304 13114442 : tree type = gimple_call_fntype (gs);
3305 :
3306 13112669 : if (type == NULL_TREE)
3307 1773 : return TREE_TYPE (gimple_call_lhs (gs));
3308 :
3309 : /* The type returned by a function is the type of its
3310 : function type. */
3311 13112669 : return TREE_TYPE (type);
3312 : }
3313 :
3314 :
3315 : /* Return the static chain for call statement GS. */
3316 :
3317 : inline tree
3318 2462357276 : gimple_call_chain (const gcall *gs)
3319 : {
3320 1359772409 : return gs->op[2];
3321 : }
3322 :
3323 : inline tree
3324 17876816 : gimple_call_chain (const gimple *gs)
3325 : {
3326 17876816 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3327 17876816 : return gimple_call_chain (gc);
3328 : }
3329 :
3330 :
3331 : /* Return a pointer to the static chain for call statement CALL_STMT. */
3332 :
3333 : inline tree *
3334 2085014071 : gimple_call_chain_ptr (gcall *call_stmt)
3335 : {
3336 2085014071 : return &call_stmt->op[2];
3337 : }
3338 :
3339 : /* Set CHAIN to be the static chain for call statement CALL_STMT. */
3340 :
3341 : inline void
3342 11576529 : gimple_call_set_chain (gcall *call_stmt, tree chain)
3343 : {
3344 11576529 : call_stmt->op[2] = chain;
3345 : }
3346 :
3347 :
3348 : /* Return the number of arguments used by call statement GS. */
3349 :
3350 : inline unsigned
3351 12146744972 : gimple_call_num_args (const gcall *gs)
3352 : {
3353 5107617702 : return gimple_num_ops (gs) - 3;
3354 : }
3355 :
3356 : inline unsigned
3357 7375518048 : gimple_call_num_args (const gimple *gs)
3358 : {
3359 7375518048 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3360 7375518048 : return gimple_call_num_args (gc);
3361 : }
3362 :
3363 :
3364 : /* Return the argument at position INDEX for call statement GS. */
3365 :
3366 : inline tree
3367 8563004566 : gimple_call_arg (const gcall *gs, unsigned index)
3368 : {
3369 8556646471 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3370 5915032558 : return gs->op[index + 3];
3371 : }
3372 :
3373 : inline tree
3374 5442445953 : gimple_call_arg (const gimple *gs, unsigned index)
3375 : {
3376 5442445953 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3377 5442445953 : return gimple_call_arg (gc, index);
3378 : }
3379 :
3380 :
3381 : /* Return a pointer to the argument at position INDEX for call
3382 : statement GS. */
3383 :
3384 : inline tree *
3385 4344162309 : gimple_call_arg_ptr (gcall *gs, unsigned index)
3386 : {
3387 4344162309 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3388 4344149812 : return &gs->op[index + 3];
3389 : }
3390 :
3391 : inline tree *
3392 4167456869 : gimple_call_arg_ptr (gimple *gs, unsigned index)
3393 : {
3394 4167456869 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3395 4167456869 : return gimple_call_arg_ptr (gc, index);
3396 : }
3397 :
3398 :
3399 : /* Set ARG to be the argument at position INDEX for call statement GS. */
3400 :
3401 : inline void
3402 25465802 : gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
3403 : {
3404 25395413 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3405 25295991 : gs->op[index + 3] = arg;
3406 25394194 : }
3407 :
3408 : inline void
3409 587285 : gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
3410 : {
3411 587285 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3412 587285 : gimple_call_set_arg (gc, index, arg);
3413 587285 : }
3414 :
3415 :
3416 : /* If TAIL_P is true, mark call statement S as being a tail call
3417 : (i.e., a call just before the exit of a function). These calls are
3418 : candidate for tail call optimization. */
3419 :
3420 : inline void
3421 11112193 : gimple_call_set_tail (gcall *s, bool tail_p)
3422 : {
3423 11112193 : if (tail_p)
3424 200069 : s->subcode |= GF_CALL_TAILCALL;
3425 : else
3426 10912124 : s->subcode &= ~GF_CALL_TAILCALL;
3427 : }
3428 :
3429 :
3430 : /* Return true if GIMPLE_CALL S is marked as a tail call. */
3431 :
3432 : inline bool
3433 25362911 : gimple_call_tail_p (const gcall *s)
3434 : {
3435 25362911 : return (s->subcode & GF_CALL_TAILCALL) != 0;
3436 : }
3437 :
3438 : /* Mark (or clear) call statement S as requiring tail call optimization. */
3439 :
3440 : inline void
3441 10911280 : gimple_call_set_must_tail (gcall *s, bool must_tail_p)
3442 : {
3443 10911280 : if (must_tail_p)
3444 874 : s->subcode |= GF_CALL_MUST_TAIL_CALL;
3445 : else
3446 10910406 : s->subcode &= ~GF_CALL_MUST_TAIL_CALL;
3447 : }
3448 :
3449 : /* Return true if call statement has been marked as requiring
3450 : tail call optimization. */
3451 :
3452 : inline bool
3453 74354826 : gimple_call_must_tail_p (const gcall *s)
3454 : {
3455 74354783 : return (s->subcode & GF_CALL_MUST_TAIL_CALL) != 0;
3456 : }
3457 :
3458 : /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
3459 : slot optimization. This transformation uses the target of the call
3460 : expansion as the return slot for calls that return in memory. */
3461 :
3462 : inline void
3463 10919348 : gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
3464 : {
3465 10919344 : if (return_slot_opt_p)
3466 333503 : s->subcode |= GF_CALL_RETURN_SLOT_OPT;
3467 : else
3468 10585845 : s->subcode &= ~GF_CALL_RETURN_SLOT_OPT;
3469 : }
3470 :
3471 :
3472 : /* Return true if S is marked for return slot optimization. */
3473 :
3474 : inline bool
3475 154842876 : gimple_call_return_slot_opt_p (const gcall *s)
3476 : {
3477 154842876 : return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
3478 : }
3479 :
3480 :
3481 : /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
3482 : thunk to the thunked-to function. */
3483 :
3484 : inline void
3485 10757753 : gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
3486 : {
3487 10757753 : if (from_thunk_p)
3488 22362 : s->subcode |= GF_CALL_FROM_THUNK;
3489 : else
3490 10735391 : s->subcode &= ~GF_CALL_FROM_THUNK;
3491 : }
3492 :
3493 :
3494 : /* Return true if GIMPLE_CALL S is a jump from a thunk. */
3495 :
3496 : inline bool
3497 36174462 : gimple_call_from_thunk_p (gcall *s)
3498 : {
3499 36174462 : return (s->subcode & GF_CALL_FROM_THUNK) != 0;
3500 : }
3501 :
3502 :
3503 : /* If FROM_NEW_OR_DELETE_P is true, mark GIMPLE_CALL S as being a call
3504 : to operator new or delete created from a new or delete expression. */
3505 :
3506 : inline void
3507 132367 : gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
3508 : {
3509 132367 : if (from_new_or_delete_p)
3510 109612 : s->subcode |= GF_CALL_FROM_NEW_OR_DELETE;
3511 : else
3512 22755 : s->subcode &= ~GF_CALL_FROM_NEW_OR_DELETE;
3513 : }
3514 :
3515 :
3516 : /* Return true if GIMPLE_CALL S is a call to operator new or delete from
3517 : from a new or delete expression. */
3518 :
3519 : inline bool
3520 123681370 : gimple_call_from_new_or_delete (const gcall *s)
3521 : {
3522 123681370 : return (s->subcode & GF_CALL_FROM_NEW_OR_DELETE) != 0;
3523 : }
3524 :
3525 :
3526 : /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
3527 : argument pack in its argument list. */
3528 :
3529 : inline void
3530 10911526 : gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
3531 : {
3532 10911526 : if (pass_arg_pack_p)
3533 132 : s->subcode |= GF_CALL_VA_ARG_PACK;
3534 : else
3535 10911394 : s->subcode &= ~GF_CALL_VA_ARG_PACK;
3536 : }
3537 :
3538 :
3539 : /* Return true if GIMPLE_CALL S is a stdarg call that needs the
3540 : argument pack in its argument list. */
3541 :
3542 : inline bool
3543 18657233 : gimple_call_va_arg_pack_p (const gcall *s)
3544 : {
3545 18657233 : return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
3546 : }
3547 :
3548 :
3549 : /* Return true if S is a noreturn call. */
3550 :
3551 : inline bool
3552 367877648 : gimple_call_noreturn_p (const gcall *s)
3553 : {
3554 460182404 : return (gimple_call_flags (s) & ECF_NORETURN) != 0;
3555 : }
3556 :
3557 : inline bool
3558 207732658 : gimple_call_noreturn_p (const gimple *s)
3559 : {
3560 207732658 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
3561 207732658 : return gimple_call_noreturn_p (gc);
3562 : }
3563 :
3564 :
3565 : /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
3566 : even if the called function can throw in other cases. */
3567 :
3568 : inline void
3569 11333436 : gimple_call_set_nothrow (gcall *s, bool nothrow_p)
3570 : {
3571 11319692 : if (nothrow_p)
3572 3011386 : s->subcode |= GF_CALL_NOTHROW;
3573 : else
3574 8320048 : s->subcode &= ~GF_CALL_NOTHROW;
3575 : }
3576 :
3577 : /* Return true if S is a nothrow call. */
3578 :
3579 : inline bool
3580 1095949755 : gimple_call_nothrow_p (const gcall *s)
3581 : {
3582 1095949755 : return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
3583 : }
3584 :
3585 : /* If EXPECTED_THROW_P is true, GIMPLE_CALL S is a call that is known
3586 : to be more likely to throw than to run forever, terminate the
3587 : program or return by other means. */
3588 :
3589 : static inline void
3590 10746409 : gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
3591 : {
3592 10746409 : if (expected_throw_p)
3593 27924 : s->subcode |= GF_CALL_XTHROW;
3594 : else
3595 10718485 : s->subcode &= ~GF_CALL_XTHROW;
3596 : }
3597 :
3598 : /* Return true if S is a call that is more likely to end by
3599 : propagating an exception than by other means. */
3600 :
3601 : static inline bool
3602 323 : gimple_call_expected_throw_p (gcall *s)
3603 : {
3604 323 : return (gimple_call_flags (s) & ECF_XTHROW) != 0;
3605 : }
3606 :
3607 : /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
3608 : is known to be emitted for VLA objects. Those are wrapped by
3609 : stack_save/stack_restore calls and hence can't lead to unbounded
3610 : stack growth even when they occur in loops. */
3611 :
3612 : inline void
3613 42647 : gimple_call_set_alloca_for_var (gcall *s, bool for_var)
3614 : {
3615 42647 : if (for_var)
3616 10151 : s->subcode |= GF_CALL_ALLOCA_FOR_VAR;
3617 : else
3618 32496 : s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR;
3619 : }
3620 :
3621 : /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3622 :
3623 : inline bool
3624 315485 : gimple_call_alloca_for_var_p (gcall *s)
3625 : {
3626 315485 : return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3627 : }
3628 :
3629 : inline bool
3630 292740 : gimple_call_alloca_for_var_p (gimple *s)
3631 : {
3632 292740 : const gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3633 292740 : return (gc->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3634 : }
3635 :
3636 : /* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
3637 : pointers to nested function are descriptors instead of trampolines. */
3638 :
3639 : inline void
3640 10911218 : gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
3641 : {
3642 10911218 : if (by_descriptor_p)
3643 0 : s->subcode |= GF_CALL_BY_DESCRIPTOR;
3644 : else
3645 10911218 : s->subcode &= ~GF_CALL_BY_DESCRIPTOR;
3646 : }
3647 :
3648 : /* Return true if S is a by-descriptor call. */
3649 :
3650 : inline bool
3651 6840446 : gimple_call_by_descriptor_p (gcall *s)
3652 : {
3653 6840446 : return (s->subcode & GF_CALL_BY_DESCRIPTOR) != 0;
3654 : }
3655 :
3656 : /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3657 :
3658 : inline void
3659 646791 : gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
3660 : {
3661 646791 : dest_call->subcode = orig_call->subcode;
3662 : }
3663 :
3664 :
3665 : /* Return a pointer to the points-to solution for the set of call-used
3666 : variables of the call CALL_STMT. */
3667 :
3668 : inline struct pt_solution *
3669 56981161 : gimple_call_use_set (gcall *call_stmt)
3670 : {
3671 56981161 : return &call_stmt->call_used;
3672 : }
3673 :
3674 : /* As above, but const. */
3675 :
3676 : inline const pt_solution *
3677 476 : gimple_call_use_set (const gcall *call_stmt)
3678 : {
3679 476 : return &call_stmt->call_used;
3680 : }
3681 :
3682 : /* Return a pointer to the points-to solution for the set of call-used
3683 : variables of the call CALL_STMT. */
3684 :
3685 : inline struct pt_solution *
3686 139837927 : gimple_call_clobber_set (gcall *call_stmt)
3687 : {
3688 139837927 : return &call_stmt->call_clobbered;
3689 : }
3690 :
3691 : /* As above, but const. */
3692 :
3693 : inline const pt_solution *
3694 476 : gimple_call_clobber_set (const gcall *call_stmt)
3695 : {
3696 476 : return &call_stmt->call_clobbered;
3697 : }
3698 :
3699 :
3700 : /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
3701 : non-NULL lhs. */
3702 :
3703 : inline bool
3704 685573143 : gimple_has_lhs (const gimple *stmt)
3705 : {
3706 685099335 : if (is_gimple_assign (stmt))
3707 : return true;
3708 1122954188 : if (const gcall *call = dyn_cast <const gcall *> (stmt))
3709 55004560 : return gimple_call_lhs (call) != NULL_TREE;
3710 : return false;
3711 : }
3712 :
3713 :
3714 : /* Return the code of the predicate computed by conditional statement GS. */
3715 :
3716 : inline enum tree_code
3717 3666482735 : gimple_cond_code (const gcond *gs)
3718 : {
3719 2413834188 : return (enum tree_code) gs->subcode;
3720 : }
3721 :
3722 : inline enum tree_code
3723 521491938 : gimple_cond_code (const gimple *gs)
3724 : {
3725 521491938 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3726 521491938 : return gimple_cond_code (gc);
3727 : }
3728 :
3729 :
3730 : /* Set CODE to be the predicate code for the conditional statement GS. */
3731 :
3732 : inline void
3733 14728329 : gimple_cond_set_code (gcond *gs, enum tree_code code)
3734 : {
3735 14728329 : gcc_gimple_checking_assert (TREE_CODE_CLASS (code) == tcc_comparison);
3736 14728329 : gs->subcode = code;
3737 14728329 : }
3738 :
3739 :
3740 : /* Return the LHS of the predicate computed by conditional statement GS. */
3741 :
3742 : inline tree
3743 3321758390 : gimple_cond_lhs (const gcond *gs)
3744 : {
3745 1968633080 : return gs->op[0];
3746 : }
3747 :
3748 : inline tree
3749 781238691 : gimple_cond_lhs (const gimple *gs)
3750 : {
3751 781238691 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3752 781238691 : return gimple_cond_lhs (gc);
3753 : }
3754 :
3755 : /* Return the pointer to the LHS of the predicate computed by conditional
3756 : statement GS. */
3757 :
3758 : inline tree *
3759 7332480 : gimple_cond_lhs_ptr (gcond *gs)
3760 : {
3761 7332480 : return &gs->op[0];
3762 : }
3763 :
3764 : /* Set LHS to be the LHS operand of the predicate computed by
3765 : conditional statement GS. */
3766 :
3767 : inline void
3768 26877428 : gimple_cond_set_lhs (gcond *gs, tree lhs)
3769 : {
3770 23251999 : gs->op[0] = lhs;
3771 : }
3772 :
3773 :
3774 : /* Return the RHS operand of the predicate computed by conditional GS. */
3775 :
3776 : inline tree
3777 2408554108 : gimple_cond_rhs (const gcond *gs)
3778 : {
3779 1869380545 : return gs->op[1];
3780 : }
3781 :
3782 : inline tree
3783 741038689 : gimple_cond_rhs (const gimple *gs)
3784 : {
3785 741038689 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3786 741038689 : return gimple_cond_rhs (gc);
3787 : }
3788 :
3789 : /* Return the pointer to the RHS operand of the predicate computed by
3790 : conditional GS. */
3791 :
3792 : inline tree *
3793 7332059 : gimple_cond_rhs_ptr (gcond *gs)
3794 : {
3795 7332059 : return &gs->op[1];
3796 : }
3797 :
3798 :
3799 : /* Set RHS to be the RHS operand of the predicate computed by
3800 : conditional statement GS. */
3801 :
3802 : inline void
3803 27009501 : gimple_cond_set_rhs (gcond *gs, tree rhs)
3804 : {
3805 23384072 : gs->op[1] = rhs;
3806 : }
3807 :
3808 :
3809 : /* Return the label used by conditional statement GS when its
3810 : predicate evaluates to true. */
3811 :
3812 : inline tree
3813 798604322 : gimple_cond_true_label (const gcond *gs)
3814 : {
3815 798604172 : return gs->op[2];
3816 : }
3817 :
3818 :
3819 : /* Set LABEL to be the label used by conditional statement GS when its
3820 : predicate evaluates to true. */
3821 :
3822 : inline void
3823 14403619 : gimple_cond_set_true_label (gcond *gs, tree label)
3824 : {
3825 8810259 : gs->op[2] = label;
3826 : }
3827 :
3828 :
3829 : /* Set LABEL to be the label used by conditional statement GS when its
3830 : predicate evaluates to false. */
3831 :
3832 : inline void
3833 14505525 : gimple_cond_set_false_label (gcond *gs, tree label)
3834 : {
3835 8912165 : gs->op[3] = label;
3836 : }
3837 :
3838 :
3839 : /* Return the label used by conditional statement GS when its
3840 : predicate evaluates to false. */
3841 :
3842 : inline tree
3843 798611590 : gimple_cond_false_label (const gcond *gs)
3844 : {
3845 798611590 : return gs->op[3];
3846 : }
3847 :
3848 :
3849 : /* Set the conditional COND_STMT to be of the form 'if (0 != 0)'. */
3850 :
3851 : inline void
3852 2225046 : gimple_cond_make_false (gcond *gs)
3853 : {
3854 2225046 : gimple_cond_set_lhs (gs, boolean_false_node);
3855 2225046 : gimple_cond_set_rhs (gs, boolean_false_node);
3856 2225046 : gs->subcode = NE_EXPR;
3857 : }
3858 :
3859 :
3860 : /* Set the conditional COND_STMT to be of the form 'if (1 != 0)'. */
3861 :
3862 : inline void
3863 1254062 : gimple_cond_make_true (gcond *gs)
3864 : {
3865 1254062 : gimple_cond_set_lhs (gs, boolean_true_node);
3866 1254062 : gimple_cond_set_rhs (gs, boolean_false_node);
3867 1254062 : gs->subcode = NE_EXPR;
3868 : }
3869 :
3870 : /* Check if conditional statement GS is of the form 'if (1 == 1)',
3871 : 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
3872 :
3873 : inline bool
3874 192331152 : gimple_cond_true_p (const gcond *gs)
3875 : {
3876 192331152 : tree lhs = gimple_cond_lhs (gs);
3877 192331152 : tree rhs = gimple_cond_rhs (gs);
3878 192331152 : enum tree_code code = gimple_cond_code (gs);
3879 :
3880 192331152 : if (lhs != boolean_true_node && lhs != boolean_false_node)
3881 : return false;
3882 :
3883 330688 : if (rhs != boolean_true_node && rhs != boolean_false_node)
3884 : return false;
3885 :
3886 330688 : if (code == NE_EXPR && lhs != rhs)
3887 : return true;
3888 :
3889 221007 : if (code == EQ_EXPR && lhs == rhs)
3890 : return true;
3891 :
3892 : return false;
3893 : }
3894 :
3895 : /* Check if conditional statement GS is in the caonical form of 'if (1 != 0)'. */
3896 :
3897 : inline bool
3898 403486 : gimple_cond_true_canonical_p (const gcond *gs)
3899 : {
3900 403486 : tree lhs = gimple_cond_lhs (gs);
3901 403486 : tree rhs = gimple_cond_rhs (gs);
3902 403486 : tree_code code = gimple_cond_code (gs);
3903 403486 : if (code == NE_EXPR
3904 296205 : && lhs == boolean_true_node
3905 192365 : && rhs == boolean_false_node)
3906 192256 : return true;
3907 : return false;
3908 : }
3909 :
3910 : /* Check if conditional statement GS is of the form 'if (1 != 1)',
3911 : 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
3912 :
3913 : inline bool
3914 192221471 : gimple_cond_false_p (const gcond *gs)
3915 : {
3916 192221471 : tree lhs = gimple_cond_lhs (gs);
3917 192221471 : tree rhs = gimple_cond_rhs (gs);
3918 192221471 : enum tree_code code = gimple_cond_code (gs);
3919 :
3920 192221471 : if (lhs != boolean_true_node && lhs != boolean_false_node)
3921 : return false;
3922 :
3923 221007 : if (rhs != boolean_true_node && rhs != boolean_false_node)
3924 : return false;
3925 :
3926 221007 : if (code == NE_EXPR && lhs == rhs)
3927 : return true;
3928 :
3929 0 : if (code == EQ_EXPR && lhs != rhs)
3930 : return true;
3931 :
3932 : return false;
3933 : }
3934 :
3935 : /* Check if conditional statement GS is in the caonical form of 'if (0 != 0)'. */
3936 :
3937 : inline bool
3938 903946 : gimple_cond_false_canonical_p (const gcond *gs)
3939 : {
3940 903946 : tree lhs = gimple_cond_lhs (gs);
3941 903946 : tree rhs = gimple_cond_rhs (gs);
3942 903946 : tree_code code = gimple_cond_code (gs);
3943 903946 : if (code == NE_EXPR
3944 636115 : && lhs == boolean_false_node
3945 384754 : && rhs == boolean_false_node)
3946 : return true;
3947 : return false;
3948 : }
3949 :
3950 : /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3951 :
3952 : inline void
3953 2131482 : gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs,
3954 : tree rhs)
3955 : {
3956 2131482 : gimple_cond_set_code (stmt, code);
3957 2131482 : gimple_cond_set_lhs (stmt, lhs);
3958 2131482 : gimple_cond_set_rhs (stmt, rhs);
3959 : }
3960 :
3961 :
3962 : /* Return the tree code for the expression computed by STMT. This is
3963 : only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
3964 : GIMPLE_CALL, return CALL_EXPR as the expression code for
3965 : consistency. This is useful when the caller needs to deal with the
3966 : three kinds of computation that GIMPLE supports. */
3967 :
3968 : inline enum tree_code
3969 379926695 : gimple_expr_code (const gimple *stmt)
3970 : {
3971 379926695 : if (const gassign *ass = dyn_cast<const gassign *> (stmt))
3972 271871488 : return gimple_assign_rhs_code (ass);
3973 108055207 : if (const gcond *cond = dyn_cast<const gcond *> (stmt))
3974 106732583 : return gimple_cond_code (cond);
3975 : else
3976 : {
3977 1322624 : gcc_gimple_checking_assert (gimple_code (stmt) == GIMPLE_CALL);
3978 : return CALL_EXPR;
3979 : }
3980 : }
3981 :
3982 :
3983 : /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3984 :
3985 : inline tree
3986 541597170 : gimple_label_label (const glabel *gs)
3987 : {
3988 541597170 : return gs->op[0];
3989 : }
3990 :
3991 :
3992 : /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3993 : GS. */
3994 :
3995 : inline void
3996 19680464 : gimple_label_set_label (glabel *gs, tree label)
3997 : {
3998 19680464 : gs->op[0] = label;
3999 : }
4000 :
4001 :
4002 : /* Return the destination of the unconditional jump GS. */
4003 :
4004 : inline tree
4005 55003983 : gimple_goto_dest (const gimple *gs)
4006 : {
4007 55003983 : GIMPLE_CHECK (gs, GIMPLE_GOTO);
4008 55003983 : return gimple_op (gs, 0);
4009 : }
4010 :
4011 :
4012 : /* Set DEST to be the destination of the unconditional jump GS. */
4013 :
4014 : inline void
4015 8319628 : gimple_goto_set_dest (ggoto *gs, tree dest)
4016 : {
4017 8319628 : gs->op[0] = dest;
4018 : }
4019 :
4020 :
4021 : /* Return the variables declared in the GIMPLE_BIND statement GS. */
4022 :
4023 : inline tree
4024 17903485 : gimple_bind_vars (const gbind *bind_stmt)
4025 : {
4026 17903485 : return bind_stmt->vars;
4027 : }
4028 :
4029 :
4030 : /* Set VARS to be the set of variables declared in the GIMPLE_BIND
4031 : statement GS. */
4032 :
4033 : inline void
4034 9556139 : gimple_bind_set_vars (gbind *bind_stmt, tree vars)
4035 : {
4036 9556139 : bind_stmt->vars = vars;
4037 : }
4038 :
4039 :
4040 : /* Append VARS to the set of variables declared in the GIMPLE_BIND
4041 : statement GS. */
4042 :
4043 : inline void
4044 77601 : gimple_bind_append_vars (gbind *bind_stmt, tree vars)
4045 : {
4046 77601 : bind_stmt->vars = chainon (bind_stmt->vars, vars);
4047 : }
4048 :
4049 :
4050 : inline gimple_seq *
4051 10592707 : gimple_bind_body_ptr (gbind *bind_stmt)
4052 : {
4053 10592707 : return &bind_stmt->body;
4054 : }
4055 :
4056 : /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
4057 :
4058 : inline gimple_seq
4059 30577730 : gimple_bind_body (const gbind *gs)
4060 : {
4061 30577730 : return *gimple_bind_body_ptr (const_cast <gbind *> (gs));
4062 : }
4063 :
4064 :
4065 : /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
4066 : statement GS. */
4067 :
4068 : inline void
4069 8293548 : gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
4070 : {
4071 8293162 : bind_stmt->body = seq;
4072 : }
4073 :
4074 :
4075 : /* Append a statement to the end of a GIMPLE_BIND's body. */
4076 :
4077 : inline void
4078 68926 : gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
4079 : {
4080 68926 : gimple_seq_add_stmt (&bind_stmt->body, stmt);
4081 : }
4082 :
4083 :
4084 : /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
4085 :
4086 : inline void
4087 131736 : gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
4088 : {
4089 127872 : gimple_seq_add_seq (&bind_stmt->body, seq);
4090 : }
4091 :
4092 :
4093 : /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
4094 : GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
4095 :
4096 : inline tree
4097 24528817 : gimple_bind_block (const gbind *bind_stmt)
4098 : {
4099 24527650 : return bind_stmt->block;
4100 : }
4101 :
4102 :
4103 : /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
4104 : statement GS. */
4105 :
4106 : inline void
4107 6070063 : gimple_bind_set_block (gbind *bind_stmt, tree block)
4108 : {
4109 6070063 : gcc_gimple_checking_assert (block == NULL_TREE
4110 : || TREE_CODE (block) == BLOCK);
4111 6070063 : bind_stmt->block = block;
4112 6070063 : }
4113 :
4114 :
4115 : /* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
4116 :
4117 : inline unsigned
4118 48110262 : gimple_asm_ninputs (const gasm *asm_stmt)
4119 : {
4120 48110262 : return asm_stmt->ni;
4121 : }
4122 :
4123 :
4124 : /* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
4125 :
4126 : inline unsigned
4127 78492336 : gimple_asm_noutputs (const gasm *asm_stmt)
4128 : {
4129 66446414 : return asm_stmt->no;
4130 : }
4131 :
4132 :
4133 : /* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
4134 :
4135 : inline unsigned
4136 14906228 : gimple_asm_nclobbers (const gasm *asm_stmt)
4137 : {
4138 14906228 : return asm_stmt->nc;
4139 : }
4140 :
4141 : /* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
4142 :
4143 : inline unsigned
4144 37918893 : gimple_asm_nlabels (const gasm *asm_stmt)
4145 : {
4146 37918465 : return asm_stmt->nl;
4147 : }
4148 :
4149 : /* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
4150 :
4151 : inline tree
4152 25329121 : gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
4153 : {
4154 25329121 : gcc_gimple_checking_assert (index < asm_stmt->ni);
4155 25329121 : return asm_stmt->op[index + asm_stmt->no];
4156 : }
4157 :
4158 : /* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */
4159 :
4160 : inline void
4161 47284 : gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
4162 : {
4163 47284 : gcc_gimple_checking_assert (index < asm_stmt->ni
4164 : && TREE_CODE (in_op) == TREE_LIST);
4165 47284 : asm_stmt->op[index + asm_stmt->no] = in_op;
4166 47284 : }
4167 :
4168 :
4169 : /* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
4170 :
4171 : inline tree
4172 37195349 : gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
4173 : {
4174 37195349 : gcc_gimple_checking_assert (index < asm_stmt->no);
4175 37195349 : return asm_stmt->op[index];
4176 : }
4177 :
4178 : /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
4179 :
4180 : inline void
4181 66237 : gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
4182 : {
4183 66237 : gcc_gimple_checking_assert (index < asm_stmt->no
4184 : && TREE_CODE (out_op) == TREE_LIST);
4185 66237 : asm_stmt->op[index] = out_op;
4186 66237 : }
4187 :
4188 :
4189 : /* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
4190 :
4191 : inline tree
4192 8527847 : gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
4193 : {
4194 8527847 : gcc_gimple_checking_assert (index < asm_stmt->nc);
4195 8527847 : return asm_stmt->op[index + asm_stmt->ni + asm_stmt->no];
4196 : }
4197 :
4198 :
4199 : /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */
4200 :
4201 : inline void
4202 80780 : gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
4203 : {
4204 80780 : gcc_gimple_checking_assert (index < asm_stmt->nc
4205 : && TREE_CODE (clobber_op) == TREE_LIST);
4206 80780 : asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op;
4207 80780 : }
4208 :
4209 : /* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
4210 :
4211 : inline tree
4212 240872 : gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
4213 : {
4214 240872 : gcc_gimple_checking_assert (index < asm_stmt->nl);
4215 240872 : return asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc];
4216 : }
4217 :
4218 : /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */
4219 :
4220 : inline void
4221 957 : gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
4222 : {
4223 957 : gcc_gimple_checking_assert (index < asm_stmt->nl
4224 : && TREE_CODE (label_op) == TREE_LIST);
4225 957 : asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc] = label_op;
4226 957 : }
4227 :
4228 : /* Return the string representing the assembly instruction in
4229 : GIMPLE_ASM ASM_STMT. */
4230 :
4231 : inline const char *
4232 1062248 : gimple_asm_string (const gasm *asm_stmt)
4233 : {
4234 1062248 : return asm_stmt->string;
4235 : }
4236 :
4237 :
4238 : /* Return true if ASM_STMT is marked volatile. */
4239 :
4240 : inline bool
4241 1594613 : gimple_asm_volatile_p (const gasm *asm_stmt)
4242 : {
4243 1594613 : return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0;
4244 : }
4245 :
4246 :
4247 : /* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
4248 :
4249 : inline void
4250 7370 : gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
4251 : {
4252 7370 : if (volatile_p)
4253 75721 : asm_stmt->subcode |= GF_ASM_VOLATILE;
4254 : else
4255 7370 : asm_stmt->subcode &= ~GF_ASM_VOLATILE;
4256 : }
4257 :
4258 :
4259 : /* Return true if ASM_STMT is marked inline. */
4260 :
4261 : inline bool
4262 676029 : gimple_asm_inline_p (const gasm *asm_stmt)
4263 : {
4264 676029 : return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
4265 : }
4266 :
4267 :
4268 : /* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
4269 :
4270 : inline void
4271 83091 : gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
4272 : {
4273 83091 : if (inline_p)
4274 97 : asm_stmt->subcode |= GF_ASM_INLINE;
4275 : else
4276 82994 : asm_stmt->subcode &= ~GF_ASM_INLINE;
4277 : }
4278 :
4279 :
4280 : /* Mark whether asm ASM_STMT is a basic asm or an extended asm, based on
4281 : BASIC_P. */
4282 :
4283 : inline void
4284 83091 : gimple_asm_set_basic (gasm *asm_stmt, bool basic_p)
4285 : {
4286 83091 : if (basic_p)
4287 2429 : asm_stmt->subcode |= GF_ASM_BASIC;
4288 : else
4289 80662 : asm_stmt->subcode &= ~GF_ASM_BASIC;
4290 : }
4291 :
4292 :
4293 : /* Return true if asm ASM_STMT is a basic asm rather than an extended asm. */
4294 :
4295 : inline bool
4296 6471383 : gimple_asm_basic_p (const gasm *asm_stmt)
4297 : {
4298 6471383 : return (asm_stmt->subcode & GF_ASM_BASIC) != 0;
4299 : }
4300 :
4301 :
4302 : /* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4303 :
4304 : inline tree
4305 64604 : gimple_catch_types (const gcatch *catch_stmt)
4306 : {
4307 64604 : return catch_stmt->types;
4308 : }
4309 :
4310 :
4311 : /* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4312 :
4313 : inline tree *
4314 17636 : gimple_catch_types_ptr (gcatch *catch_stmt)
4315 : {
4316 17636 : return &catch_stmt->types;
4317 : }
4318 :
4319 :
4320 : /* Return a pointer to the GIMPLE sequence representing the body of
4321 : the handler of GIMPLE_CATCH statement CATCH_STMT. */
4322 :
4323 : inline gimple_seq *
4324 78416 : gimple_catch_handler_ptr (gcatch *catch_stmt)
4325 : {
4326 78416 : return &catch_stmt->handler;
4327 : }
4328 :
4329 :
4330 : /* Return the GIMPLE sequence representing the body of the handler of
4331 : GIMPLE_CATCH statement CATCH_STMT. */
4332 :
4333 : inline gimple_seq
4334 396772 : gimple_catch_handler (const gcatch *catch_stmt)
4335 : {
4336 396772 : return *gimple_catch_handler_ptr (const_cast <gcatch *> (catch_stmt));
4337 : }
4338 :
4339 :
4340 : /* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */
4341 :
4342 : inline void
4343 60528 : gimple_catch_set_types (gcatch *catch_stmt, tree t)
4344 : {
4345 60528 : catch_stmt->types = t;
4346 : }
4347 :
4348 :
4349 : /* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4350 :
4351 : inline void
4352 60516 : gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
4353 : {
4354 60516 : catch_stmt->handler = handler;
4355 : }
4356 :
4357 :
4358 : /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4359 :
4360 : inline tree
4361 4503 : gimple_eh_filter_types (const gimple *gs)
4362 : {
4363 4503 : const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
4364 4503 : return eh_filter_stmt->types;
4365 : }
4366 :
4367 :
4368 : /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4369 : GS. */
4370 :
4371 : inline tree *
4372 71 : gimple_eh_filter_types_ptr (gimple *gs)
4373 : {
4374 71 : geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4375 71 : return &eh_filter_stmt->types;
4376 : }
4377 :
4378 :
4379 : /* Return a pointer to the sequence of statement to execute when
4380 : GIMPLE_EH_FILTER statement fails. */
4381 :
4382 : inline gimple_seq *
4383 41215 : gimple_eh_filter_failure_ptr (gimple *gs)
4384 : {
4385 31694 : geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4386 31694 : return &eh_filter_stmt->failure;
4387 : }
4388 :
4389 :
4390 : /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4391 : statement fails. */
4392 :
4393 : inline gimple_seq
4394 36106 : gimple_eh_filter_failure (const gimple *gs)
4395 : {
4396 36106 : return *gimple_eh_filter_failure_ptr (const_cast <gimple *> (gs));
4397 : }
4398 :
4399 :
4400 : /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4401 : EH_FILTER_STMT. */
4402 :
4403 : inline void
4404 4491 : gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
4405 : {
4406 4491 : eh_filter_stmt->types = types;
4407 : }
4408 :
4409 :
4410 : /* Set FAILURE to be the sequence of statements to execute on failure
4411 : for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4412 :
4413 : inline void
4414 4491 : gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt,
4415 : gimple_seq failure)
4416 : {
4417 4491 : eh_filter_stmt->failure = failure;
4418 : }
4419 :
4420 : /* Get the function decl to be called by the MUST_NOT_THROW region. */
4421 :
4422 : inline tree
4423 1346977 : gimple_eh_must_not_throw_fndecl (const geh_mnt *eh_mnt_stmt)
4424 : {
4425 1346977 : return eh_mnt_stmt->fndecl;
4426 : }
4427 :
4428 : /* Set the function decl to be called by GS to DECL. */
4429 :
4430 : inline void
4431 1340033 : gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt,
4432 : tree decl)
4433 : {
4434 1340033 : eh_mnt_stmt->fndecl = decl;
4435 : }
4436 :
4437 : /* GIMPLE_EH_ELSE accessors. */
4438 :
4439 : inline gimple_seq *
4440 1097 : gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
4441 : {
4442 1097 : return &eh_else_stmt->n_body;
4443 : }
4444 :
4445 : inline gimple_seq
4446 5344 : gimple_eh_else_n_body (const geh_else *eh_else_stmt)
4447 : {
4448 5033 : return *gimple_eh_else_n_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4449 : }
4450 :
4451 : inline gimple_seq *
4452 1097 : gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
4453 : {
4454 1097 : return &eh_else_stmt->e_body;
4455 : }
4456 :
4457 : inline gimple_seq
4458 4229 : gimple_eh_else_e_body (const geh_else *eh_else_stmt)
4459 : {
4460 4229 : return *gimple_eh_else_e_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4461 : }
4462 :
4463 : inline void
4464 827 : gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
4465 : {
4466 273 : eh_else_stmt->n_body = seq;
4467 : }
4468 :
4469 : inline void
4470 827 : gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
4471 : {
4472 273 : eh_else_stmt->e_body = seq;
4473 : }
4474 :
4475 : /* GIMPLE_TRY accessors. */
4476 :
4477 : /* Return the kind of try block represented by GIMPLE_TRY GS. This is
4478 : either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
4479 :
4480 : inline enum gimple_try_flags
4481 10576638 : gimple_try_kind (const gimple *gs)
4482 : {
4483 10576638 : GIMPLE_CHECK (gs, GIMPLE_TRY);
4484 10576638 : return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
4485 : }
4486 :
4487 :
4488 : /* Set the kind of try block represented by GIMPLE_TRY GS. */
4489 :
4490 : inline void
4491 1 : gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
4492 : {
4493 1 : gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
4494 : || kind == GIMPLE_TRY_FINALLY);
4495 1 : if (gimple_try_kind (gs) != kind)
4496 1 : gs->subcode = (unsigned int) kind;
4497 1 : }
4498 :
4499 :
4500 : /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4501 :
4502 : inline bool
4503 6143 : gimple_try_catch_is_cleanup (const gimple *gs)
4504 : {
4505 6143 : gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
4506 6143 : return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
4507 : }
4508 :
4509 :
4510 : /* Return a pointer to the sequence of statements used as the
4511 : body for GIMPLE_TRY GS. */
4512 :
4513 : inline gimple_seq *
4514 29625969 : gimple_try_eval_ptr (gimple *gs)
4515 : {
4516 20404113 : gtry *try_stmt = as_a <gtry *> (gs);
4517 20404113 : return &try_stmt->eval;
4518 : }
4519 :
4520 :
4521 : /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4522 :
4523 : inline gimple_seq
4524 25022334 : gimple_try_eval (const gimple *gs)
4525 : {
4526 25022334 : return *gimple_try_eval_ptr (const_cast <gimple *> (gs));
4527 : }
4528 :
4529 :
4530 : /* Return a pointer to the sequence of statements used as the cleanup body for
4531 : GIMPLE_TRY GS. */
4532 :
4533 : inline gimple_seq *
4534 30071472 : gimple_try_cleanup_ptr (gimple *gs)
4535 : {
4536 17895696 : gtry *try_stmt = as_a <gtry *> (gs);
4537 17895696 : return &try_stmt->cleanup;
4538 : }
4539 :
4540 :
4541 : /* Return the sequence of statements used as the cleanup body for
4542 : GIMPLE_TRY GS. */
4543 :
4544 : inline gimple_seq
4545 14410125 : gimple_try_cleanup (const gimple *gs)
4546 : {
4547 26027683 : return *gimple_try_cleanup_ptr (const_cast <gimple *> (gs));
4548 : }
4549 :
4550 :
4551 : /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4552 :
4553 : inline void
4554 172967 : gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
4555 : {
4556 172967 : gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
4557 172967 : if (catch_is_cleanup)
4558 216 : g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
4559 : else
4560 172751 : g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
4561 172967 : }
4562 :
4563 :
4564 : /* Set EVAL to be the sequence of statements to use as the body for
4565 : GIMPLE_TRY TRY_STMT. */
4566 :
4567 : inline void
4568 3203754 : gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
4569 : {
4570 3203754 : try_stmt->eval = eval;
4571 : }
4572 :
4573 :
4574 : /* Set CLEANUP to be the sequence of statements to use as the cleanup
4575 : body for GIMPLE_TRY TRY_STMT. */
4576 :
4577 : inline void
4578 3359962 : gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
4579 : {
4580 3359962 : try_stmt->cleanup = cleanup;
4581 : }
4582 :
4583 :
4584 : /* Return a pointer to the cleanup sequence for cleanup statement GS. */
4585 :
4586 : inline gimple_seq *
4587 650491 : gimple_wce_cleanup_ptr (gimple *gs)
4588 : {
4589 650491 : gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4590 650491 : return &wce_stmt->cleanup;
4591 : }
4592 :
4593 :
4594 : /* Return the cleanup sequence for cleanup statement GS. */
4595 :
4596 : inline gimple_seq
4597 650491 : gimple_wce_cleanup (gimple *gs)
4598 : {
4599 650491 : return *gimple_wce_cleanup_ptr (gs);
4600 : }
4601 :
4602 :
4603 : /* Set CLEANUP to be the cleanup sequence for GS. */
4604 :
4605 : inline void
4606 650491 : gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
4607 : {
4608 650491 : gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4609 650491 : wce_stmt->cleanup = cleanup;
4610 : }
4611 :
4612 :
4613 : /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4614 :
4615 : inline bool
4616 650491 : gimple_wce_cleanup_eh_only (const gimple *gs)
4617 : {
4618 650491 : GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4619 650491 : return gs->subcode != 0;
4620 : }
4621 :
4622 :
4623 : /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4624 :
4625 : inline void
4626 635821 : gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
4627 : {
4628 635821 : GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4629 635821 : gs->subcode = (unsigned int) eh_only_p;
4630 635821 : }
4631 :
4632 :
4633 : /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4634 :
4635 : inline unsigned
4636 424693782 : gimple_phi_capacity (const gimple *gs)
4637 : {
4638 381905172 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4639 424693782 : return phi_stmt->capacity;
4640 : }
4641 :
4642 :
4643 : /* Return the number of arguments in GIMPLE_PHI GS. This must always
4644 : be exactly the number of incoming edges for the basic block holding
4645 : GS. */
4646 :
4647 : inline unsigned
4648 7501298010 : gimple_phi_num_args (const gimple *gs)
4649 : {
4650 7504130574 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4651 7504907294 : return phi_stmt->nargs;
4652 : }
4653 :
4654 :
4655 : /* Return the SSA name created by GIMPLE_PHI GS. */
4656 :
4657 : inline tree
4658 8815846601 : gimple_phi_result (const gphi *gs)
4659 : {
4660 8231409349 : return gs->result;
4661 : }
4662 :
4663 : inline tree
4664 756729949 : gimple_phi_result (const gimple *gs)
4665 : {
4666 749169046 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4667 758245340 : return gimple_phi_result (phi_stmt);
4668 : }
4669 :
4670 : /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4671 :
4672 : inline tree *
4673 16838352 : gimple_phi_result_ptr (gphi *gs)
4674 : {
4675 16838352 : return &gs->result;
4676 : }
4677 :
4678 : inline tree *
4679 : gimple_phi_result_ptr (gimple *gs)
4680 : {
4681 : gphi *phi_stmt = as_a <gphi *> (gs);
4682 : return gimple_phi_result_ptr (phi_stmt);
4683 : }
4684 :
4685 : /* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4686 :
4687 : inline void
4688 14667623 : gimple_phi_set_result (gphi *phi, tree result)
4689 : {
4690 14667623 : phi->result = result;
4691 14667623 : if (result && TREE_CODE (result) == SSA_NAME)
4692 14667623 : SSA_NAME_DEF_STMT (result) = phi;
4693 : }
4694 :
4695 :
4696 : /* Return the PHI argument corresponding to incoming edge INDEX for
4697 : GIMPLE_PHI GS. */
4698 :
4699 : inline struct phi_arg_d *
4700 3460540469 : gimple_phi_arg (gphi *gs, unsigned index)
4701 : {
4702 424168373 : gcc_gimple_checking_assert (index < gs->nargs);
4703 1418624369 : return &(gs->args[index]);
4704 : }
4705 :
4706 : inline const phi_arg_d *
4707 8185338527 : gimple_phi_arg (const gphi *gs, unsigned index)
4708 : {
4709 26641 : gcc_gimple_checking_assert (index < gs->nargs);
4710 8185306488 : return &(gs->args[index]);
4711 : }
4712 :
4713 : inline const phi_arg_d *
4714 771479885 : gimple_phi_arg (const gimple *gs, unsigned index)
4715 : {
4716 771479885 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4717 771479885 : return gimple_phi_arg (phi_stmt, index);
4718 : }
4719 :
4720 : inline struct phi_arg_d *
4721 2648660101 : gimple_phi_arg (gimple *gs, unsigned index)
4722 : {
4723 2648660101 : gphi *phi_stmt = as_a <gphi *> (gs);
4724 2648660101 : return gimple_phi_arg (phi_stmt, index);
4725 : }
4726 :
4727 : /* Set PHIARG to be the argument corresponding to incoming edge INDEX
4728 : for GIMPLE_PHI PHI. */
4729 :
4730 : inline void
4731 : gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d * phiarg)
4732 : {
4733 : gcc_gimple_checking_assert (index < phi->nargs);
4734 : phi->args[index] = *phiarg;
4735 : }
4736 :
4737 : /* Return the PHI nodes for basic block BB, or NULL if there are no
4738 : PHI nodes. */
4739 :
4740 : inline gimple_seq
4741 733857698 : phi_nodes (const_basic_block bb)
4742 : {
4743 733857698 : gcc_checking_assert (!(bb->flags & BB_RTL));
4744 733857698 : return bb->il.gimple.phi_nodes;
4745 : }
4746 :
4747 : /* Return a pointer to the PHI nodes for basic block BB. */
4748 :
4749 : inline gimple_seq *
4750 12322613415 : phi_nodes_ptr (basic_block bb)
4751 : {
4752 12322613415 : gcc_checking_assert (!(bb->flags & BB_RTL));
4753 12322613415 : return &bb->il.gimple.phi_nodes;
4754 : }
4755 :
4756 : /* Return the tree operand for argument I of PHI node GS. */
4757 :
4758 : inline tree
4759 4550279773 : gimple_phi_arg_def (const gphi *gs, size_t index)
4760 : {
4761 4570789776 : return gimple_phi_arg (gs, index)->def;
4762 : }
4763 :
4764 : inline tree
4765 440978844 : gimple_phi_arg_def (const gimple *gs, size_t index)
4766 : {
4767 440973378 : return gimple_phi_arg (gs, index)->def;
4768 : }
4769 :
4770 : /* Return the tree operand for the argument associated with
4771 : edge E of PHI node GS. */
4772 :
4773 : inline tree
4774 985061017 : gimple_phi_arg_def_from_edge (const gphi *gs, const_edge e)
4775 : {
4776 985061017 : gcc_checking_assert (e->dest == gimple_bb (gs));
4777 985061017 : return gimple_phi_arg (gs, e->dest_idx)->def;
4778 : }
4779 :
4780 : inline tree
4781 330500160 : gimple_phi_arg_def_from_edge (const gimple *gs, const_edge e)
4782 : {
4783 330500160 : gcc_checking_assert (e->dest == gimple_bb (gs));
4784 330500160 : return gimple_phi_arg (gs, e->dest_idx)->def;
4785 : }
4786 :
4787 : /* Return a pointer to the tree operand for argument I of phi node PHI. */
4788 :
4789 : inline tree *
4790 105280201 : gimple_phi_arg_def_ptr (gphi *phi, size_t index)
4791 : {
4792 105280201 : return &gimple_phi_arg (phi, index)->def;
4793 : }
4794 :
4795 : /* Return the edge associated with argument I of phi node PHI. */
4796 :
4797 : inline edge
4798 700383863 : gimple_phi_arg_edge (const gphi *phi, size_t i)
4799 : {
4800 714519295 : return EDGE_PRED (gimple_bb (phi), i);
4801 : }
4802 :
4803 : /* Return the source location of gimple argument I of phi node PHI. */
4804 :
4805 : inline location_t
4806 1852052513 : gimple_phi_arg_location (const gphi *phi, size_t i)
4807 : {
4808 1852052513 : return gimple_phi_arg (phi, i)->locus;
4809 : }
4810 :
4811 : /* Return the source location of the argument on edge E of phi node PHI. */
4812 :
4813 : inline location_t
4814 15802539 : gimple_phi_arg_location_from_edge (gphi *phi, edge e)
4815 : {
4816 15802539 : return gimple_phi_arg (phi, e->dest_idx)->locus;
4817 : }
4818 :
4819 : /* Set the source location of gimple argument I of phi node PHI to LOC. */
4820 :
4821 : inline void
4822 266405024 : gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
4823 : {
4824 266405024 : gimple_phi_arg (phi, i)->locus = loc;
4825 266405024 : }
4826 :
4827 : /* Return address of source location of gimple argument I of phi node PHI. */
4828 :
4829 : inline location_t *
4830 184911 : gimple_phi_arg_location_ptr (gphi *phi, size_t i)
4831 : {
4832 184911 : return &gimple_phi_arg (phi, i)->locus;
4833 : }
4834 :
4835 : /* Return TRUE if argument I of phi node PHI has a location record. */
4836 :
4837 : inline bool
4838 8088927 : gimple_phi_arg_has_location (const gphi *phi, size_t i)
4839 : {
4840 8088927 : return gimple_phi_arg_location (phi, i) != UNKNOWN_LOCATION;
4841 : }
4842 :
4843 : /* Return the number of arguments that can be accessed by gimple_arg. */
4844 :
4845 : inline unsigned
4846 24868927 : gimple_num_args (const gimple *gs)
4847 : {
4848 24868927 : if (auto phi = dyn_cast<const gphi *> (gs))
4849 1375891 : return gimple_phi_num_args (phi);
4850 23493036 : if (auto call = dyn_cast<const gcall *> (gs))
4851 143309 : return gimple_call_num_args (call);
4852 23349727 : return gimple_num_ops (as_a <const gassign *> (gs)) - 1;
4853 : }
4854 :
4855 : /* GS must be an assignment, a call, or a PHI.
4856 : If it's an assignment, return rhs operand I.
4857 : If it's a call, return function argument I.
4858 : If it's a PHI, return the value of PHI argument I. */
4859 :
4860 : inline tree
4861 35993012 : gimple_arg (const gimple *gs, unsigned int i)
4862 : {
4863 35993012 : if (auto phi = dyn_cast<const gphi *> (gs))
4864 1781265 : return gimple_phi_arg_def (phi, i);
4865 34211747 : if (auto call = dyn_cast<const gcall *> (gs))
4866 119074 : return gimple_call_arg (call, i);
4867 34092673 : return gimple_op (as_a <const gassign *> (gs), i + 1);
4868 : }
4869 :
4870 : /* Return a pointer to gimple_arg (GS, I). */
4871 :
4872 : inline tree *
4873 : gimple_arg_ptr (gimple *gs, unsigned int i)
4874 : {
4875 : if (auto phi = dyn_cast<gphi *> (gs))
4876 : return gimple_phi_arg_def_ptr (phi, i);
4877 : if (auto call = dyn_cast<gcall *> (gs))
4878 : return gimple_call_arg_ptr (call, i);
4879 : return gimple_op_ptr (as_a <gassign *> (gs), i + 1);
4880 : }
4881 :
4882 : /* Return the region number for GIMPLE_RESX RESX_STMT. */
4883 :
4884 : inline int
4885 1459823 : gimple_resx_region (const gresx *resx_stmt)
4886 : {
4887 1459823 : return resx_stmt->region;
4888 : }
4889 :
4890 : /* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4891 :
4892 : inline void
4893 84020 : gimple_resx_set_region (gresx *resx_stmt, int region)
4894 : {
4895 84020 : resx_stmt->region = region;
4896 : }
4897 :
4898 : /* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4899 :
4900 : inline int
4901 2199069 : gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
4902 : {
4903 2198913 : return eh_dispatch_stmt->region;
4904 : }
4905 :
4906 : /* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4907 : EH_DISPATCH_STMT. */
4908 :
4909 : inline void
4910 11030 : gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
4911 : {
4912 11030 : eh_dispatch_stmt->region = region;
4913 : }
4914 :
4915 : /* Return the number of labels associated with the switch statement GS. */
4916 :
4917 : inline unsigned
4918 14393317 : gimple_switch_num_labels (const gswitch *gs)
4919 : {
4920 14393317 : unsigned num_ops;
4921 14393317 : GIMPLE_CHECK (gs, GIMPLE_SWITCH);
4922 14393317 : num_ops = gimple_num_ops (gs);
4923 14393317 : gcc_gimple_checking_assert (num_ops > 1);
4924 14393317 : return num_ops - 1;
4925 : }
4926 :
4927 :
4928 : /* Set NLABELS to be the number of labels for the switch statement GS. */
4929 :
4930 : inline void
4931 24186 : gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
4932 : {
4933 24186 : GIMPLE_CHECK (g, GIMPLE_SWITCH);
4934 24186 : gimple_set_num_ops (g, nlabels + 1);
4935 24186 : }
4936 :
4937 :
4938 : /* Return the index variable used by the switch statement GS. */
4939 :
4940 : inline tree
4941 13658556 : gimple_switch_index (const gswitch *gs)
4942 : {
4943 13590963 : return gs->op[0];
4944 : }
4945 :
4946 :
4947 : /* Return a pointer to the index variable for the switch statement GS. */
4948 :
4949 : inline tree *
4950 3595599 : gimple_switch_index_ptr (gswitch *gs)
4951 : {
4952 3595599 : return &gs->op[0];
4953 : }
4954 :
4955 :
4956 : /* Set INDEX to be the index variable for switch statement GS. */
4957 :
4958 : inline void
4959 117476 : gimple_switch_set_index (gswitch *gs, tree index)
4960 : {
4961 117476 : gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
4962 117476 : gs->op[0] = index;
4963 117476 : }
4964 :
4965 :
4966 : /* Return the label numbered INDEX. The default label is 0, followed by any
4967 : labels in a switch statement. */
4968 :
4969 : inline tree
4970 147190719 : gimple_switch_label (const gswitch *gs, unsigned index)
4971 : {
4972 147144650 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
4973 10992440 : return gs->op[index + 1];
4974 : }
4975 :
4976 : /* Set the label number INDEX to LABEL. 0 is always the default label. */
4977 :
4978 : inline void
4979 1268756 : gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
4980 : {
4981 1268756 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
4982 : && (label == NULL_TREE
4983 : || TREE_CODE (label) == CASE_LABEL_EXPR));
4984 1268756 : gs->op[index + 1] = label;
4985 1268756 : }
4986 :
4987 : /* Return the default label for a switch statement. */
4988 :
4989 : inline tree
4990 46069 : gimple_switch_default_label (const gswitch *gs)
4991 : {
4992 46069 : tree label = gimple_switch_label (gs, 0);
4993 46069 : gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4994 46069 : return label;
4995 : }
4996 :
4997 : /* Set the default label for a switch statement. */
4998 :
4999 : inline void
5000 70062 : gimple_switch_set_default_label (gswitch *gs, tree label)
5001 : {
5002 70062 : gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
5003 70062 : gimple_switch_set_label (gs, 0, label);
5004 70062 : }
5005 :
5006 : /* Return true if GS is a GIMPLE_DEBUG statement. */
5007 :
5008 : inline bool
5009 70784691417 : is_gimple_debug (const gimple *gs)
5010 : {
5011 59911017167 : return gimple_code (gs) == GIMPLE_DEBUG;
5012 : }
5013 :
5014 :
5015 : /* Return the first nondebug statement in GIMPLE sequence S. */
5016 :
5017 : inline gimple *
5018 4756679 : gimple_seq_first_nondebug_stmt (gimple_seq s)
5019 : {
5020 4756679 : gimple_seq_node n = gimple_seq_first (s);
5021 4824446 : while (n && is_gimple_debug (n))
5022 67767 : n = n->next;
5023 4756679 : return n;
5024 : }
5025 :
5026 :
5027 : /* Return the last nondebug statement in GIMPLE sequence S. */
5028 :
5029 : inline gimple *
5030 17193706 : gimple_seq_last_nondebug_stmt (gimple_seq s)
5031 : {
5032 17193706 : gimple_seq_node n;
5033 34166119 : for (n = gimple_seq_last (s);
5034 17325012 : n && is_gimple_debug (n);
5035 131306 : n = n->prev)
5036 134085 : if (n == s)
5037 : return NULL;
5038 : return n;
5039 : }
5040 :
5041 :
5042 : /* Return true if S is a GIMPLE_DEBUG BIND statement. */
5043 :
5044 : inline bool
5045 38687159269 : gimple_debug_bind_p (const gimple *s)
5046 : {
5047 17759129694 : if (is_gimple_debug (s))
5048 17496344213 : return s->subcode == GIMPLE_DEBUG_BIND;
5049 :
5050 : return false;
5051 : }
5052 :
5053 : /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
5054 :
5055 : inline tree
5056 1074940739 : gimple_debug_bind_get_var (const gimple *dbg)
5057 : {
5058 1074940739 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5059 1074940739 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5060 1074940739 : return gimple_op (dbg, 0);
5061 : }
5062 :
5063 : /* Return the value bound to the variable in a GIMPLE_DEBUG bind
5064 : statement. */
5065 :
5066 : inline tree
5067 628302129 : gimple_debug_bind_get_value (const gimple *dbg)
5068 : {
5069 628302129 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5070 628302129 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5071 628302129 : return gimple_op (dbg, 1);
5072 : }
5073 :
5074 : /* Return a pointer to the value bound to the variable in a
5075 : GIMPLE_DEBUG bind statement. */
5076 :
5077 : inline tree *
5078 3178294390 : gimple_debug_bind_get_value_ptr (gimple *dbg)
5079 : {
5080 3178294390 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5081 3178294390 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5082 3178294390 : return gimple_op_ptr (dbg, 1);
5083 : }
5084 :
5085 : /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
5086 :
5087 : inline void
5088 116737926 : gimple_debug_bind_set_var (gimple *dbg, tree var)
5089 : {
5090 116737926 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5091 116737926 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5092 116737926 : gimple_set_op (dbg, 0, var);
5093 116737926 : }
5094 :
5095 : /* Set the value bound to the variable in a GIMPLE_DEBUG bind
5096 : statement. */
5097 :
5098 : inline void
5099 69668934 : gimple_debug_bind_set_value (gimple *dbg, tree value)
5100 : {
5101 69668934 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5102 69668934 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5103 69668934 : gimple_set_op (dbg, 1, value);
5104 69668934 : }
5105 :
5106 : /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
5107 : optimized away. */
5108 : #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
5109 :
5110 : /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
5111 : statement. */
5112 :
5113 : inline void
5114 9845995 : gimple_debug_bind_reset_value (gimple *dbg)
5115 : {
5116 9845995 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5117 9845995 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5118 9845995 : gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
5119 9845995 : }
5120 :
5121 : /* Return true if the GIMPLE_DEBUG bind statement is bound to a
5122 : value. */
5123 :
5124 : inline bool
5125 10538055842 : gimple_debug_bind_has_value_p (gimple *dbg)
5126 : {
5127 10538055842 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5128 10538055842 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5129 10538055842 : return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
5130 : }
5131 :
5132 : #undef GIMPLE_DEBUG_BIND_NOVALUE
5133 :
5134 : /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
5135 :
5136 : inline bool
5137 102296079 : gimple_debug_source_bind_p (const gimple *s)
5138 : {
5139 101233051 : if (is_gimple_debug (s))
5140 69230886 : return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
5141 :
5142 : return false;
5143 : }
5144 :
5145 : /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
5146 :
5147 : inline tree
5148 1350943 : gimple_debug_source_bind_get_var (const gimple *dbg)
5149 : {
5150 1350943 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5151 1350943 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5152 1350943 : return gimple_op (dbg, 0);
5153 : }
5154 :
5155 : /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
5156 : statement. */
5157 :
5158 : inline tree
5159 1303964 : gimple_debug_source_bind_get_value (const gimple *dbg)
5160 : {
5161 1303964 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5162 1303964 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5163 1303964 : return gimple_op (dbg, 1);
5164 : }
5165 :
5166 : /* Return a pointer to the value bound to the variable in a
5167 : GIMPLE_DEBUG source bind statement. */
5168 :
5169 : inline tree *
5170 145494 : gimple_debug_source_bind_get_value_ptr (gimple *dbg)
5171 : {
5172 145494 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5173 145494 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5174 145494 : return gimple_op_ptr (dbg, 1);
5175 : }
5176 :
5177 : /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
5178 :
5179 : inline void
5180 1274902 : gimple_debug_source_bind_set_var (gimple *dbg, tree var)
5181 : {
5182 1274902 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5183 1274902 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5184 1274902 : gimple_set_op (dbg, 0, var);
5185 1274902 : }
5186 :
5187 : /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
5188 : statement. */
5189 :
5190 : inline void
5191 710934 : gimple_debug_source_bind_set_value (gimple *dbg, tree value)
5192 : {
5193 710934 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5194 710934 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5195 710934 : gimple_set_op (dbg, 1, value);
5196 710934 : }
5197 :
5198 : /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
5199 :
5200 : inline bool
5201 302257089 : gimple_debug_begin_stmt_p (const gimple *s)
5202 : {
5203 314053697 : if (is_gimple_debug (s))
5204 85629108 : return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
5205 :
5206 : return false;
5207 : }
5208 :
5209 : /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
5210 :
5211 : inline bool
5212 1353391 : gimple_debug_inline_entry_p (const gimple *s)
5213 : {
5214 9046493 : if (is_gimple_debug (s))
5215 14195 : return s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5216 :
5217 : return false;
5218 : }
5219 :
5220 : /* Return true if S is a GIMPLE_DEBUG non-binding marker statement. */
5221 :
5222 : inline bool
5223 821109580 : gimple_debug_nonbind_marker_p (const gimple *s)
5224 : {
5225 770858712 : if (is_gimple_debug (s))
5226 647573705 : return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
5227 647573705 : || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5228 :
5229 : return false;
5230 : }
5231 :
5232 : /* Return the line number for EXPR, or return -1 if we have no line
5233 : number information for it. */
5234 : inline int
5235 0 : get_lineno (const gimple *stmt)
5236 : {
5237 0 : location_t loc;
5238 :
5239 0 : if (!stmt)
5240 : return -1;
5241 :
5242 0 : loc = gimple_location (stmt);
5243 0 : if (loc == UNKNOWN_LOCATION)
5244 : return -1;
5245 :
5246 0 : return LOCATION_LINE (loc);
5247 : }
5248 :
5249 : /* Return a pointer to the body for the OMP statement GS. */
5250 :
5251 : inline gimple_seq *
5252 493225 : gimple_omp_body_ptr (gimple *gs)
5253 : {
5254 493134 : return &static_cast <gimple_statement_omp *> (gs)->body;
5255 : }
5256 :
5257 : /* Return the body for the OMP statement GS. */
5258 :
5259 : inline gimple_seq
5260 403795 : gimple_omp_body (const gimple *gs)
5261 : {
5262 403795 : return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
5263 : }
5264 :
5265 : /* Set BODY to be the body for the OMP statement GS. */
5266 :
5267 : inline void
5268 297182 : gimple_omp_set_body (gimple *gs, gimple_seq body)
5269 : {
5270 294294 : static_cast <gimple_statement_omp *> (gs)->body = body;
5271 : }
5272 :
5273 :
5274 : /* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
5275 :
5276 : inline tree
5277 832 : gimple_omp_critical_name (const gomp_critical *crit_stmt)
5278 : {
5279 832 : return crit_stmt->name;
5280 : }
5281 :
5282 :
5283 : /* Return a pointer to the name associated with OMP critical statement
5284 : CRIT_STMT. */
5285 :
5286 : inline tree *
5287 1376 : gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
5288 : {
5289 1376 : return &crit_stmt->name;
5290 : }
5291 :
5292 :
5293 : /* Set NAME to be the name associated with OMP critical statement
5294 : CRIT_STMT. */
5295 :
5296 : inline void
5297 552 : gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
5298 : {
5299 552 : crit_stmt->name = name;
5300 : }
5301 :
5302 :
5303 : /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
5304 :
5305 : inline tree
5306 16 : gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
5307 : {
5308 16 : return crit_stmt->clauses;
5309 : }
5310 :
5311 :
5312 : /* Return a pointer to the clauses associated with OMP critical statement
5313 : CRIT_STMT. */
5314 :
5315 : inline tree *
5316 1376 : gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
5317 : {
5318 1376 : return &crit_stmt->clauses;
5319 : }
5320 :
5321 :
5322 : /* Set CLAUSES to be the clauses associated with OMP critical statement
5323 : CRIT_STMT. */
5324 :
5325 : inline void
5326 552 : gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
5327 : {
5328 552 : crit_stmt->clauses = clauses;
5329 : }
5330 :
5331 :
5332 : /* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
5333 :
5334 : inline tree
5335 7098 : gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
5336 : {
5337 7098 : return ord_stmt->clauses;
5338 : }
5339 :
5340 :
5341 : /* Return a pointer to the clauses associated with OMP ordered statement
5342 : ORD_STMT. */
5343 :
5344 : inline tree *
5345 5479 : gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
5346 : {
5347 5479 : return &ord_stmt->clauses;
5348 : }
5349 :
5350 :
5351 : /* Set CLAUSES to be the clauses associated with OMP ordered statement
5352 : ORD_STMT. */
5353 :
5354 : inline void
5355 1852 : gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
5356 : {
5357 1852 : ord_stmt->clauses = clauses;
5358 : }
5359 :
5360 :
5361 : /* Return the clauses associated with OMP_SCAN statement SCAN_STMT. */
5362 :
5363 : inline tree
5364 3275 : gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
5365 : {
5366 3275 : return scan_stmt->clauses;
5367 : }
5368 :
5369 :
5370 : /* Return a pointer to the clauses associated with OMP scan statement
5371 : ORD_STMT. */
5372 :
5373 : inline tree *
5374 880 : gimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
5375 : {
5376 880 : return &scan_stmt->clauses;
5377 : }
5378 :
5379 :
5380 : /* Set CLAUSES to be the clauses associated with OMP scan statement
5381 : ORD_STMT. */
5382 :
5383 : inline void
5384 1324 : gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
5385 : {
5386 1324 : scan_stmt->clauses = clauses;
5387 : }
5388 :
5389 :
5390 : /* Return the clauses associated with OMP_TASKGROUP statement GS. */
5391 :
5392 : inline tree
5393 1145 : gimple_omp_taskgroup_clauses (const gimple *gs)
5394 : {
5395 1145 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5396 1145 : return
5397 1145 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5398 : }
5399 :
5400 :
5401 : /* Return a pointer to the clauses associated with OMP taskgroup statement
5402 : GS. */
5403 :
5404 : inline tree *
5405 76 : gimple_omp_taskgroup_clauses_ptr (gimple *gs)
5406 : {
5407 76 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5408 76 : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5409 : }
5410 :
5411 :
5412 : /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
5413 : GS. */
5414 :
5415 : inline void
5416 611 : gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
5417 : {
5418 611 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5419 611 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5420 611 : = clauses;
5421 611 : }
5422 :
5423 :
5424 : /* Return the clauses associated with OMP_MASKED statement GS. */
5425 :
5426 : inline tree
5427 909 : gimple_omp_masked_clauses (const gimple *gs)
5428 : {
5429 909 : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5430 909 : return
5431 909 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5432 : }
5433 :
5434 :
5435 : /* Return a pointer to the clauses associated with OMP masked statement
5436 : GS. */
5437 :
5438 : inline tree *
5439 : gimple_omp_masked_clauses_ptr (gimple *gs)
5440 : {
5441 : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5442 : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5443 : }
5444 :
5445 :
5446 : /* Set CLAUSES to be the clauses associated with OMP masked statement
5447 : GS. */
5448 :
5449 : inline void
5450 500 : gimple_omp_masked_set_clauses (gimple *gs, tree clauses)
5451 : {
5452 500 : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5453 500 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5454 500 : = clauses;
5455 500 : }
5456 :
5457 :
5458 : /* Return the clauses associated with OMP_SCOPE statement GS. */
5459 :
5460 : inline tree
5461 1048 : gimple_omp_scope_clauses (const gimple *gs)
5462 : {
5463 1048 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5464 1048 : return
5465 1048 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5466 : }
5467 :
5468 :
5469 : /* Return a pointer to the clauses associated with OMP scope statement
5470 : GS. */
5471 :
5472 : inline tree *
5473 0 : gimple_omp_scope_clauses_ptr (gimple *gs)
5474 : {
5475 0 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5476 0 : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5477 : }
5478 :
5479 :
5480 : /* Set CLAUSES to be the clauses associated with OMP scope statement
5481 : GS. */
5482 :
5483 : inline void
5484 296 : gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
5485 : {
5486 296 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5487 296 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5488 296 : = clauses;
5489 296 : }
5490 :
5491 : /* Return the clauses associated with OMP_DISPATCH statement GS. */
5492 :
5493 : inline tree
5494 401 : gimple_omp_dispatch_clauses (const gimple *gs)
5495 : {
5496 401 : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5497 401 : return static_cast<const gimple_statement_omp_single_layout *> (gs)->clauses;
5498 : }
5499 :
5500 : /* Return a pointer to the clauses associated with OMP dispatch statement
5501 : GS. */
5502 :
5503 : inline tree *
5504 : gimple_omp_dispatch_clauses_ptr (gimple *gs)
5505 : {
5506 : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5507 : return &static_cast<gimple_statement_omp_single_layout *> (gs)->clauses;
5508 : }
5509 :
5510 : /* Set CLAUSES to be the clauses associated with OMP dispatch statement
5511 : GS. */
5512 :
5513 : inline void
5514 852 : gimple_omp_dispatch_set_clauses (gimple *gs, tree clauses)
5515 : {
5516 852 : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5517 852 : static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5518 852 : }
5519 :
5520 : /* Return the clauses associated with OMP_INTEROP statement GS. */
5521 :
5522 : inline tree
5523 164 : gimple_omp_interop_clauses (const gimple *gs)
5524 : {
5525 164 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5526 164 : return static_cast<const gimple_statement_omp_single_layout *> (gs)->clauses;
5527 : }
5528 :
5529 : /* Return a pointer to the clauses associated with OMP_INTEROP statement GS. */
5530 :
5531 : inline tree *
5532 35 : gimple_omp_interop_clauses_ptr (gimple *gs)
5533 : {
5534 35 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5535 35 : return &static_cast<gimple_statement_omp_single_layout *> (gs)->clauses;
5536 : }
5537 :
5538 : /* Set CLAUSES to be the clauses associated with OMP interop statement
5539 : GS. */
5540 :
5541 : inline void
5542 612 : gimple_omp_interop_set_clauses (gimple *gs, tree clauses)
5543 : {
5544 612 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5545 612 : static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5546 612 : }
5547 :
5548 : /* Return the kind of the OMP_FOR statemement G. */
5549 :
5550 : inline int
5551 1199297 : gimple_omp_for_kind (const gimple *g)
5552 : {
5553 1199297 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5554 1199297 : return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
5555 : }
5556 :
5557 :
5558 : /* Set the kind of the OMP_FOR statement G. */
5559 :
5560 : inline void
5561 53696 : gimple_omp_for_set_kind (gomp_for *g, int kind)
5562 : {
5563 53696 : g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
5564 53696 : | (kind & GF_OMP_FOR_KIND_MASK);
5565 : }
5566 :
5567 :
5568 : /* Return true if OMP_FOR statement G has the
5569 : GF_OMP_FOR_COMBINED flag set. */
5570 :
5571 : inline bool
5572 163921 : gimple_omp_for_combined_p (const gimple *g)
5573 : {
5574 163921 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5575 163921 : return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
5576 : }
5577 :
5578 :
5579 : /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5580 : the boolean value of COMBINED_P. */
5581 :
5582 : inline void
5583 15588 : gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
5584 : {
5585 15588 : if (combined_p)
5586 15588 : g->subcode |= GF_OMP_FOR_COMBINED;
5587 : else
5588 : g->subcode &= ~GF_OMP_FOR_COMBINED;
5589 : }
5590 :
5591 :
5592 : /* Return true if the OMP_FOR statement G has the
5593 : GF_OMP_FOR_COMBINED_INTO flag set. */
5594 :
5595 : inline bool
5596 172258 : gimple_omp_for_combined_into_p (const gimple *g)
5597 : {
5598 172258 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5599 172258 : return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
5600 : }
5601 :
5602 :
5603 : /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5604 : on the boolean value of COMBINED_P. */
5605 :
5606 : inline void
5607 15588 : gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
5608 : {
5609 15588 : if (combined_p)
5610 15588 : g->subcode |= GF_OMP_FOR_COMBINED_INTO;
5611 : else
5612 : g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
5613 : }
5614 :
5615 :
5616 : /* Return the clauses associated with the OMP_FOR statement GS. */
5617 :
5618 : inline tree
5619 609981 : gimple_omp_for_clauses (const gimple *gs)
5620 : {
5621 609981 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5622 609981 : return omp_for_stmt->clauses;
5623 : }
5624 :
5625 :
5626 : /* Return a pointer to the clauses associated with the OMP_FOR statement
5627 : GS. */
5628 :
5629 : inline tree *
5630 258435 : gimple_omp_for_clauses_ptr (gimple *gs)
5631 : {
5632 258435 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5633 258435 : return &omp_for_stmt->clauses;
5634 : }
5635 :
5636 :
5637 : /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5638 : GS. */
5639 :
5640 : inline void
5641 68220 : gimple_omp_for_set_clauses (gimple *gs, tree clauses)
5642 : {
5643 68220 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5644 68220 : omp_for_stmt->clauses = clauses;
5645 : }
5646 :
5647 :
5648 : /* Get the collapse count of the OMP_FOR statement GS. */
5649 :
5650 : inline size_t
5651 788089 : gimple_omp_for_collapse (const gimple *gs)
5652 : {
5653 788089 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5654 788089 : return omp_for_stmt->collapse;
5655 : }
5656 :
5657 :
5658 : /* Return the condition code associated with the OMP_FOR statement GS. */
5659 :
5660 : inline enum tree_code
5661 200243 : gimple_omp_for_cond (const gimple *gs, size_t i)
5662 : {
5663 200243 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5664 200243 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5665 200243 : return omp_for_stmt->iter[i].cond;
5666 : }
5667 :
5668 :
5669 : /* Set COND to be the condition code for the OMP_FOR statement GS. */
5670 :
5671 : inline void
5672 76016 : gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
5673 : {
5674 76016 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5675 76016 : gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
5676 : && i < omp_for_stmt->collapse);
5677 76016 : omp_for_stmt->iter[i].cond = cond;
5678 76016 : }
5679 :
5680 :
5681 : /* Return the index variable for the OMP_FOR statement GS. */
5682 :
5683 : inline tree
5684 218140 : gimple_omp_for_index (const gimple *gs, size_t i)
5685 : {
5686 218140 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5687 218140 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5688 218140 : return omp_for_stmt->iter[i].index;
5689 : }
5690 :
5691 :
5692 : /* Return a pointer to the index variable for the OMP_FOR statement GS. */
5693 :
5694 : inline tree *
5695 356665 : gimple_omp_for_index_ptr (gimple *gs, size_t i)
5696 : {
5697 356665 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5698 356665 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5699 356665 : return &omp_for_stmt->iter[i].index;
5700 : }
5701 :
5702 :
5703 : /* Set INDEX to be the index variable for the OMP_FOR statement GS. */
5704 :
5705 : inline void
5706 76016 : gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
5707 : {
5708 76016 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5709 76016 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5710 76016 : omp_for_stmt->iter[i].index = index;
5711 76016 : }
5712 :
5713 :
5714 : /* Return the initial value for the OMP_FOR statement GS. */
5715 :
5716 : inline tree
5717 264889 : gimple_omp_for_initial (const gimple *gs, size_t i)
5718 : {
5719 264889 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5720 264889 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5721 264889 : return omp_for_stmt->iter[i].initial;
5722 : }
5723 :
5724 :
5725 : /* Return a pointer to the initial value for the OMP_FOR statement GS. */
5726 :
5727 : inline tree *
5728 425051 : gimple_omp_for_initial_ptr (gimple *gs, size_t i)
5729 : {
5730 425051 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5731 425051 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5732 425051 : return &omp_for_stmt->iter[i].initial;
5733 : }
5734 :
5735 :
5736 : /* Set INITIAL to be the initial value for the OMP_FOR statement GS. */
5737 :
5738 : inline void
5739 76016 : gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
5740 : {
5741 76016 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5742 76016 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5743 76016 : omp_for_stmt->iter[i].initial = initial;
5744 76016 : }
5745 :
5746 :
5747 : /* Return the final value for the OMP_FOR statement GS. */
5748 :
5749 : inline tree
5750 264707 : gimple_omp_for_final (const gimple *gs, size_t i)
5751 : {
5752 264707 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5753 264707 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5754 264707 : return omp_for_stmt->iter[i].final;
5755 : }
5756 :
5757 :
5758 : /* Return a pointer to the final value for the OMP_FOR statement GS. */
5759 :
5760 : inline tree *
5761 425051 : gimple_omp_for_final_ptr (gimple *gs, size_t i)
5762 : {
5763 425051 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5764 425051 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5765 425051 : return &omp_for_stmt->iter[i].final;
5766 : }
5767 :
5768 :
5769 : /* Set FINAL to be the final value for the OMP_FOR statement GS. */
5770 :
5771 : inline void
5772 76016 : gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
5773 : {
5774 76016 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5775 76016 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5776 76016 : omp_for_stmt->iter[i].final = final;
5777 76016 : }
5778 :
5779 :
5780 : /* Return the increment value for the OMP_FOR statement GS. */
5781 :
5782 : inline tree
5783 272937 : gimple_omp_for_incr (const gimple *gs, size_t i)
5784 : {
5785 272937 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5786 272937 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5787 272937 : return omp_for_stmt->iter[i].incr;
5788 : }
5789 :
5790 :
5791 : /* Return a pointer to the increment value for the OMP_FOR statement GS. */
5792 :
5793 : inline tree *
5794 352539 : gimple_omp_for_incr_ptr (gimple *gs, size_t i)
5795 : {
5796 352539 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5797 352539 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5798 352539 : return &omp_for_stmt->iter[i].incr;
5799 : }
5800 :
5801 :
5802 : /* Set INCR to be the increment value for the OMP_FOR statement GS. */
5803 :
5804 : inline void
5805 76016 : gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
5806 : {
5807 76016 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5808 76016 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5809 76016 : omp_for_stmt->iter[i].incr = incr;
5810 76016 : }
5811 :
5812 :
5813 : /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5814 : statement GS starts. */
5815 :
5816 : inline gimple_seq *
5817 310699 : gimple_omp_for_pre_body_ptr (gimple *gs)
5818 : {
5819 210502 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5820 210502 : return &omp_for_stmt->pre_body;
5821 : }
5822 :
5823 :
5824 : /* Return the sequence of statements to execute before the OMP_FOR
5825 : statement GS starts. */
5826 :
5827 : inline gimple_seq
5828 128941 : gimple_omp_for_pre_body (const gimple *gs)
5829 : {
5830 128941 : return *gimple_omp_for_pre_body_ptr (const_cast <gimple *> (gs));
5831 : }
5832 :
5833 :
5834 : /* Set PRE_BODY to be the sequence of statements to execute before the
5835 : OMP_FOR statement GS starts. */
5836 :
5837 : inline void
5838 52556 : gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
5839 : {
5840 52556 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5841 52556 : omp_for_stmt->pre_body = pre_body;
5842 : }
5843 :
5844 : /* Return the clauses associated with OMP_PARALLEL GS. */
5845 :
5846 : inline tree
5847 117636 : gimple_omp_parallel_clauses (const gimple *gs)
5848 : {
5849 117636 : const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
5850 117636 : return omp_parallel_stmt->clauses;
5851 : }
5852 :
5853 :
5854 : /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5855 :
5856 : inline tree *
5857 66578 : gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
5858 : {
5859 66578 : return &omp_parallel_stmt->clauses;
5860 : }
5861 :
5862 :
5863 : /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5864 :
5865 : inline void
5866 18726 : gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
5867 : tree clauses)
5868 : {
5869 69 : omp_parallel_stmt->clauses = clauses;
5870 : }
5871 :
5872 :
5873 : /* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5874 :
5875 : inline tree
5876 18742 : gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
5877 : {
5878 18742 : return omp_parallel_stmt->child_fn;
5879 : }
5880 :
5881 : /* Return a pointer to the child function used to hold the body of
5882 : OMP_PARALLEL_STMT. */
5883 :
5884 : inline tree *
5885 66578 : gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
5886 : {
5887 66578 : return &omp_parallel_stmt->child_fn;
5888 : }
5889 :
5890 :
5891 : /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5892 :
5893 : inline void
5894 37009 : gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
5895 : tree child_fn)
5896 : {
5897 18352 : omp_parallel_stmt->child_fn = child_fn;
5898 : }
5899 :
5900 :
5901 : /* Return the artificial argument used to send variables and values
5902 : from the parent to the children threads in OMP_PARALLEL_STMT. */
5903 :
5904 : inline tree
5905 16638 : gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
5906 : {
5907 16638 : return omp_parallel_stmt->data_arg;
5908 : }
5909 :
5910 :
5911 : /* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5912 :
5913 : inline tree *
5914 66578 : gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
5915 : {
5916 66578 : return &omp_parallel_stmt->data_arg;
5917 : }
5918 :
5919 :
5920 : /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5921 :
5922 : inline void
5923 18657 : gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
5924 : tree data_arg)
5925 : {
5926 0 : omp_parallel_stmt->data_arg = data_arg;
5927 : }
5928 :
5929 : /* Return the clauses associated with OMP_TASK GS. */
5930 :
5931 : inline tree
5932 28423 : gimple_omp_task_clauses (const gimple *gs)
5933 : {
5934 28423 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5935 28423 : return omp_task_stmt->clauses;
5936 : }
5937 :
5938 :
5939 : /* Return a pointer to the clauses associated with OMP_TASK GS. */
5940 :
5941 : inline tree *
5942 17190 : gimple_omp_task_clauses_ptr (gimple *gs)
5943 : {
5944 17190 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5945 17190 : return &omp_task_stmt->clauses;
5946 : }
5947 :
5948 :
5949 : /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5950 : GS. */
5951 :
5952 : inline void
5953 6230 : gimple_omp_task_set_clauses (gimple *gs, tree clauses)
5954 : {
5955 6230 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5956 6230 : omp_task_stmt->clauses = clauses;
5957 : }
5958 :
5959 :
5960 : /* Return true if OMP task statement G has the
5961 : GF_OMP_TASK_TASKLOOP flag set. */
5962 :
5963 : inline bool
5964 22399 : gimple_omp_task_taskloop_p (const gimple *g)
5965 : {
5966 22399 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5967 22399 : return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0;
5968 : }
5969 :
5970 :
5971 : /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5972 : value of TASKLOOP_P. */
5973 :
5974 : inline void
5975 1586 : gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
5976 : {
5977 1586 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5978 1586 : if (taskloop_p)
5979 1586 : g->subcode |= GF_OMP_TASK_TASKLOOP;
5980 : else
5981 0 : g->subcode &= ~GF_OMP_TASK_TASKLOOP;
5982 1586 : }
5983 :
5984 :
5985 : /* Return true if OMP task statement G has the
5986 : GF_OMP_TASK_TASKWAIT flag set. */
5987 :
5988 : inline bool
5989 25359 : gimple_omp_task_taskwait_p (const gimple *g)
5990 : {
5991 25359 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5992 25359 : return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKWAIT) != 0;
5993 : }
5994 :
5995 :
5996 : /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5997 : value of TASKWAIT_P. */
5998 :
5999 : inline void
6000 93 : gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
6001 : {
6002 93 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
6003 93 : if (taskwait_p)
6004 93 : g->subcode |= GF_OMP_TASK_TASKWAIT;
6005 : else
6006 0 : g->subcode &= ~GF_OMP_TASK_TASKWAIT;
6007 93 : }
6008 :
6009 :
6010 : /* Return the child function used to hold the body of OMP_TASK GS. */
6011 :
6012 : inline tree
6013 4203 : gimple_omp_task_child_fn (const gimple *gs)
6014 : {
6015 4203 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6016 4203 : return omp_task_stmt->child_fn;
6017 : }
6018 :
6019 : /* Return a pointer to the child function used to hold the body of
6020 : OMP_TASK GS. */
6021 :
6022 : inline tree *
6023 16001 : gimple_omp_task_child_fn_ptr (gimple *gs)
6024 : {
6025 16001 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6026 16001 : return &omp_task_stmt->child_fn;
6027 : }
6028 :
6029 :
6030 : /* Set CHILD_FN to be the child function for OMP_TASK GS. */
6031 :
6032 : inline void
6033 11250 : gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
6034 : {
6035 11250 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6036 11250 : omp_task_stmt->child_fn = child_fn;
6037 : }
6038 :
6039 :
6040 : /* Return the artificial argument used to send variables and values
6041 : from the parent to the children threads in OMP_TASK GS. */
6042 :
6043 : inline tree
6044 3855 : gimple_omp_task_data_arg (const gimple *gs)
6045 : {
6046 3855 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6047 3855 : return omp_task_stmt->data_arg;
6048 : }
6049 :
6050 :
6051 : /* Return a pointer to the data argument for OMP_TASK GS. */
6052 :
6053 : inline tree *
6054 16001 : gimple_omp_task_data_arg_ptr (gimple *gs)
6055 : {
6056 16001 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6057 16001 : return &omp_task_stmt->data_arg;
6058 : }
6059 :
6060 :
6061 : /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6062 :
6063 : inline void
6064 5713 : gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
6065 : {
6066 5713 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6067 5713 : omp_task_stmt->data_arg = data_arg;
6068 : }
6069 :
6070 :
6071 : /* Return the clauses associated with OMP_TASK GS. */
6072 :
6073 : inline tree
6074 59475 : gimple_omp_taskreg_clauses (const gimple *gs)
6075 : {
6076 59475 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6077 59475 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6078 59475 : return omp_taskreg_stmt->clauses;
6079 : }
6080 :
6081 :
6082 : /* Return a pointer to the clauses associated with OMP_TASK GS. */
6083 :
6084 : inline tree *
6085 2808 : gimple_omp_taskreg_clauses_ptr (gimple *gs)
6086 : {
6087 2808 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6088 2808 : = as_a <gimple_statement_omp_taskreg *> (gs);
6089 2808 : return &omp_taskreg_stmt->clauses;
6090 : }
6091 :
6092 :
6093 : /* Set CLAUSES to be the list of clauses associated with OMP_TASK
6094 : GS. */
6095 :
6096 : inline void
6097 19904 : gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
6098 : {
6099 19904 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6100 19904 : = as_a <gimple_statement_omp_taskreg *> (gs);
6101 19904 : omp_taskreg_stmt->clauses = clauses;
6102 : }
6103 :
6104 :
6105 : /* Return the child function used to hold the body of OMP_TASK GS. */
6106 :
6107 : inline tree
6108 29783 : gimple_omp_taskreg_child_fn (const gimple *gs)
6109 : {
6110 29783 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6111 29783 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6112 29783 : return omp_taskreg_stmt->child_fn;
6113 : }
6114 :
6115 : /* Return a pointer to the child function used to hold the body of
6116 : OMP_TASK GS. */
6117 :
6118 : inline tree *
6119 : gimple_omp_taskreg_child_fn_ptr (gimple *gs)
6120 : {
6121 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6122 : = as_a <gimple_statement_omp_taskreg *> (gs);
6123 : return &omp_taskreg_stmt->child_fn;
6124 : }
6125 :
6126 :
6127 : /* Set CHILD_FN to be the child function for OMP_TASK GS. */
6128 :
6129 : inline void
6130 : gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
6131 : {
6132 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6133 : = as_a <gimple_statement_omp_taskreg *> (gs);
6134 : omp_taskreg_stmt->child_fn = child_fn;
6135 : }
6136 :
6137 :
6138 : /* Return the artificial argument used to send variables and values
6139 : from the parent to the children threads in OMP_TASK GS. */
6140 :
6141 : inline tree
6142 41213 : gimple_omp_taskreg_data_arg (const gimple *gs)
6143 : {
6144 41213 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6145 18332 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6146 41213 : return omp_taskreg_stmt->data_arg;
6147 : }
6148 :
6149 :
6150 : /* Return a pointer to the data argument for OMP_TASK GS. */
6151 :
6152 : inline tree *
6153 : gimple_omp_taskreg_data_arg_ptr (gimple *gs)
6154 : {
6155 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6156 : = as_a <gimple_statement_omp_taskreg *> (gs);
6157 : return &omp_taskreg_stmt->data_arg;
6158 : }
6159 :
6160 :
6161 : /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6162 :
6163 : inline void
6164 18181 : gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
6165 : {
6166 18181 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6167 18181 : = as_a <gimple_statement_omp_taskreg *> (gs);
6168 18181 : omp_taskreg_stmt->data_arg = data_arg;
6169 : }
6170 :
6171 :
6172 : /* Return the copy function used to hold the body of OMP_TASK GS. */
6173 :
6174 : inline tree
6175 4868 : gimple_omp_task_copy_fn (const gimple *gs)
6176 : {
6177 4868 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6178 4868 : return omp_task_stmt->copy_fn;
6179 : }
6180 :
6181 : /* Return a pointer to the copy function used to hold the body of
6182 : OMP_TASK GS. */
6183 :
6184 : inline tree *
6185 16001 : gimple_omp_task_copy_fn_ptr (gimple *gs)
6186 : {
6187 16001 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6188 16001 : return &omp_task_stmt->copy_fn;
6189 : }
6190 :
6191 :
6192 : /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
6193 :
6194 : inline void
6195 6263 : gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
6196 : {
6197 6263 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6198 6263 : omp_task_stmt->copy_fn = copy_fn;
6199 : }
6200 :
6201 :
6202 : /* Return size of the data block in bytes in OMP_TASK GS. */
6203 :
6204 : inline tree
6205 3842 : gimple_omp_task_arg_size (const gimple *gs)
6206 : {
6207 3842 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6208 3842 : return omp_task_stmt->arg_size;
6209 : }
6210 :
6211 :
6212 : /* Return a pointer to the data block size for OMP_TASK GS. */
6213 :
6214 : inline tree *
6215 16001 : gimple_omp_task_arg_size_ptr (gimple *gs)
6216 : {
6217 16001 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6218 16001 : return &omp_task_stmt->arg_size;
6219 : }
6220 :
6221 :
6222 : /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
6223 :
6224 : inline void
6225 11250 : gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
6226 : {
6227 11250 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6228 11250 : omp_task_stmt->arg_size = arg_size;
6229 : }
6230 :
6231 :
6232 : /* Return align of the data block in bytes in OMP_TASK GS. */
6233 :
6234 : inline tree
6235 3842 : gimple_omp_task_arg_align (const gimple *gs)
6236 : {
6237 3842 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6238 3842 : return omp_task_stmt->arg_align;
6239 : }
6240 :
6241 :
6242 : /* Return a pointer to the data block align for OMP_TASK GS. */
6243 :
6244 : inline tree *
6245 16001 : gimple_omp_task_arg_align_ptr (gimple *gs)
6246 : {
6247 16001 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6248 16001 : return &omp_task_stmt->arg_align;
6249 : }
6250 :
6251 :
6252 : /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
6253 :
6254 : inline void
6255 11250 : gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
6256 : {
6257 11250 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6258 5537 : omp_task_stmt->arg_align = arg_align;
6259 : }
6260 :
6261 :
6262 : /* Return the clauses associated with OMP_SINGLE GS. */
6263 :
6264 : inline tree
6265 3679 : gimple_omp_single_clauses (const gimple *gs)
6266 : {
6267 3679 : const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
6268 3679 : return omp_single_stmt->clauses;
6269 : }
6270 :
6271 :
6272 : /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
6273 :
6274 : inline tree *
6275 5120 : gimple_omp_single_clauses_ptr (gimple *gs)
6276 : {
6277 5120 : gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
6278 5120 : return &omp_single_stmt->clauses;
6279 : }
6280 :
6281 :
6282 : /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
6283 :
6284 : inline void
6285 1299 : gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
6286 : {
6287 0 : omp_single_stmt->clauses = clauses;
6288 : }
6289 :
6290 :
6291 : /* Return the clauses associated with OMP_TARGET GS. */
6292 :
6293 : inline tree
6294 189486 : gimple_omp_target_clauses (const gimple *gs)
6295 : {
6296 189486 : const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
6297 189486 : return omp_target_stmt->clauses;
6298 : }
6299 :
6300 :
6301 : /* Return a pointer to the clauses associated with OMP_TARGET GS. */
6302 :
6303 : inline tree *
6304 168071 : gimple_omp_target_clauses_ptr (gimple *gs)
6305 : {
6306 168071 : gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
6307 168071 : return &omp_target_stmt->clauses;
6308 : }
6309 :
6310 :
6311 : /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
6312 :
6313 : inline void
6314 44044 : gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
6315 : tree clauses)
6316 : {
6317 779 : omp_target_stmt->clauses = clauses;
6318 : }
6319 :
6320 :
6321 : /* Return the kind of the OMP_TARGET G. */
6322 :
6323 : inline int
6324 1608843 : gimple_omp_target_kind (const gimple *g)
6325 : {
6326 1608843 : GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
6327 1608843 : return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
6328 : }
6329 :
6330 :
6331 : /* Set the kind of the OMP_TARGET G. */
6332 :
6333 : inline void
6334 43265 : gimple_omp_target_set_kind (gomp_target *g, int kind)
6335 : {
6336 43265 : g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
6337 43265 : | (kind & GF_OMP_TARGET_KIND_MASK);
6338 : }
6339 :
6340 :
6341 : /* Return the child function used to hold the body of OMP_TARGET_STMT. */
6342 :
6343 : inline tree
6344 28559 : gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
6345 : {
6346 28559 : return omp_target_stmt->child_fn;
6347 : }
6348 :
6349 : /* Return a pointer to the child function used to hold the body of
6350 : OMP_TARGET_STMT. */
6351 :
6352 : inline tree *
6353 151366 : gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
6354 : {
6355 151366 : return &omp_target_stmt->child_fn;
6356 : }
6357 :
6358 :
6359 : /* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
6360 :
6361 : inline void
6362 24963 : gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
6363 : tree child_fn)
6364 : {
6365 24963 : omp_target_stmt->child_fn = child_fn;
6366 : }
6367 :
6368 :
6369 : /* Return the artificial argument used to send variables and values
6370 : from the parent to the children threads in OMP_TARGET_STMT. */
6371 :
6372 : inline tree
6373 58757 : gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
6374 : {
6375 58757 : return omp_target_stmt->data_arg;
6376 : }
6377 :
6378 :
6379 : /* Return a pointer to the data argument for OMP_TARGET GS. */
6380 :
6381 : inline tree *
6382 151366 : gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
6383 : {
6384 151366 : return &omp_target_stmt->data_arg;
6385 : }
6386 :
6387 :
6388 : /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
6389 :
6390 : inline void
6391 32403 : gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
6392 : tree data_arg)
6393 : {
6394 32403 : omp_target_stmt->data_arg = data_arg;
6395 : }
6396 :
6397 :
6398 : /* Return the Gimple sequence used to store loops for OpenMP iterators used
6399 : by OMP_TARGET_STMT. */
6400 :
6401 : inline gimple_seq
6402 39885 : gimple_omp_target_iterator_loops (const gomp_target *omp_target_stmt)
6403 : {
6404 39885 : return omp_target_stmt->iterator_loops;
6405 : }
6406 :
6407 :
6408 : /* Return a pointer to the Gimple sequence used to store loops for OpenMP
6409 : iterators used by OMP_TARGET GS. */
6410 :
6411 : inline gimple_seq *
6412 6345 : gimple_omp_target_iterator_loops_ptr (gimple *gs)
6413 : {
6414 6345 : gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
6415 6345 : return &omp_target_stmt->iterator_loops;
6416 : }
6417 :
6418 :
6419 : /* Set ITERATOR_LOOPS to be the Gimple sequence used to store loops
6420 : constructed for OpenMP iterators in OMP_TARGET_STMT. */
6421 :
6422 : inline void
6423 80579 : gimple_omp_target_set_iterator_loops (gomp_target *omp_target_stmt,
6424 : gimple_seq iterator_loops)
6425 : {
6426 80579 : omp_target_stmt->iterator_loops = iterator_loops;
6427 : }
6428 :
6429 :
6430 : /* Return the clauses associated with OMP_TEAMS GS. */
6431 :
6432 : inline tree
6433 35753 : gimple_omp_teams_clauses (const gimple *gs)
6434 : {
6435 35753 : const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
6436 35753 : return omp_teams_stmt->clauses;
6437 : }
6438 :
6439 :
6440 : /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
6441 :
6442 : inline tree *
6443 34195 : gimple_omp_teams_clauses_ptr (gimple *gs)
6444 : {
6445 34195 : gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
6446 34195 : return &omp_teams_stmt->clauses;
6447 : }
6448 :
6449 :
6450 : /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
6451 :
6452 : inline void
6453 8935 : gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
6454 : {
6455 0 : omp_teams_stmt->clauses = clauses;
6456 : }
6457 :
6458 : /* Return the child function used to hold the body of OMP_TEAMS_STMT. */
6459 :
6460 : inline tree
6461 2577 : gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
6462 : {
6463 2577 : return omp_teams_stmt->child_fn;
6464 : }
6465 :
6466 : /* Return a pointer to the child function used to hold the body of
6467 : OMP_TEAMS_STMT. */
6468 :
6469 : inline tree *
6470 : gimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
6471 : {
6472 : return &omp_teams_stmt->child_fn;
6473 : }
6474 :
6475 :
6476 : /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT. */
6477 :
6478 : inline void
6479 2721 : gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
6480 : {
6481 2721 : omp_teams_stmt->child_fn = child_fn;
6482 : }
6483 :
6484 :
6485 : /* Return the artificial argument used to send variables and values
6486 : from the parent to the children threads in OMP_TEAMS_STMT. */
6487 :
6488 : inline tree
6489 2577 : gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
6490 : {
6491 2577 : return omp_teams_stmt->data_arg;
6492 : }
6493 :
6494 :
6495 : /* Return a pointer to the data argument for OMP_TEAMS_STMT. */
6496 :
6497 : inline tree *
6498 : gimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
6499 : {
6500 : return &omp_teams_stmt->data_arg;
6501 : }
6502 :
6503 :
6504 : /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT. */
6505 :
6506 : inline void
6507 : gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
6508 : {
6509 : omp_teams_stmt->data_arg = data_arg;
6510 : }
6511 :
6512 : /* Return the host flag of an OMP_TEAMS_STMT. */
6513 :
6514 : inline bool
6515 107080 : gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
6516 : {
6517 107080 : return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
6518 : }
6519 :
6520 : /* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6521 :
6522 : inline void
6523 2735 : gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
6524 : {
6525 2735 : if (value)
6526 2735 : omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
6527 : else
6528 : omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
6529 : }
6530 :
6531 : /* Return the clauses associated with OMP_SECTIONS GS. */
6532 :
6533 : inline tree
6534 3365 : gimple_omp_sections_clauses (const gimple *gs)
6535 : {
6536 2979 : const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6537 3365 : return omp_sections_stmt->clauses;
6538 : }
6539 :
6540 :
6541 : /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6542 :
6543 : inline tree *
6544 2056 : gimple_omp_sections_clauses_ptr (gimple *gs)
6545 : {
6546 2056 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6547 2056 : return &omp_sections_stmt->clauses;
6548 : }
6549 :
6550 :
6551 : /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6552 : GS. */
6553 :
6554 : inline void
6555 642 : gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
6556 : {
6557 642 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6558 8 : omp_sections_stmt->clauses = clauses;
6559 : }
6560 :
6561 :
6562 : /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6563 : in GS. */
6564 :
6565 : inline tree
6566 436 : gimple_omp_sections_control (const gimple *gs)
6567 : {
6568 436 : const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6569 436 : return omp_sections_stmt->control;
6570 : }
6571 :
6572 :
6573 : /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6574 : GS. */
6575 :
6576 : inline tree *
6577 1586 : gimple_omp_sections_control_ptr (gimple *gs)
6578 : {
6579 1586 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6580 1586 : return &omp_sections_stmt->control;
6581 : }
6582 :
6583 :
6584 : /* Set CONTROL to be the set of clauses associated with the
6585 : GIMPLE_OMP_SECTIONS in GS. */
6586 :
6587 : inline void
6588 386 : gimple_omp_sections_set_control (gimple *gs, tree control)
6589 : {
6590 386 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6591 386 : omp_sections_stmt->control = control;
6592 : }
6593 :
6594 :
6595 : /* Set the value being stored in an atomic store. */
6596 :
6597 : inline void
6598 10397 : gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
6599 : {
6600 10397 : store_stmt->val = val;
6601 : }
6602 :
6603 :
6604 : /* Return the value being stored in an atomic store. */
6605 :
6606 : inline tree
6607 10272 : gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
6608 : {
6609 10272 : return store_stmt->val;
6610 : }
6611 :
6612 :
6613 : /* Return a pointer to the value being stored in an atomic store. */
6614 :
6615 : inline tree *
6616 50553 : gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
6617 : {
6618 50553 : return &store_stmt->val;
6619 : }
6620 :
6621 :
6622 : /* Set the LHS of an atomic load. */
6623 :
6624 : inline void
6625 10397 : gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
6626 : {
6627 10397 : load_stmt->lhs = lhs;
6628 : }
6629 :
6630 :
6631 : /* Get the LHS of an atomic load. */
6632 :
6633 : inline tree
6634 10272 : gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
6635 : {
6636 10272 : return load_stmt->lhs;
6637 : }
6638 :
6639 :
6640 : /* Return a pointer to the LHS of an atomic load. */
6641 :
6642 : inline tree *
6643 49519 : gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
6644 : {
6645 49519 : return &load_stmt->lhs;
6646 : }
6647 :
6648 :
6649 : /* Set the RHS of an atomic load. */
6650 :
6651 : inline void
6652 10397 : gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
6653 : {
6654 10397 : load_stmt->rhs = rhs;
6655 : }
6656 :
6657 :
6658 : /* Get the RHS of an atomic load. */
6659 :
6660 : inline tree
6661 10272 : gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
6662 : {
6663 10272 : return load_stmt->rhs;
6664 : }
6665 :
6666 :
6667 : /* Return a pointer to the RHS of an atomic load. */
6668 :
6669 : inline tree *
6670 53437 : gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
6671 : {
6672 53437 : return &load_stmt->rhs;
6673 : }
6674 :
6675 :
6676 : /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6677 :
6678 : inline tree
6679 25321 : gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
6680 : {
6681 25321 : return cont_stmt->control_def;
6682 : }
6683 :
6684 : /* The same as above, but return the address. */
6685 :
6686 : inline tree *
6687 197758 : gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
6688 : {
6689 197758 : return &cont_stmt->control_def;
6690 : }
6691 :
6692 : /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6693 :
6694 : inline void
6695 52123 : gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
6696 : {
6697 52123 : cont_stmt->control_def = def;
6698 : }
6699 :
6700 :
6701 : /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6702 :
6703 : inline tree
6704 25321 : gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
6705 : {
6706 25321 : return cont_stmt->control_use;
6707 : }
6708 :
6709 :
6710 : /* The same as above, but return the address. */
6711 :
6712 : inline tree *
6713 197758 : gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
6714 : {
6715 197758 : return &cont_stmt->control_use;
6716 : }
6717 :
6718 :
6719 : /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6720 :
6721 : inline void
6722 52123 : gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
6723 : {
6724 52123 : cont_stmt->control_use = use;
6725 : }
6726 :
6727 : /* Return the guard associated with the GIMPLE_ASSUME statement GS. */
6728 :
6729 : inline tree
6730 168 : gimple_assume_guard (const gimple *gs)
6731 : {
6732 168 : const gimple_statement_assume *assume_stmt
6733 168 : = as_a <const gimple_statement_assume *> (gs);
6734 168 : return assume_stmt->guard;
6735 : }
6736 :
6737 : /* Set the guard associated with the GIMPLE_ASSUME statement GS. */
6738 :
6739 : inline void
6740 168 : gimple_assume_set_guard (gimple *gs, tree guard)
6741 : {
6742 168 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6743 168 : assume_stmt->guard = guard;
6744 : }
6745 :
6746 : inline tree *
6747 14 : gimple_assume_guard_ptr (gimple *gs)
6748 : {
6749 14 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6750 14 : return &assume_stmt->guard;
6751 : }
6752 :
6753 : /* Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
6754 : statement GS. */
6755 :
6756 : inline gimple_seq *
6757 371 : gimple_assume_body_ptr (gimple *gs)
6758 : {
6759 371 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6760 203 : return &assume_stmt->body;
6761 : }
6762 :
6763 : /* Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS. */
6764 :
6765 : inline gimple_seq
6766 678 : gimple_assume_body (const gimple *gs)
6767 : {
6768 678 : const gimple_statement_assume *assume_stmt
6769 678 : = as_a <const gimple_statement_assume *> (gs);
6770 678 : return assume_stmt->body;
6771 : }
6772 :
6773 : /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6774 : TRANSACTION_STMT. */
6775 :
6776 : inline gimple_seq *
6777 1759 : gimple_transaction_body_ptr (gtransaction *transaction_stmt)
6778 : {
6779 1759 : return &transaction_stmt->body;
6780 : }
6781 :
6782 : /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6783 :
6784 : inline gimple_seq
6785 35363 : gimple_transaction_body (const gtransaction *transaction_stmt)
6786 : {
6787 35363 : return transaction_stmt->body;
6788 : }
6789 :
6790 : /* Return the label associated with a GIMPLE_TRANSACTION. */
6791 :
6792 : inline tree
6793 35644 : gimple_transaction_label_norm (const gtransaction *transaction_stmt)
6794 : {
6795 35644 : return transaction_stmt->label_norm;
6796 : }
6797 :
6798 : inline tree *
6799 62310 : gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
6800 : {
6801 62310 : return &transaction_stmt->label_norm;
6802 : }
6803 :
6804 : inline tree
6805 35644 : gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
6806 : {
6807 35644 : return transaction_stmt->label_uninst;
6808 : }
6809 :
6810 : inline tree *
6811 62310 : gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
6812 : {
6813 62310 : return &transaction_stmt->label_uninst;
6814 : }
6815 :
6816 : inline tree
6817 35644 : gimple_transaction_label_over (const gtransaction *transaction_stmt)
6818 : {
6819 35644 : return transaction_stmt->label_over;
6820 : }
6821 :
6822 : inline tree *
6823 62310 : gimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
6824 : {
6825 62310 : return &transaction_stmt->label_over;
6826 : }
6827 :
6828 : /* Return the subcode associated with a GIMPLE_TRANSACTION. */
6829 :
6830 : inline unsigned int
6831 3929 : gimple_transaction_subcode (const gtransaction *transaction_stmt)
6832 : {
6833 3921 : return transaction_stmt->subcode;
6834 : }
6835 :
6836 : /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6837 : TRANSACTION_STMT. */
6838 :
6839 : inline void
6840 1025 : gimple_transaction_set_body (gtransaction *transaction_stmt,
6841 : gimple_seq body)
6842 : {
6843 480 : transaction_stmt->body = body;
6844 : }
6845 :
6846 : /* Set the label associated with a GIMPLE_TRANSACTION. */
6847 :
6848 : inline void
6849 1151 : gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
6850 : {
6851 1151 : transaction_stmt->label_norm = label;
6852 : }
6853 :
6854 : inline void
6855 1132 : gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
6856 : {
6857 1132 : transaction_stmt->label_uninst = label;
6858 : }
6859 :
6860 : inline void
6861 1102 : gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
6862 : {
6863 1102 : transaction_stmt->label_over = label;
6864 : }
6865 :
6866 : /* Set the subcode associated with a GIMPLE_TRANSACTION. */
6867 :
6868 : inline void
6869 1974 : gimple_transaction_set_subcode (gtransaction *transaction_stmt,
6870 : unsigned int subcode)
6871 : {
6872 1974 : transaction_stmt->subcode = subcode;
6873 : }
6874 :
6875 : /* Return a pointer to the return value for GIMPLE_RETURN GS. */
6876 :
6877 : inline tree *
6878 611474 : gimple_return_retval_ptr (greturn *gs)
6879 : {
6880 611474 : return &gs->op[0];
6881 : }
6882 :
6883 : /* Return the return value for GIMPLE_RETURN GS. */
6884 :
6885 : inline tree
6886 376234134 : gimple_return_retval (const greturn *gs)
6887 : {
6888 376234134 : return gs->op[0];
6889 : }
6890 :
6891 :
6892 : /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6893 :
6894 : inline void
6895 2248238 : gimple_return_set_retval (greturn *gs, tree retval)
6896 : {
6897 2248238 : gs->op[0] = retval;
6898 : }
6899 :
6900 :
6901 : /* Returns true when the gimple statement STMT is any of the OMP types. */
6902 :
6903 : #define CASE_GIMPLE_OMP \
6904 : case GIMPLE_OMP_PARALLEL: \
6905 : case GIMPLE_OMP_TASK: \
6906 : case GIMPLE_OMP_FOR: \
6907 : case GIMPLE_OMP_SECTIONS: \
6908 : case GIMPLE_OMP_SECTIONS_SWITCH: \
6909 : case GIMPLE_OMP_SINGLE: \
6910 : case GIMPLE_OMP_TARGET: \
6911 : case GIMPLE_OMP_TEAMS: \
6912 : case GIMPLE_OMP_SCOPE: \
6913 : case GIMPLE_OMP_DISPATCH: \
6914 : case GIMPLE_OMP_INTEROP: \
6915 : case GIMPLE_OMP_SECTION: \
6916 : case GIMPLE_OMP_STRUCTURED_BLOCK: \
6917 : case GIMPLE_OMP_MASTER: \
6918 : case GIMPLE_OMP_MASKED: \
6919 : case GIMPLE_OMP_TASKGROUP: \
6920 : case GIMPLE_OMP_ORDERED: \
6921 : case GIMPLE_OMP_CRITICAL: \
6922 : case GIMPLE_OMP_SCAN: \
6923 : case GIMPLE_OMP_RETURN: \
6924 : case GIMPLE_OMP_ATOMIC_LOAD: \
6925 : case GIMPLE_OMP_ATOMIC_STORE: \
6926 : case GIMPLE_OMP_CONTINUE
6927 :
6928 : inline bool
6929 9021282 : is_gimple_omp (const gimple *stmt)
6930 : {
6931 7600043 : switch (gimple_code (stmt))
6932 : {
6933 : CASE_GIMPLE_OMP:
6934 : return true;
6935 3303870 : default:
6936 3303870 : return false;
6937 : }
6938 : }
6939 :
6940 : /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6941 : specifically. */
6942 :
6943 : inline bool
6944 1131826 : is_gimple_omp_oacc (const gimple *stmt)
6945 : {
6946 1131826 : gcc_assert (is_gimple_omp (stmt));
6947 1131826 : switch (gimple_code (stmt))
6948 : {
6949 0 : case GIMPLE_OMP_ATOMIC_LOAD:
6950 0 : case GIMPLE_OMP_ATOMIC_STORE:
6951 0 : case GIMPLE_OMP_CONTINUE:
6952 0 : case GIMPLE_OMP_RETURN:
6953 : /* Codes shared between OpenACC and OpenMP cannot be used to disambiguate
6954 : the two. */
6955 0 : gcc_unreachable ();
6956 :
6957 400464 : case GIMPLE_OMP_FOR:
6958 400464 : switch (gimple_omp_for_kind (stmt))
6959 : {
6960 : case GF_OMP_FOR_KIND_OACC_LOOP:
6961 : return true;
6962 : default:
6963 : return false;
6964 : }
6965 490339 : case GIMPLE_OMP_TARGET:
6966 490339 : switch (gimple_omp_target_kind (stmt))
6967 : {
6968 : case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6969 : case GF_OMP_TARGET_KIND_OACC_KERNELS:
6970 : case GF_OMP_TARGET_KIND_OACC_SERIAL:
6971 : case GF_OMP_TARGET_KIND_OACC_DATA:
6972 : case GF_OMP_TARGET_KIND_OACC_UPDATE:
6973 : case GF_OMP_TARGET_KIND_OACC_ENTER_DATA:
6974 : case GF_OMP_TARGET_KIND_OACC_EXIT_DATA:
6975 : case GF_OMP_TARGET_KIND_OACC_DECLARE:
6976 : case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
6977 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
6978 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
6979 : case GF_OMP_TARGET_KIND_OACC_DATA_KERNELS:
6980 : return true;
6981 : default:
6982 : return false;
6983 : }
6984 : default:
6985 : return false;
6986 : }
6987 : }
6988 :
6989 :
6990 : /* Return true if the OMP gimple statement STMT is offloaded. */
6991 :
6992 : inline bool
6993 708652 : is_gimple_omp_offloaded (const gimple *stmt)
6994 : {
6995 708652 : gcc_assert (is_gimple_omp (stmt));
6996 708652 : switch (gimple_code (stmt))
6997 : {
6998 508073 : case GIMPLE_OMP_TARGET:
6999 508073 : switch (gimple_omp_target_kind (stmt))
7000 : {
7001 : case GF_OMP_TARGET_KIND_REGION:
7002 : case GF_OMP_TARGET_KIND_OACC_PARALLEL:
7003 : case GF_OMP_TARGET_KIND_OACC_KERNELS:
7004 : case GF_OMP_TARGET_KIND_OACC_SERIAL:
7005 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
7006 : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
7007 : return true;
7008 : default:
7009 : return false;
7010 : }
7011 : default:
7012 : return false;
7013 : }
7014 : }
7015 :
7016 :
7017 : /* Returns TRUE if statement G is a GIMPLE_NOP. */
7018 :
7019 : inline bool
7020 25919754331 : gimple_nop_p (const gimple *g)
7021 : {
7022 26288262134 : return gimple_code (g) == GIMPLE_NOP;
7023 : }
7024 :
7025 :
7026 : /* Return true if GS is a GIMPLE_RESX. */
7027 :
7028 : inline bool
7029 2576312 : is_gimple_resx (const gimple *gs)
7030 : {
7031 2576312 : return gimple_code (gs) == GIMPLE_RESX;
7032 : }
7033 :
7034 :
7035 : /* Enum and arrays used for allocation stats. Keep in sync with
7036 : gimple.cc:gimple_alloc_kind_names. */
7037 : enum gimple_alloc_kind
7038 : {
7039 : gimple_alloc_kind_assign, /* Assignments. */
7040 : gimple_alloc_kind_phi, /* PHI nodes. */
7041 : gimple_alloc_kind_cond, /* Conditionals. */
7042 : gimple_alloc_kind_rest, /* Everything else. */
7043 : gimple_alloc_kind_all
7044 : };
7045 :
7046 : extern uint64_t gimple_alloc_counts[];
7047 : extern uint64_t gimple_alloc_sizes[];
7048 :
7049 : /* Return the allocation kind for a given stmt CODE. */
7050 : inline enum gimple_alloc_kind
7051 : gimple_alloc_kind (enum gimple_code code)
7052 : {
7053 : switch (code)
7054 : {
7055 : case GIMPLE_ASSIGN:
7056 : return gimple_alloc_kind_assign;
7057 : case GIMPLE_PHI:
7058 : return gimple_alloc_kind_phi;
7059 : case GIMPLE_COND:
7060 : return gimple_alloc_kind_cond;
7061 : default:
7062 : return gimple_alloc_kind_rest;
7063 : }
7064 : }
7065 :
7066 : /* Return true if a location should not be emitted for this statement
7067 : by annotate_all_with_location. */
7068 :
7069 : inline bool
7070 338021704 : gimple_do_not_emit_location_p (gimple *g)
7071 : {
7072 338021704 : return gimple_plf (g, GF_PLF_1);
7073 : }
7074 :
7075 : /* Mark statement G so a location will not be emitted by
7076 : annotate_one_with_location. */
7077 :
7078 : inline void
7079 1960119 : gimple_set_do_not_emit_location (gimple *g)
7080 : {
7081 : /* The PLF flags are initialized to 0 when a new tuple is created,
7082 : so no need to initialize it anywhere. */
7083 1960119 : gimple_set_plf (g, GF_PLF_1, true);
7084 : }
7085 :
7086 : #endif /* GCC_GIMPLE_H */
|