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