Branch data Line data Source code
1 : : /* Gimple IR definitions.
2 : :
3 : : Copyright (C) 2007-2025 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 : >10913*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 : >10913*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 : >10913*10^7 : return ret;
73 : : }
74 : : template <typename T>
75 : : inline T
76 : 7105580267 : 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 : 7105580267 : 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 : 7105580267 : 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 : : /* Padding to get subcode to 16 bit alignment. */
254 : : unsigned pad : 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_PARALLEL_LAYOUT")))
686 : : gomp_target : public gimple_statement_omp_parallel_layout
687 : : {
688 : : /* No extra fields; adds invariant:
689 : : stmt->code == GIMPLE_OMP_TARGET. */
690 : : };
691 : :
692 : : /* GIMPLE_OMP_TASK */
693 : :
694 : : struct GTY((tag("GSS_OMP_TASK")))
695 : : gomp_task : public gimple_statement_omp_taskreg
696 : : {
697 : : /* [ WORD 1-10 ] : base class */
698 : :
699 : : /* [ WORD 11 ]
700 : : Child function holding firstprivate initialization if needed. */
701 : : tree copy_fn;
702 : :
703 : : /* [ WORD 12-13 ]
704 : : Size and alignment in bytes of the argument data block. */
705 : : tree arg_size;
706 : : tree arg_align;
707 : : };
708 : :
709 : :
710 : : /* GIMPLE_OMP_SECTION */
711 : : /* Uses struct gimple_statement_omp. */
712 : :
713 : :
714 : : /* GIMPLE_OMP_SECTIONS */
715 : :
716 : : struct GTY((tag("GSS_OMP_SECTIONS")))
717 : : gomp_sections : public gimple_statement_omp
718 : : {
719 : : /* [ WORD 1-7 ] : base class */
720 : :
721 : : /* [ WORD 8 ] */
722 : : tree clauses;
723 : :
724 : : /* [ WORD 9 ]
725 : : The control variable used for deciding which of the sections to
726 : : execute. */
727 : : tree control;
728 : : };
729 : :
730 : : /* GIMPLE_OMP_CONTINUE.
731 : :
732 : : Note: This does not inherit from gimple_statement_omp, because we
733 : : do not need the body field. */
734 : :
735 : : struct GTY((tag("GSS_OMP_CONTINUE")))
736 : : gomp_continue : public gimple
737 : : {
738 : : /* [ WORD 1-6 ] : base class */
739 : :
740 : : /* [ WORD 7 ] */
741 : : tree control_def;
742 : :
743 : : /* [ WORD 8 ] */
744 : : tree control_use;
745 : : };
746 : :
747 : : /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
748 : : GIMPLE_OMP_SCAN, GIMPLE_OMP_MASKED, GIMPLE_OMP_SCOPE, GIMPLE_OMP_DISPATCH,
749 : : GIMPLE_OMP_INTEROP. */
750 : :
751 : : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
752 : : gimple_statement_omp_single_layout : public gimple_statement_omp
753 : : {
754 : : /* [ WORD 1-7 ] : base class */
755 : :
756 : : /* [ WORD 8 ] */
757 : : tree clauses;
758 : : };
759 : :
760 : : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
761 : : gomp_single : public gimple_statement_omp_single_layout
762 : : {
763 : : /* No extra fields; adds invariant:
764 : : stmt->code == GIMPLE_OMP_SINGLE. */
765 : : };
766 : :
767 : : struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
768 : : gomp_teams : public gimple_statement_omp_taskreg
769 : : {
770 : : /* No extra fields; adds invariant:
771 : : stmt->code == GIMPLE_OMP_TEAMS. */
772 : : };
773 : :
774 : : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
775 : : gomp_ordered : public gimple_statement_omp_single_layout
776 : : {
777 : : /* No extra fields; adds invariant:
778 : : stmt->code == GIMPLE_OMP_ORDERED. */
779 : : };
780 : :
781 : : struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
782 : : gomp_scan : public gimple_statement_omp_single_layout
783 : : {
784 : : /* No extra fields; adds invariant:
785 : : stmt->code == GIMPLE_OMP_SCAN. */
786 : : };
787 : :
788 : :
789 : : /* GIMPLE_OMP_ATOMIC_LOAD.
790 : : Note: This is based on gimple, not g_s_omp, because g_s_omp
791 : : contains a sequence, which we don't need here. */
792 : :
793 : : struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
794 : : gomp_atomic_load : public gimple
795 : : {
796 : : /* [ WORD 1-6 ] : base class */
797 : :
798 : : /* [ WORD 7-8 ] */
799 : : tree rhs, lhs;
800 : : };
801 : :
802 : : /* GIMPLE_OMP_ATOMIC_STORE.
803 : : See note on GIMPLE_OMP_ATOMIC_LOAD. */
804 : :
805 : : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
806 : : gimple_statement_omp_atomic_store_layout : public gimple
807 : : {
808 : : /* [ WORD 1-6 ] : base class */
809 : :
810 : : /* [ WORD 7 ] */
811 : : tree val;
812 : : };
813 : :
814 : : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
815 : : gomp_atomic_store :
816 : : public gimple_statement_omp_atomic_store_layout
817 : : {
818 : : /* No extra fields; adds invariant:
819 : : stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
820 : : };
821 : :
822 : : struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
823 : : gimple_statement_omp_return :
824 : : public gimple_statement_omp_atomic_store_layout
825 : : {
826 : : /* No extra fields; adds invariant:
827 : : stmt->code == GIMPLE_OMP_RETURN. */
828 : : };
829 : :
830 : : /* Assumptions. */
831 : :
832 : : struct GTY((tag("GSS_ASSUME")))
833 : : gimple_statement_assume : public gimple
834 : : {
835 : : /* [ WORD 1-6 ] : base class */
836 : :
837 : : /* [ WORD 7 ] */
838 : : tree guard;
839 : :
840 : : /* [ WORD 8 ] */
841 : : gimple_seq body;
842 : : };
843 : :
844 : : /* GIMPLE_TRANSACTION. */
845 : :
846 : : /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
847 : :
848 : : /* The __transaction_atomic was declared [[outer]] or it is
849 : : __transaction_relaxed. */
850 : : #define GTMA_IS_OUTER (1u << 0)
851 : : #define GTMA_IS_RELAXED (1u << 1)
852 : : #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
853 : :
854 : : /* The transaction is seen to not have an abort. */
855 : : #define GTMA_HAVE_ABORT (1u << 2)
856 : : /* The transaction is seen to have loads or stores. */
857 : : #define GTMA_HAVE_LOAD (1u << 3)
858 : : #define GTMA_HAVE_STORE (1u << 4)
859 : : /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
860 : : #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
861 : : /* The transaction WILL enter serial irrevocable mode.
862 : : An irrevocable block post-dominates the entire transaction, such
863 : : that all invocations of the transaction will go serial-irrevocable.
864 : : In such case, we don't bother instrumenting the transaction, and
865 : : tell the runtime that it should begin the transaction in
866 : : serial-irrevocable mode. */
867 : : #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
868 : : /* The transaction contains no instrumentation code whatsover, most
869 : : likely because it is guaranteed to go irrevocable upon entry. */
870 : : #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
871 : :
872 : : struct GTY((tag("GSS_TRANSACTION")))
873 : : gtransaction : public gimple_statement_with_memory_ops_base
874 : : {
875 : : /* [ WORD 1-9 ] : base class */
876 : :
877 : : /* [ WORD 10 ] */
878 : : gimple_seq body;
879 : :
880 : : /* [ WORD 11-13 ] */
881 : : tree label_norm;
882 : : tree label_uninst;
883 : : tree label_over;
884 : : };
885 : :
886 : : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
887 : : enum gimple_statement_structure_enum {
888 : : #include "gsstruct.def"
889 : : LAST_GSS_ENUM
890 : : };
891 : : #undef DEFGSSTRUCT
892 : :
893 : : /* A statement with the invariant that
894 : : stmt->code == GIMPLE_COND
895 : : i.e. a conditional jump statement. */
896 : :
897 : : struct GTY((tag("GSS_WITH_OPS")))
898 : : gcond : public gimple_statement_with_ops
899 : : {
900 : : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
901 : : static const enum gimple_code code_ = GIMPLE_COND;
902 : : };
903 : :
904 : : /* A statement with the invariant that
905 : : stmt->code == GIMPLE_DEBUG
906 : : i.e. a debug statement. */
907 : :
908 : : struct GTY((tag("GSS_WITH_OPS")))
909 : : gdebug : public gimple_statement_with_ops
910 : : {
911 : : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
912 : : };
913 : :
914 : : /* A statement with the invariant that
915 : : stmt->code == GIMPLE_GOTO
916 : : i.e. a goto statement. */
917 : :
918 : : struct GTY((tag("GSS_WITH_OPS")))
919 : : ggoto : public gimple_statement_with_ops
920 : : {
921 : : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
922 : : };
923 : :
924 : : /* A statement with the invariant that
925 : : stmt->code == GIMPLE_LABEL
926 : : i.e. a label statement. */
927 : :
928 : : struct GTY((tag("GSS_WITH_OPS")))
929 : : glabel : public gimple_statement_with_ops
930 : : {
931 : : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
932 : : };
933 : :
934 : : /* A statement with the invariant that
935 : : stmt->code == GIMPLE_SWITCH
936 : : i.e. a switch statement. */
937 : :
938 : : struct GTY((tag("GSS_WITH_OPS")))
939 : : gswitch : public gimple_statement_with_ops
940 : : {
941 : : /* no additional fields; this uses the layout for GSS_WITH_OPS. */
942 : : };
943 : :
944 : : /* A statement with the invariant that
945 : : stmt->code == GIMPLE_ASSIGN
946 : : i.e. an assignment statement. */
947 : :
948 : : struct GTY((tag("GSS_WITH_MEM_OPS")))
949 : : gassign : public gimple_statement_with_memory_ops
950 : : {
951 : : static const enum gimple_code code_ = GIMPLE_ASSIGN;
952 : : /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
953 : : };
954 : :
955 : : /* A statement with the invariant that
956 : : stmt->code == GIMPLE_RETURN
957 : : i.e. a return statement. */
958 : :
959 : : struct GTY((tag("GSS_WITH_MEM_OPS")))
960 : : greturn : public gimple_statement_with_memory_ops
961 : : {
962 : : /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
963 : : };
964 : :
965 : : template <>
966 : : template <>
967 : : inline bool
968 : 90625871 : is_a_helper <gasm *>::test (gimple *gs)
969 : : {
970 : 90625871 : return gs->code == GIMPLE_ASM;
971 : : }
972 : :
973 : : template <>
974 : : template <>
975 : : inline bool
976 : 12874167001 : is_a_helper <gassign *>::test (gimple *gs)
977 : : {
978 : 12874064040 : return gs->code == GIMPLE_ASSIGN;
979 : : }
980 : :
981 : : template <>
982 : : template <>
983 : : inline bool
984 : 74720005921 : is_a_helper <const gassign *>::test (const gimple *gs)
985 : : {
986 : 74720005921 : return gs->code == GIMPLE_ASSIGN;
987 : : }
988 : :
989 : : template <>
990 : : template <>
991 : : inline bool
992 : 42868855 : is_a_helper <gbind *>::test (gimple *gs)
993 : : {
994 : 42868855 : return gs->code == GIMPLE_BIND;
995 : : }
996 : :
997 : : template <>
998 : : template <>
999 : : inline bool
1000 : 16933060404 : is_a_helper <gcall *>::test (gimple *gs)
1001 : : {
1002 : 16933060404 : return gs->code == GIMPLE_CALL;
1003 : : }
1004 : :
1005 : : template <>
1006 : : template <>
1007 : : inline bool
1008 : 509061 : is_a_helper <gcatch *>::test (gimple *gs)
1009 : : {
1010 : 509061 : return gs->code == GIMPLE_CATCH;
1011 : : }
1012 : :
1013 : : template <>
1014 : : template <>
1015 : : inline bool
1016 : 2683395432 : is_a_helper <gcond *>::test (gimple *gs)
1017 : : {
1018 : 2683395432 : return gs->code == GIMPLE_COND;
1019 : : }
1020 : :
1021 : : template <>
1022 : : template <>
1023 : : inline bool
1024 : 1984910623 : is_a_helper <const gcond *>::test (const gimple *gs)
1025 : : {
1026 : 1984910623 : return gs->code == GIMPLE_COND;
1027 : : }
1028 : :
1029 : : template <>
1030 : : template <>
1031 : : inline bool
1032 : 76590906 : is_a_helper <gdebug *>::test (gimple *gs)
1033 : : {
1034 : 76590906 : return gs->code == GIMPLE_DEBUG;
1035 : : }
1036 : :
1037 : : template <>
1038 : : template <>
1039 : : inline bool
1040 : 34267 : is_a_helper <const gdebug *>::test (const gimple *gs)
1041 : : {
1042 : 34267 : return gs->code == GIMPLE_DEBUG;
1043 : : }
1044 : :
1045 : : template <>
1046 : : template <>
1047 : : inline bool
1048 : 36202051 : is_a_helper <ggoto *>::test (gimple *gs)
1049 : : {
1050 : 36202051 : return gs->code == GIMPLE_GOTO;
1051 : : }
1052 : :
1053 : : template <>
1054 : : template <>
1055 : : inline bool
1056 : 3658 : is_a_helper <const ggoto *>::test (const gimple *gs)
1057 : : {
1058 : 3658 : return gs->code == GIMPLE_GOTO;
1059 : : }
1060 : :
1061 : : template <>
1062 : : template <>
1063 : : inline bool
1064 : 14298231178 : is_a_helper <glabel *>::test (gimple *gs)
1065 : : {
1066 : 14298231178 : return gs->code == GIMPLE_LABEL;
1067 : : }
1068 : :
1069 : : template <>
1070 : : template <>
1071 : : inline bool
1072 : 34676 : is_a_helper <const glabel *>::test (const gimple *gs)
1073 : : {
1074 : 34676 : return gs->code == GIMPLE_LABEL;
1075 : : }
1076 : :
1077 : : template <>
1078 : : template <>
1079 : : inline bool
1080 : 9454348 : is_a_helper <gresx *>::test (gimple *gs)
1081 : : {
1082 : 9454348 : return gs->code == GIMPLE_RESX;
1083 : : }
1084 : :
1085 : : template <>
1086 : : template <>
1087 : : inline bool
1088 : 2065259 : is_a_helper <geh_dispatch *>::test (gimple *gs)
1089 : : {
1090 : 2065259 : return gs->code == GIMPLE_EH_DISPATCH;
1091 : : }
1092 : :
1093 : : template <>
1094 : : template <>
1095 : : inline bool
1096 : 8155 : is_a_helper <geh_else *>::test (gimple *gs)
1097 : : {
1098 : 8155 : return gs->code == GIMPLE_EH_ELSE;
1099 : : }
1100 : :
1101 : : template <>
1102 : : template <>
1103 : : inline bool
1104 : 0 : is_a_helper <const geh_else *>::test (const gimple *gs)
1105 : : {
1106 : 0 : return gs->code == GIMPLE_EH_ELSE;
1107 : : }
1108 : :
1109 : : template <>
1110 : : template <>
1111 : : inline bool
1112 : 43541 : is_a_helper <geh_filter *>::test (gimple *gs)
1113 : : {
1114 : 43541 : return gs->code == GIMPLE_EH_FILTER;
1115 : : }
1116 : :
1117 : : template <>
1118 : : template <>
1119 : : inline bool
1120 : 2517108 : is_a_helper <geh_mnt *>::test (gimple *gs)
1121 : : {
1122 : 2517108 : return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1123 : : }
1124 : :
1125 : : template <>
1126 : : template <>
1127 : : inline bool
1128 : 730 : is_a_helper <const geh_mnt *>::test (const gimple *gs)
1129 : : {
1130 : 730 : return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1131 : : }
1132 : :
1133 : : template <>
1134 : : template <>
1135 : : inline bool
1136 : 72043 : is_a_helper <gomp_atomic_load *>::test (gimple *gs)
1137 : : {
1138 : 72043 : return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1139 : : }
1140 : :
1141 : : template <>
1142 : : template <>
1143 : : inline bool
1144 : 69193 : is_a_helper <gomp_atomic_store *>::test (gimple *gs)
1145 : : {
1146 : 69193 : return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1147 : : }
1148 : :
1149 : : template <>
1150 : : template <>
1151 : : inline bool
1152 : 399512 : is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
1153 : : {
1154 : 399512 : return gs->code == GIMPLE_OMP_RETURN;
1155 : : }
1156 : :
1157 : : template <>
1158 : : template <>
1159 : : inline bool
1160 : 284112 : is_a_helper <gomp_continue *>::test (gimple *gs)
1161 : : {
1162 : 284112 : return gs->code == GIMPLE_OMP_CONTINUE;
1163 : : }
1164 : :
1165 : : template <>
1166 : : template <>
1167 : : inline bool
1168 : 3103 : is_a_helper <gomp_critical *>::test (gimple *gs)
1169 : : {
1170 : 3103 : return gs->code == GIMPLE_OMP_CRITICAL;
1171 : : }
1172 : :
1173 : : template <>
1174 : : template <>
1175 : : inline bool
1176 : 12856 : is_a_helper <gomp_ordered *>::test (gimple *gs)
1177 : : {
1178 : 12856 : return gs->code == GIMPLE_OMP_ORDERED;
1179 : : }
1180 : :
1181 : : template <>
1182 : : template <>
1183 : : inline bool
1184 : 5279 : is_a_helper <gomp_scan *>::test (gimple *gs)
1185 : : {
1186 : 5279 : return gs->code == GIMPLE_OMP_SCAN;
1187 : : }
1188 : :
1189 : : template <>
1190 : : template <>
1191 : : inline bool
1192 : 2941866 : is_a_helper <gomp_for *>::test (gimple *gs)
1193 : : {
1194 : 2941866 : return gs->code == GIMPLE_OMP_FOR;
1195 : : }
1196 : :
1197 : : template <>
1198 : : template <>
1199 : : inline bool
1200 : 40593 : is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
1201 : : {
1202 : 40593 : return (gs->code == GIMPLE_OMP_PARALLEL
1203 : : || gs->code == GIMPLE_OMP_TASK
1204 : 40593 : || gs->code == GIMPLE_OMP_TEAMS);
1205 : : }
1206 : :
1207 : : template <>
1208 : : template <>
1209 : : inline bool
1210 : 61959852 : is_a_helper <gomp_parallel *>::test (gimple *gs)
1211 : : {
1212 : 61959852 : return gs->code == GIMPLE_OMP_PARALLEL;
1213 : : }
1214 : :
1215 : : template <>
1216 : : template <>
1217 : : inline bool
1218 : 464136 : is_a_helper <gomp_target *>::test (gimple *gs)
1219 : : {
1220 : 464136 : return gs->code == GIMPLE_OMP_TARGET;
1221 : : }
1222 : :
1223 : : template <>
1224 : : template <>
1225 : : inline bool
1226 : 6545 : is_a_helper <gomp_sections *>::test (gimple *gs)
1227 : : {
1228 : 6545 : return gs->code == GIMPLE_OMP_SECTIONS;
1229 : : }
1230 : :
1231 : : template <>
1232 : : template <>
1233 : : inline bool
1234 : 8651 : is_a_helper <gomp_single *>::test (gimple *gs)
1235 : : {
1236 : 8651 : return gs->code == GIMPLE_OMP_SINGLE;
1237 : : }
1238 : :
1239 : : template <>
1240 : : template <>
1241 : : inline bool
1242 : 154163 : is_a_helper <gomp_teams *>::test (gimple *gs)
1243 : : {
1244 : 154163 : return gs->code == GIMPLE_OMP_TEAMS;
1245 : : }
1246 : :
1247 : : template <>
1248 : : template <>
1249 : : inline bool
1250 : 161552 : is_a_helper <gomp_task *>::test (gimple *gs)
1251 : : {
1252 : 161552 : return gs->code == GIMPLE_OMP_TASK;
1253 : : }
1254 : :
1255 : : template <>
1256 : : template <>
1257 : : inline bool
1258 : 10441246500 : is_a_helper <gphi *>::test (gimple *gs)
1259 : : {
1260 : 10441246500 : return gs->code == GIMPLE_PHI;
1261 : : }
1262 : :
1263 : : template <>
1264 : : template <>
1265 : : inline bool
1266 : 479894537 : is_a_helper <greturn *>::test (gimple *gs)
1267 : : {
1268 : 479894537 : return gs->code == GIMPLE_RETURN;
1269 : : }
1270 : :
1271 : : template <>
1272 : : template <>
1273 : : inline bool
1274 : 267796275 : is_a_helper <gswitch *>::test (gimple *gs)
1275 : : {
1276 : 267796275 : return gs->code == GIMPLE_SWITCH;
1277 : : }
1278 : :
1279 : : template <>
1280 : : template <>
1281 : : inline bool
1282 : 270337 : is_a_helper <const gswitch *>::test (const gimple *gs)
1283 : : {
1284 : 270337 : return gs->code == GIMPLE_SWITCH;
1285 : : }
1286 : :
1287 : : template <>
1288 : : template <>
1289 : : inline bool
1290 : 535 : is_a_helper <gimple_statement_assume *>::test (gimple *gs)
1291 : : {
1292 : 535 : return gs->code == GIMPLE_ASSUME;
1293 : : }
1294 : :
1295 : : template <>
1296 : : template <>
1297 : : inline bool
1298 : 115245 : is_a_helper <gtransaction *>::test (gimple *gs)
1299 : : {
1300 : 115245 : return gs->code == GIMPLE_TRANSACTION;
1301 : : }
1302 : :
1303 : : template <>
1304 : : template <>
1305 : : inline bool
1306 : 110193002 : is_a_helper <gtry *>::test (gimple *gs)
1307 : : {
1308 : 108770116 : return gs->code == GIMPLE_TRY;
1309 : : }
1310 : :
1311 : : template <>
1312 : : template <>
1313 : : inline bool
1314 : 3461 : is_a_helper <const gtry *>::test (const gimple *gs)
1315 : : {
1316 : 3461 : return gs->code == GIMPLE_TRY;
1317 : : }
1318 : :
1319 : : template <>
1320 : : template <>
1321 : : inline bool
1322 : 1184861 : is_a_helper <gimple_statement_wce *>::test (gimple *gs)
1323 : : {
1324 : 1184861 : return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
1325 : : }
1326 : :
1327 : : template <>
1328 : : template <>
1329 : : inline bool
1330 : 643631 : is_a_helper <const gasm *>::test (const gimple *gs)
1331 : : {
1332 : 643631 : return gs->code == GIMPLE_ASM;
1333 : : }
1334 : :
1335 : : template <>
1336 : : template <>
1337 : : inline bool
1338 : 16720 : is_a_helper <const gbind *>::test (const gimple *gs)
1339 : : {
1340 : 16720 : return gs->code == GIMPLE_BIND;
1341 : : }
1342 : :
1343 : : template <>
1344 : : template <>
1345 : : inline bool
1346 : 34212287571 : is_a_helper <const gcall *>::test (const gimple *gs)
1347 : : {
1348 : 34212287571 : return gs->code == GIMPLE_CALL;
1349 : : }
1350 : :
1351 : : template <>
1352 : : template <>
1353 : : inline bool
1354 : 0 : is_a_helper <const gcatch *>::test (const gimple *gs)
1355 : : {
1356 : 0 : return gs->code == GIMPLE_CATCH;
1357 : : }
1358 : :
1359 : : template <>
1360 : : template <>
1361 : : inline bool
1362 : 1658 : is_a_helper <const gresx *>::test (const gimple *gs)
1363 : : {
1364 : 1658 : return gs->code == GIMPLE_RESX;
1365 : : }
1366 : :
1367 : : template <>
1368 : : template <>
1369 : : inline bool
1370 : 23 : is_a_helper <const geh_dispatch *>::test (const gimple *gs)
1371 : : {
1372 : 23 : return gs->code == GIMPLE_EH_DISPATCH;
1373 : : }
1374 : :
1375 : : template <>
1376 : : template <>
1377 : : inline bool
1378 : 4295 : is_a_helper <const geh_filter *>::test (const gimple *gs)
1379 : : {
1380 : 4295 : return gs->code == GIMPLE_EH_FILTER;
1381 : : }
1382 : :
1383 : : template <>
1384 : : template <>
1385 : : inline bool
1386 : 526 : is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
1387 : : {
1388 : 526 : return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1389 : : }
1390 : :
1391 : : template <>
1392 : : template <>
1393 : : inline bool
1394 : 526 : is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
1395 : : {
1396 : 526 : return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1397 : : }
1398 : :
1399 : : template <>
1400 : : template <>
1401 : : inline bool
1402 : 10002 : is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs)
1403 : : {
1404 : 10002 : return gs->code == GIMPLE_OMP_RETURN;
1405 : : }
1406 : :
1407 : : template <>
1408 : : template <>
1409 : : inline bool
1410 : 292 : is_a_helper <const gomp_continue *>::test (const gimple *gs)
1411 : : {
1412 : 292 : return gs->code == GIMPLE_OMP_CONTINUE;
1413 : : }
1414 : :
1415 : : template <>
1416 : : template <>
1417 : : inline bool
1418 : 16 : is_a_helper <const gomp_critical *>::test (const gimple *gs)
1419 : : {
1420 : 16 : return gs->code == GIMPLE_OMP_CRITICAL;
1421 : : }
1422 : :
1423 : : template <>
1424 : : template <>
1425 : : inline bool
1426 : 37 : is_a_helper <const gomp_ordered *>::test (const gimple *gs)
1427 : : {
1428 : 37 : return gs->code == GIMPLE_OMP_ORDERED;
1429 : : }
1430 : :
1431 : : template <>
1432 : : template <>
1433 : : inline bool
1434 : 0 : is_a_helper <const gomp_scan *>::test (const gimple *gs)
1435 : : {
1436 : 0 : return gs->code == GIMPLE_OMP_SCAN;
1437 : : }
1438 : :
1439 : : template <>
1440 : : template <>
1441 : : inline bool
1442 : 2608972 : is_a_helper <const gomp_for *>::test (const gimple *gs)
1443 : : {
1444 : 2608972 : return gs->code == GIMPLE_OMP_FOR;
1445 : : }
1446 : :
1447 : : template <>
1448 : : template <>
1449 : : inline bool
1450 : 106573 : is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs)
1451 : : {
1452 : 106573 : return (gs->code == GIMPLE_OMP_PARALLEL
1453 : : || gs->code == GIMPLE_OMP_TASK
1454 : 106573 : || gs->code == GIMPLE_OMP_TEAMS);
1455 : : }
1456 : :
1457 : : template <>
1458 : : template <>
1459 : : inline bool
1460 : 117372 : is_a_helper <const gomp_parallel *>::test (const gimple *gs)
1461 : : {
1462 : 117372 : return gs->code == GIMPLE_OMP_PARALLEL;
1463 : : }
1464 : :
1465 : : template <>
1466 : : template <>
1467 : : inline bool
1468 : 181750 : is_a_helper <const gomp_target *>::test (const gimple *gs)
1469 : : {
1470 : 181750 : return gs->code == GIMPLE_OMP_TARGET;
1471 : : }
1472 : :
1473 : : template <>
1474 : : template <>
1475 : : inline bool
1476 : 3374 : is_a_helper <const gomp_sections *>::test (const gimple *gs)
1477 : : {
1478 : 3374 : return gs->code == GIMPLE_OMP_SECTIONS;
1479 : : }
1480 : :
1481 : : template <>
1482 : : template <>
1483 : : inline bool
1484 : 3636 : is_a_helper <const gomp_single *>::test (const gimple *gs)
1485 : : {
1486 : 3636 : return gs->code == GIMPLE_OMP_SINGLE;
1487 : : }
1488 : :
1489 : : template <>
1490 : : template <>
1491 : : inline bool
1492 : 35983 : is_a_helper <const gomp_teams *>::test (const gimple *gs)
1493 : : {
1494 : 35983 : return gs->code == GIMPLE_OMP_TEAMS;
1495 : : }
1496 : :
1497 : : template <>
1498 : : template <>
1499 : : inline bool
1500 : 44798 : is_a_helper <const gomp_task *>::test (const gimple *gs)
1501 : : {
1502 : 44798 : return gs->code == GIMPLE_OMP_TASK;
1503 : : }
1504 : :
1505 : : template <>
1506 : : template <>
1507 : : inline bool
1508 : 9609908534 : is_a_helper <const gphi *>::test (const gimple *gs)
1509 : : {
1510 : 9609908534 : return gs->code == GIMPLE_PHI;
1511 : : }
1512 : :
1513 : : template <>
1514 : : template <>
1515 : : inline bool
1516 : 69558 : is_a_helper <const greturn *>::test (const gimple *gs)
1517 : : {
1518 : 69558 : return gs->code == GIMPLE_RETURN;
1519 : : }
1520 : :
1521 : : template <>
1522 : : template <>
1523 : : inline bool
1524 : 626 : is_a_helper <const gimple_statement_assume *>::test (const gimple *gs)
1525 : : {
1526 : 626 : return gs->code == GIMPLE_ASSUME;
1527 : : }
1528 : :
1529 : : template <>
1530 : : template <>
1531 : : inline bool
1532 : 77 : is_a_helper <const gtransaction *>::test (const gimple *gs)
1533 : : {
1534 : 77 : return gs->code == GIMPLE_TRANSACTION;
1535 : : }
1536 : :
1537 : : /* Offset in bytes to the location of the operand vector.
1538 : : Zero if there is no operand vector for this tuple structure. */
1539 : : extern size_t const gimple_ops_offset_[];
1540 : :
1541 : : /* Map GIMPLE codes to GSS codes. */
1542 : : extern enum gimple_statement_structure_enum const gss_for_code_[];
1543 : :
1544 : : /* This variable holds the currently expanded gimple statement for purposes
1545 : : of comminucating the profile info to the builtin expanders. */
1546 : : extern gimple *currently_expanding_gimple_stmt;
1547 : :
1548 : : size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
1549 : : void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
1550 : : gimple *gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO);
1551 : : greturn *gimple_build_return (tree);
1552 : : void gimple_call_reset_alias_info (gcall *);
1553 : : gcall *gimple_build_call_vec (tree, const vec<tree> &);
1554 : : gcall *gimple_build_call (tree, unsigned, ...);
1555 : : gcall *gimple_build_call_valist (tree, unsigned, va_list);
1556 : : gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
1557 : : gcall *gimple_build_call_internal_vec (enum internal_fn, const vec<tree> &);
1558 : : gcall *gimple_build_call_from_tree (tree, tree);
1559 : : gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO);
1560 : : gassign *gimple_build_assign (tree, enum tree_code,
1561 : : tree, tree, tree CXX_MEM_STAT_INFO);
1562 : : gassign *gimple_build_assign (tree, enum tree_code,
1563 : : tree, tree CXX_MEM_STAT_INFO);
1564 : : gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
1565 : : gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
1566 : : gcond *gimple_build_cond_from_tree (tree, tree, tree);
1567 : : void gimple_cond_set_condition_from_tree (gcond *, tree);
1568 : : glabel *gimple_build_label (tree label);
1569 : : ggoto *gimple_build_goto (tree dest);
1570 : : gimple *gimple_build_nop (void);
1571 : : gbind *gimple_build_bind (tree, gimple_seq, tree);
1572 : : gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
1573 : : vec<tree, va_gc> *, vec<tree, va_gc> *,
1574 : : vec<tree, va_gc> *);
1575 : : gcatch *gimple_build_catch (tree, gimple_seq);
1576 : : geh_filter *gimple_build_eh_filter (tree, gimple_seq);
1577 : : geh_mnt *gimple_build_eh_must_not_throw (tree);
1578 : : geh_else *gimple_build_eh_else (gimple_seq, gimple_seq);
1579 : : gtry *gimple_build_try (gimple_seq, gimple_seq,
1580 : : enum gimple_try_flags);
1581 : : gimple *gimple_build_wce (gimple_seq);
1582 : : gresx *gimple_build_resx (int);
1583 : : gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
1584 : : gswitch *gimple_build_switch (tree, tree, const vec<tree> &);
1585 : : geh_dispatch *gimple_build_eh_dispatch (int);
1586 : : gdebug *gimple_build_debug_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1587 : : gdebug *gimple_build_debug_source_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1588 : : gdebug *gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO);
1589 : : gdebug *gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO);
1590 : : gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree);
1591 : : gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
1592 : : gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
1593 : : gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree,
1594 : : tree, tree);
1595 : : gimple *gimple_build_omp_section (gimple_seq);
1596 : : gimple *gimple_build_omp_structured_block (gimple_seq);
1597 : : gimple *gimple_build_omp_scope (gimple_seq, tree);
1598 : : gimple *gimple_build_omp_dispatch (gimple_seq, tree);
1599 : : gimple *gimple_build_omp_interop (tree);
1600 : : gimple *gimple_build_omp_master (gimple_seq);
1601 : : gimple *gimple_build_omp_masked (gimple_seq, tree);
1602 : : gimple *gimple_build_omp_taskgroup (gimple_seq, tree);
1603 : : gomp_continue *gimple_build_omp_continue (tree, tree);
1604 : : gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree);
1605 : : gimple *gimple_build_omp_return (bool);
1606 : : gomp_scan *gimple_build_omp_scan (gimple_seq, tree);
1607 : : gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
1608 : : gimple *gimple_build_omp_sections_switch (void);
1609 : : gomp_single *gimple_build_omp_single (gimple_seq, tree);
1610 : : gomp_target *gimple_build_omp_target (gimple_seq, int, tree);
1611 : : gomp_teams *gimple_build_omp_teams (gimple_seq, tree);
1612 : : gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree,
1613 : : enum omp_memory_order);
1614 : : gomp_atomic_store *gimple_build_omp_atomic_store (tree, enum omp_memory_order);
1615 : : gimple *gimple_build_assume (tree, gimple_seq);
1616 : : gtransaction *gimple_build_transaction (gimple_seq);
1617 : : extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
1618 : : extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
1619 : : void gimple_seq_add_seq (gimple_seq *, gimple_seq);
1620 : : void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq);
1621 : : extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
1622 : : location_t);
1623 : : extern void annotate_all_with_location (gimple_seq, location_t);
1624 : : bool empty_body_p (gimple_seq);
1625 : : gimple_seq gimple_seq_copy (gimple_seq);
1626 : : bool gimple_call_same_target_p (const gimple *, const gimple *);
1627 : : int gimple_call_flags (const gimple *);
1628 : : int gimple_call_arg_flags (const gcall *, unsigned);
1629 : : int gimple_call_retslot_flags (const gcall *);
1630 : : int gimple_call_static_chain_flags (const gcall *);
1631 : : int gimple_call_return_flags (const gcall *);
1632 : : bool gimple_call_nonnull_result_p (gcall *);
1633 : : tree gimple_call_nonnull_arg (gcall *);
1634 : : bool gimple_assign_copy_p (gimple *);
1635 : : bool gimple_assign_ssa_name_copy_p (gimple *);
1636 : : bool gimple_assign_unary_nop_p (gimple *);
1637 : : bool gimple_assign_load_p (const gimple *);
1638 : : void gimple_set_bb (gimple *, basic_block);
1639 : : void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
1640 : : void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
1641 : : tree, tree, tree);
1642 : : tree gimple_get_lhs (const gimple *);
1643 : : void gimple_set_lhs (gimple *, tree);
1644 : : gimple *gimple_copy (gimple *);
1645 : : void gimple_move_vops (gimple *, gimple *);
1646 : : bool gimple_has_side_effects (const gimple *);
1647 : : bool gimple_could_trap_p_1 (const gimple *, bool, bool);
1648 : : bool gimple_could_trap_p (const gimple *);
1649 : : bool gimple_assign_rhs_could_trap_p (gimple *);
1650 : : extern void dump_gimple_statistics (void);
1651 : : unsigned get_gimple_rhs_num_ops (enum tree_code);
1652 : : gcall *gimple_call_copy_skip_args (gcall *, bitmap);
1653 : : extern bool gimple_compare_field_offset (tree, tree);
1654 : : extern tree gimple_unsigned_type (tree);
1655 : : extern tree gimple_signed_type (tree);
1656 : : extern alias_set_type gimple_get_alias_set (tree);
1657 : : extern bool gimple_ior_addresses_taken (bitmap, gimple *);
1658 : : extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
1659 : : extern combined_fn gimple_call_combined_fn (const gimple *);
1660 : : extern bool gimple_call_operator_delete_p (const gcall *);
1661 : : extern bool gimple_call_builtin_p (const gimple *);
1662 : : extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
1663 : : extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
1664 : : extern bool gimple_asm_clobbers_memory_p (const gasm *);
1665 : : extern void dump_decl_set (FILE *, bitmap);
1666 : : extern bool nonfreeing_call_p (gimple *);
1667 : : extern bool nonbarrier_call_p (gimple *);
1668 : : extern bool infer_nonnull_range (gimple *, tree);
1669 : : extern bool infer_nonnull_range_by_dereference (gimple *, tree);
1670 : : extern bool infer_nonnull_range_by_attribute (gimple *, tree, tree * = NULL,
1671 : : tree * = NULL);
1672 : : extern void sort_case_labels (vec<tree> &);
1673 : : extern void preprocess_case_label_vec_for_gimple (vec<tree> &, tree, tree *);
1674 : : extern void gimple_seq_set_location (gimple_seq, location_t);
1675 : : extern void gimple_seq_discard (gimple_seq);
1676 : : extern void maybe_remove_unused_call_args (struct function *, gimple *);
1677 : : extern bool gimple_inexpensive_call_p (gcall *);
1678 : : extern bool stmt_can_terminate_bb_p (gimple *);
1679 : : extern location_t gimple_or_expr_nonartificial_location (gimple *, tree);
1680 : : gcall *gimple_build_builtin_unreachable (location_t);
1681 : :
1682 : : /* Return the disposition for a warning (or all warnings by default)
1683 : : for a statement. */
1684 : : extern bool warning_suppressed_p (const gimple *, opt_code = all_warnings)
1685 : : ATTRIBUTE_NONNULL (1);
1686 : : /* Set the disposition for a warning (or all warnings by default)
1687 : : at a location to enabled by default. */
1688 : : extern void suppress_warning (gimple *, opt_code = all_warnings,
1689 : : bool = true) ATTRIBUTE_NONNULL (1);
1690 : :
1691 : : /* Copy the warning disposition mapping from one statement to another. */
1692 : : extern void copy_warning (gimple *, const gimple *)
1693 : : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1694 : : /* Copy the warning disposition mapping from an expression to a statement. */
1695 : : extern void copy_warning (gimple *, const_tree)
1696 : : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1697 : : /* Copy the warning disposition mapping from a statement to an expression. */
1698 : : extern void copy_warning (tree, const gimple *)
1699 : : ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1700 : :
1701 : : /* Formal (expression) temporary table handling: multiple occurrences of
1702 : : the same scalar expression are evaluated into the same temporary. */
1703 : :
1704 : : typedef struct gimple_temp_hash_elt
1705 : : {
1706 : : tree val; /* Key */
1707 : : tree temp; /* Value */
1708 : : } elt_t;
1709 : :
1710 : : /* Get the number of the next statement uid to be allocated. */
1711 : : inline unsigned int
1712 : 8468353 : gimple_stmt_max_uid (struct function *fn)
1713 : : {
1714 : 8468353 : return fn->last_stmt_uid;
1715 : : }
1716 : :
1717 : : /* Set the number of the next statement uid to be allocated. */
1718 : : inline void
1719 : 20407515 : set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
1720 : : {
1721 : 20407515 : fn->last_stmt_uid = maxid;
1722 : : }
1723 : :
1724 : : /* Set the number of the next statement uid to be allocated. */
1725 : : inline unsigned int
1726 : 1070830040 : inc_gimple_stmt_max_uid (struct function *fn)
1727 : : {
1728 : 1070830040 : return fn->last_stmt_uid++;
1729 : : }
1730 : :
1731 : : /* Return the first node in GIMPLE sequence S. */
1732 : :
1733 : : inline gimple_seq_node
1734 : : gimple_seq_first (gimple_seq s)
1735 : : {
1736 : : return s;
1737 : : }
1738 : :
1739 : :
1740 : : /* Return the first statement in GIMPLE sequence S. */
1741 : :
1742 : : inline gimple *
1743 : : gimple_seq_first_stmt (gimple_seq s)
1744 : : {
1745 : 9661186 : gimple_seq_node n = gimple_seq_first (s);
1746 : : return n;
1747 : : }
1748 : :
1749 : : /* Return the first statement in GIMPLE sequence S as a gbind *,
1750 : : verifying that it has code GIMPLE_BIND in a checked build. */
1751 : :
1752 : : inline gbind *
1753 : 24189 : gimple_seq_first_stmt_as_a_bind (gimple_seq s)
1754 : : {
1755 : 24189 : gimple_seq_node n = gimple_seq_first (s);
1756 : 24189 : return as_a <gbind *> (n);
1757 : : }
1758 : :
1759 : :
1760 : : /* Return the last node in GIMPLE sequence S. */
1761 : :
1762 : : inline gimple_seq_node
1763 : 7154818346 : gimple_seq_last (gimple_seq s)
1764 : : {
1765 : 7152659653 : return s ? s->prev : NULL;
1766 : : }
1767 : :
1768 : :
1769 : : /* Return the last statement in GIMPLE sequence S. */
1770 : :
1771 : : inline gimple *
1772 : 2223284 : gimple_seq_last_stmt (gimple_seq s)
1773 : : {
1774 : 915401 : gimple_seq_node n = gimple_seq_last (s);
1775 : 1487437 : return n;
1776 : : }
1777 : :
1778 : :
1779 : : /* Set the last node in GIMPLE sequence *PS to LAST. */
1780 : :
1781 : : inline void
1782 : 438628826 : gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
1783 : : {
1784 : 23681879 : (*ps)->prev = last;
1785 : 414357884 : }
1786 : :
1787 : :
1788 : : /* Set the first node in GIMPLE sequence *PS to FIRST. */
1789 : :
1790 : : inline void
1791 : 203177926 : gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
1792 : : {
1793 : 183051197 : *ps = first;
1794 : 20715792 : }
1795 : :
1796 : :
1797 : : /* Return true if GIMPLE sequence S is empty. */
1798 : :
1799 : : inline bool
1800 : 199183165 : gimple_seq_empty_p (gimple_seq s)
1801 : : {
1802 : 199183165 : return s == NULL;
1803 : : }
1804 : :
1805 : : /* Allocate a new sequence and initialize its first element with STMT. */
1806 : :
1807 : : inline gimple_seq
1808 : 13235177 : gimple_seq_alloc_with_stmt (gimple *stmt)
1809 : : {
1810 : 13235177 : gimple_seq seq = NULL;
1811 : 13235177 : gimple_seq_add_stmt (&seq, stmt);
1812 : 13235177 : return seq;
1813 : : }
1814 : :
1815 : :
1816 : : /* Returns the sequence of statements in BB. */
1817 : :
1818 : : inline gimple_seq
1819 : 96221803 : bb_seq (const_basic_block bb)
1820 : : {
1821 : 96221803 : return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL;
1822 : : }
1823 : :
1824 : : inline gimple_seq *
1825 : 19202024943 : bb_seq_addr (basic_block bb)
1826 : : {
1827 : 19170348053 : return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL;
1828 : : }
1829 : :
1830 : : /* Sets the sequence of statements in BB to SEQ. */
1831 : :
1832 : : inline void
1833 : 89597269 : set_bb_seq (basic_block bb, gimple_seq seq)
1834 : : {
1835 : 89597269 : gcc_checking_assert (!(bb->flags & BB_RTL));
1836 : 89597269 : bb->il.gimple.seq = seq;
1837 : 89597269 : }
1838 : :
1839 : :
1840 : : /* Return the code for GIMPLE statement G. */
1841 : :
1842 : : inline enum gimple_code
1843 : >58210*10^7 : gimple_code (const gimple *g)
1844 : : {
1845 : >18531*10^7 : return g->code;
1846 : : }
1847 : :
1848 : :
1849 : : /* Return the GSS code used by a GIMPLE code. */
1850 : :
1851 : : inline enum gimple_statement_structure_enum
1852 : >10013*10^7 : gss_for_code (enum gimple_code code)
1853 : : {
1854 : >10013*10^7 : gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
1855 : >10013*10^7 : return gss_for_code_[code];
1856 : : }
1857 : :
1858 : :
1859 : : /* Return which GSS code is used by GS. */
1860 : :
1861 : : inline enum gimple_statement_structure_enum
1862 : 99768733257 : gimple_statement_structure (gimple *gs)
1863 : : {
1864 : 54508301869 : return gss_for_code (gimple_code (gs));
1865 : : }
1866 : :
1867 : :
1868 : : /* Return true if statement G has sub-statements. This is only true for
1869 : : High GIMPLE statements. */
1870 : :
1871 : : inline bool
1872 : 361308817 : gimple_has_substatements (gimple *g)
1873 : : {
1874 : 361308817 : switch (gimple_code (g))
1875 : : {
1876 : : case GIMPLE_ASSUME:
1877 : : case GIMPLE_BIND:
1878 : : case GIMPLE_CATCH:
1879 : : case GIMPLE_EH_FILTER:
1880 : : case GIMPLE_EH_ELSE:
1881 : : case GIMPLE_TRY:
1882 : : case GIMPLE_OMP_FOR:
1883 : : case GIMPLE_OMP_MASTER:
1884 : : case GIMPLE_OMP_MASKED:
1885 : : case GIMPLE_OMP_TASKGROUP:
1886 : : case GIMPLE_OMP_ORDERED:
1887 : : case GIMPLE_OMP_SECTION:
1888 : : case GIMPLE_OMP_STRUCTURED_BLOCK:
1889 : : case GIMPLE_OMP_PARALLEL:
1890 : : case GIMPLE_OMP_TASK:
1891 : : case GIMPLE_OMP_SCOPE:
1892 : : case GIMPLE_OMP_DISPATCH:
1893 : : case GIMPLE_OMP_SECTIONS:
1894 : : case GIMPLE_OMP_SINGLE:
1895 : : case GIMPLE_OMP_TARGET:
1896 : : case GIMPLE_OMP_TEAMS:
1897 : : case GIMPLE_OMP_CRITICAL:
1898 : : case GIMPLE_WITH_CLEANUP_EXPR:
1899 : : case GIMPLE_TRANSACTION:
1900 : : return true;
1901 : :
1902 : 361257555 : default:
1903 : 361257555 : return false;
1904 : : }
1905 : : }
1906 : :
1907 : :
1908 : : /* Return the basic block holding statement G. */
1909 : :
1910 : : inline basic_block
1911 : 34702858773 : gimple_bb (const gimple *g)
1912 : : {
1913 : 32862138271 : return g->bb;
1914 : : }
1915 : :
1916 : :
1917 : : /* Return the lexical scope block holding statement G. */
1918 : :
1919 : : inline tree
1920 : 1478458238 : gimple_block (const gimple *g)
1921 : : {
1922 : 1478458238 : return LOCATION_BLOCK (g->location);
1923 : : }
1924 : :
1925 : : /* Forward declare. */
1926 : : inline void gimple_set_location (gimple *, location_t);
1927 : :
1928 : : /* Set BLOCK to be the lexical scope block holding statement G. */
1929 : :
1930 : : inline void
1931 : 176165444 : gimple_set_block (gimple *g, tree block)
1932 : : {
1933 : 176165444 : gimple_set_location (g, set_block (g->location, block));
1934 : 176165444 : }
1935 : :
1936 : : /* Return location information for statement G. */
1937 : :
1938 : : inline location_t
1939 : 16136956921 : gimple_location (const gimple *g)
1940 : : {
1941 : 16047701732 : return g->location;
1942 : : }
1943 : :
1944 : : /* Return location information for statement G if g is not NULL.
1945 : : Otherwise, UNKNOWN_LOCATION is returned. */
1946 : :
1947 : : inline location_t
1948 : : gimple_location_safe (const gimple *g)
1949 : : {
1950 : : return g ? gimple_location (g) : UNKNOWN_LOCATION;
1951 : : }
1952 : :
1953 : : /* Set location information for statement G. */
1954 : :
1955 : : inline void
1956 : 397431203 : gimple_set_location (gimple *g, location_t location)
1957 : : {
1958 : : /* Copy the no-warning data to the statement location. */
1959 : 397423487 : if (g->location != UNKNOWN_LOCATION)
1960 : 193945638 : copy_warning (location, g->location);
1961 : 226331571 : g->location = location;
1962 : 126494154 : }
1963 : :
1964 : : /* Return address of the location information for statement G. */
1965 : :
1966 : : inline location_t *
1967 : 1391741 : gimple_location_ptr (gimple *g)
1968 : : {
1969 : 1391741 : return &g->location;
1970 : : }
1971 : :
1972 : :
1973 : : /* Return true if G contains location information. */
1974 : :
1975 : : inline bool
1976 : 751238568 : gimple_has_location (const gimple *g)
1977 : : {
1978 : 751238568 : return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
1979 : : }
1980 : :
1981 : :
1982 : : /* Return non-artificial location information for statement G. */
1983 : :
1984 : : inline location_t
1985 : 168808 : gimple_nonartificial_location (const gimple *g)
1986 : : {
1987 : 168808 : location_t *ploc = NULL;
1988 : :
1989 : 168808 : if (tree block = gimple_block (g))
1990 : 167270 : ploc = block_nonartificial_location (block);
1991 : :
1992 : 168808 : return ploc ? *ploc : gimple_location (g);
1993 : : }
1994 : :
1995 : :
1996 : : /* Return the file name of the location of STMT. */
1997 : :
1998 : : inline const char *
1999 : 10574 : gimple_filename (const gimple *stmt)
2000 : : {
2001 : 10574 : return LOCATION_FILE (gimple_location (stmt));
2002 : : }
2003 : :
2004 : :
2005 : : /* Return the line number of the location of STMT. */
2006 : :
2007 : : inline int
2008 : 20732 : gimple_lineno (const gimple *stmt)
2009 : : {
2010 : 10583 : return LOCATION_LINE (gimple_location (stmt));
2011 : : }
2012 : :
2013 : :
2014 : : /* Determine whether SEQ is a singleton. */
2015 : :
2016 : : inline bool
2017 : 421847 : gimple_seq_singleton_p (gimple_seq seq)
2018 : : {
2019 : 421847 : return ((gimple_seq_first (seq) != NULL)
2020 : 421847 : && (gimple_seq_first (seq) == gimple_seq_last (seq)));
2021 : : }
2022 : :
2023 : : /* Return true if no warnings should be emitted for statement STMT. */
2024 : :
2025 : : inline bool
2026 : 1662417 : gimple_no_warning_p (const gimple *stmt)
2027 : : {
2028 : 1662417 : return stmt->no_warning;
2029 : : }
2030 : :
2031 : : /* Set the no_warning flag of STMT to NO_WARNING. */
2032 : :
2033 : : inline void
2034 : : gimple_set_no_warning (gimple *stmt, bool no_warning)
2035 : : {
2036 : : stmt->no_warning = (unsigned) no_warning;
2037 : : }
2038 : :
2039 : : /* Set the visited status on statement STMT to VISITED_P.
2040 : :
2041 : : Please note that this 'visited' property of the gimple statement is
2042 : : supposed to be undefined at pass boundaries. This means that a
2043 : : given pass should not assume it contains any useful value when the
2044 : : pass starts and thus can set it to any value it sees fit.
2045 : :
2046 : : You can learn more about the visited property of the gimple
2047 : : statement by reading the comments of the 'visited' data member of
2048 : : struct gimple.
2049 : : */
2050 : :
2051 : : inline void
2052 : 2255537013 : gimple_set_visited (gimple *stmt, bool visited_p)
2053 : : {
2054 : 2083717863 : stmt->visited = (unsigned) visited_p;
2055 : 171819150 : }
2056 : :
2057 : :
2058 : : /* Return the visited status for statement STMT.
2059 : :
2060 : : Please note that this 'visited' property of the gimple statement is
2061 : : supposed to be undefined at pass boundaries. This means that a
2062 : : given pass should not assume it contains any useful value when the
2063 : : pass starts and thus can set it to any value it sees fit.
2064 : :
2065 : : You can learn more about the visited property of the gimple
2066 : : statement by reading the comments of the 'visited' data member of
2067 : : struct gimple. */
2068 : :
2069 : : inline bool
2070 : 6244033711 : gimple_visited_p (gimple *stmt)
2071 : : {
2072 : 6244033711 : return stmt->visited;
2073 : : }
2074 : :
2075 : :
2076 : : /* Set pass local flag PLF on statement STMT to VAL_P.
2077 : :
2078 : : Please note that this PLF property of the gimple statement is
2079 : : supposed to be undefined at pass boundaries. This means that a
2080 : : given pass should not assume it contains any useful value when the
2081 : : pass starts and thus can set it to any value it sees fit.
2082 : :
2083 : : You can learn more about the PLF property by reading the comment of
2084 : : the 'plf' data member of struct gimple_statement_structure. */
2085 : :
2086 : : inline void
2087 : 2964459347 : gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
2088 : : {
2089 : 2964459347 : if (val_p)
2090 : 1202697687 : stmt->plf |= (unsigned int) plf;
2091 : : else
2092 : 1746970600 : stmt->plf &= ~((unsigned int) plf);
2093 : 42019817 : }
2094 : :
2095 : :
2096 : : /* Return the value of pass local flag PLF on statement STMT.
2097 : :
2098 : : Please note that this 'plf' property of the gimple statement is
2099 : : supposed to be undefined at pass boundaries. This means that a
2100 : : given pass should not assume it contains any useful value when the
2101 : : pass starts and thus can set it to any value it sees fit.
2102 : :
2103 : : You can learn more about the plf property by reading the comment of
2104 : : the 'plf' data member of struct gimple_statement_structure. */
2105 : :
2106 : : inline unsigned int
2107 : 4217381972 : gimple_plf (gimple *stmt, enum plf_mask plf)
2108 : : {
2109 : 4181415412 : return stmt->plf & ((unsigned int) plf);
2110 : : }
2111 : :
2112 : :
2113 : : /* Set the UID of statement.
2114 : :
2115 : : Please note that this UID property is supposed to be undefined at
2116 : : pass boundaries. This means that a given pass should not assume it
2117 : : contains any useful value when the pass starts and thus can set it
2118 : : to any value it sees fit. */
2119 : :
2120 : : inline void
2121 : 2076577537 : gimple_set_uid (gimple *g, unsigned uid)
2122 : : {
2123 : 2075169517 : g->uid = uid;
2124 : 35051595 : }
2125 : :
2126 : :
2127 : : /* Return the UID of statement.
2128 : :
2129 : : Please note that this UID property is supposed to be undefined at
2130 : : pass boundaries. This means that a given pass should not assume it
2131 : : contains any useful value when the pass starts and thus can set it
2132 : : to any value it sees fit. */
2133 : :
2134 : : inline unsigned
2135 : 2048560701 : gimple_uid (const gimple *g)
2136 : : {
2137 : 2039882312 : return g->uid;
2138 : : }
2139 : :
2140 : :
2141 : : /* Make statement G a singleton sequence. */
2142 : :
2143 : : inline void
2144 : 391855434 : gimple_init_singleton (gimple *g)
2145 : : {
2146 : 391855434 : g->next = NULL;
2147 : 87115230 : g->prev = g;
2148 : : }
2149 : :
2150 : :
2151 : : /* Return true if GIMPLE statement G has register or memory operands. */
2152 : :
2153 : : inline bool
2154 : >12740*10^7 : gimple_has_ops (const gimple *g)
2155 : : {
2156 : >12740*10^7 : return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
2157 : : }
2158 : :
2159 : : template <>
2160 : : template <>
2161 : : inline bool
2162 : 26412337002 : is_a_helper <const gimple_statement_with_ops *>::test (const gimple *gs)
2163 : : {
2164 : 66107974352 : return gimple_has_ops (gs);
2165 : : }
2166 : :
2167 : : template <>
2168 : : template <>
2169 : : inline bool
2170 : 423254168 : is_a_helper <gimple_statement_with_ops *>::test (gimple *gs)
2171 : : {
2172 : 846508336 : return gimple_has_ops (gs);
2173 : : }
2174 : :
2175 : : /* Return true if GIMPLE statement G has memory operands. */
2176 : :
2177 : : inline bool
2178 : >10928*10^7 : gimple_has_mem_ops (const gimple *g)
2179 : : {
2180 : 59445546433 : return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
2181 : : }
2182 : :
2183 : : template <>
2184 : : template <>
2185 : : inline bool
2186 : 39720690073 : is_a_helper <const gimple_statement_with_memory_ops *>::test (const gimple *gs)
2187 : : {
2188 : >13616*10^7 : return gimple_has_mem_ops (gs);
2189 : : }
2190 : :
2191 : : template <>
2192 : : template <>
2193 : : inline bool
2194 : 561324410 : is_a_helper <gimple_statement_with_memory_ops *>::test (gimple *gs)
2195 : : {
2196 : 2593547799 : return gimple_has_mem_ops (gs);
2197 : : }
2198 : :
2199 : : /* Return the set of USE operands for statement G. */
2200 : :
2201 : : inline struct use_optype_d *
2202 : 26412350605 : gimple_use_ops (const gimple *g)
2203 : : {
2204 : 26412337002 : const gimple_statement_with_ops *ops_stmt =
2205 : 39694786104 : dyn_cast <const gimple_statement_with_ops *> (g);
2206 : 26277834488 : if (!ops_stmt)
2207 : : return NULL;
2208 : 26277834488 : return ops_stmt->use_ops;
2209 : : }
2210 : :
2211 : :
2212 : : /* Set USE to be the set of USE operands for statement G. */
2213 : :
2214 : : inline void
2215 : 423254168 : gimple_set_use_ops (gimple *g, struct use_optype_d *use)
2216 : : {
2217 : 423254168 : gimple_statement_with_ops *ops_stmt =
2218 : 423254168 : as_a <gimple_statement_with_ops *> (g);
2219 : 63617440 : ops_stmt->use_ops = use;
2220 : 5248 : }
2221 : :
2222 : :
2223 : : /* Return the single VUSE operand of the statement G. */
2224 : :
2225 : : inline tree
2226 : 46420126845 : gimple_vuse (const gimple *g)
2227 : : {
2228 : 49423694951 : const gimple_statement_with_memory_ops *mem_ops_stmt =
2229 : 53896512729 : dyn_cast <const gimple_statement_with_memory_ops *> (g);
2230 : 23846013448 : if (!mem_ops_stmt)
2231 : : return NULL_TREE;
2232 : 23738135016 : return mem_ops_stmt->vuse;
2233 : : }
2234 : :
2235 : : /* Return the single VDEF operand of the statement G. */
2236 : :
2237 : : inline tree
2238 : 23441107847 : gimple_vdef (const gimple *g)
2239 : : {
2240 : 34225948164 : const gimple_statement_with_memory_ops *mem_ops_stmt =
2241 : 43237802390 : dyn_cast <const gimple_statement_with_memory_ops *> (g);
2242 : 15670255244 : if (!mem_ops_stmt)
2243 : : return NULL_TREE;
2244 : 15638937255 : return mem_ops_stmt->vdef;
2245 : : }
2246 : :
2247 : : /* Return the single VUSE operand of the statement G. */
2248 : :
2249 : : inline tree *
2250 : 91884648 : gimple_vuse_ptr (gimple *g)
2251 : : {
2252 : 91884648 : gimple_statement_with_memory_ops *mem_ops_stmt =
2253 : 91884648 : dyn_cast <gimple_statement_with_memory_ops *> (g);
2254 : 91884648 : if (!mem_ops_stmt)
2255 : : return NULL;
2256 : 91884648 : return &mem_ops_stmt->vuse;
2257 : : }
2258 : :
2259 : : /* Return the single VDEF operand of the statement G. */
2260 : :
2261 : : inline tree *
2262 : 161148068 : gimple_vdef_ptr (gimple *g)
2263 : : {
2264 : 161148068 : gimple_statement_with_memory_ops *mem_ops_stmt =
2265 : 1526559068 : dyn_cast <gimple_statement_with_memory_ops *> (g);
2266 : 161148068 : if (!mem_ops_stmt)
2267 : : return NULL;
2268 : 161148068 : return &mem_ops_stmt->vdef;
2269 : : }
2270 : :
2271 : : /* Set the single VUSE operand of the statement G. */
2272 : :
2273 : : inline void
2274 : 206880176 : gimple_set_vuse (gimple *g, tree vuse)
2275 : : {
2276 : 206880176 : gimple_statement_with_memory_ops *mem_ops_stmt =
2277 : 206957829 : as_a <gimple_statement_with_memory_ops *> (g);
2278 : 206880176 : mem_ops_stmt->vuse = vuse;
2279 : 121474282 : }
2280 : :
2281 : : /* Set the single VDEF operand of the statement G. */
2282 : :
2283 : : inline void
2284 : 101411518 : gimple_set_vdef (gimple *g, tree vdef)
2285 : : {
2286 : 101411518 : gimple_statement_with_memory_ops *mem_ops_stmt =
2287 : 101489171 : as_a <gimple_statement_with_memory_ops *> (g);
2288 : 101411518 : mem_ops_stmt->vdef = vdef;
2289 : 41468031 : }
2290 : :
2291 : :
2292 : : /* Return true if statement G has operands and the modified field has
2293 : : been set. */
2294 : :
2295 : : inline bool
2296 : 14628919284 : gimple_modified_p (const gimple *g)
2297 : : {
2298 : 29241097743 : return (gimple_has_ops (g)) ? (bool) g->modified : false;
2299 : : }
2300 : :
2301 : :
2302 : : /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2303 : : a MODIFIED field. */
2304 : :
2305 : : inline void
2306 : 751721302 : gimple_set_modified (gimple *s, bool modifiedp)
2307 : : {
2308 : 2894574412 : if (gimple_has_ops (s))
2309 : 747003393 : s->modified = (unsigned) modifiedp;
2310 : 103 : }
2311 : :
2312 : :
2313 : : /* Return true if statement STMT contains volatile operands. */
2314 : :
2315 : : inline bool
2316 : 24342127738 : gimple_has_volatile_ops (const gimple *stmt)
2317 : : {
2318 : 35379239650 : if (gimple_has_mem_ops (stmt))
2319 : 11075285978 : return stmt->has_volatile_ops;
2320 : : else
2321 : : return false;
2322 : : }
2323 : :
2324 : :
2325 : : /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2326 : :
2327 : : inline void
2328 : 11542689471 : gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
2329 : : {
2330 : 21845390897 : if (gimple_has_mem_ops (stmt))
2331 : 4974434998 : stmt->has_volatile_ops = (unsigned) volatilep;
2332 : : }
2333 : :
2334 : : /* Return true if STMT is in a transaction. */
2335 : :
2336 : : inline bool
2337 : 428 : gimple_in_transaction (const gimple *stmt)
2338 : : {
2339 : 428 : return bb_in_transaction (gimple_bb (stmt));
2340 : : }
2341 : :
2342 : : /* Return true if statement STMT may access memory. */
2343 : :
2344 : : inline bool
2345 : 101094654 : gimple_references_memory_p (gimple *stmt)
2346 : : {
2347 : 179161032 : return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
2348 : : }
2349 : :
2350 : :
2351 : : /* Return the subcode for OMP statement S. */
2352 : :
2353 : : inline unsigned
2354 : 3359780 : gimple_omp_subcode (const gimple *s)
2355 : : {
2356 : 3359780 : gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
2357 : : && gimple_code (s) <= GIMPLE_OMP_ORDERED);
2358 : 3359780 : return s->subcode;
2359 : : }
2360 : :
2361 : : /* Set the subcode for OMP statement S to SUBCODE. */
2362 : :
2363 : : inline void
2364 : 12553 : gimple_omp_set_subcode (gimple *s, unsigned int subcode)
2365 : : {
2366 : : /* We only have 16 bits for the subcode. Assert that we are not
2367 : : overflowing it. */
2368 : 12553 : gcc_gimple_checking_assert (subcode < (1 << 16));
2369 : 12553 : s->subcode = subcode;
2370 : 12553 : }
2371 : :
2372 : : /* Set the nowait flag on OMP_RETURN statement S. */
2373 : :
2374 : : inline void
2375 : 38186 : gimple_omp_return_set_nowait (gimple *s)
2376 : : {
2377 : 38186 : GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
2378 : 38186 : s->subcode |= GF_OMP_RETURN_NOWAIT;
2379 : 38186 : }
2380 : :
2381 : :
2382 : : /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2383 : : flag set. */
2384 : :
2385 : : inline bool
2386 : 84071 : gimple_omp_return_nowait_p (const gimple *g)
2387 : : {
2388 : 84071 : GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
2389 : 84071 : return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
2390 : : }
2391 : :
2392 : :
2393 : : /* Set the LHS of OMP return. */
2394 : :
2395 : : inline void
2396 : 64 : gimple_omp_return_set_lhs (gimple *g, tree lhs)
2397 : : {
2398 : 64 : gimple_statement_omp_return *omp_return_stmt =
2399 : 64 : as_a <gimple_statement_omp_return *> (g);
2400 : 64 : omp_return_stmt->val = lhs;
2401 : : }
2402 : :
2403 : :
2404 : : /* Get the LHS of OMP return. */
2405 : :
2406 : : inline tree
2407 : 10002 : gimple_omp_return_lhs (const gimple *g)
2408 : : {
2409 : 10002 : const gimple_statement_omp_return *omp_return_stmt =
2410 : 10002 : as_a <const gimple_statement_omp_return *> (g);
2411 : 10002 : return omp_return_stmt->val;
2412 : : }
2413 : :
2414 : :
2415 : : /* Return a pointer to the LHS of OMP return. */
2416 : :
2417 : : inline tree *
2418 : 399448 : gimple_omp_return_lhs_ptr (gimple *g)
2419 : : {
2420 : 399448 : gimple_statement_omp_return *omp_return_stmt =
2421 : 399448 : as_a <gimple_statement_omp_return *> (g);
2422 : 399448 : return &omp_return_stmt->val;
2423 : : }
2424 : :
2425 : :
2426 : : /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2427 : : flag set. */
2428 : :
2429 : : inline bool
2430 : 0 : gimple_omp_section_last_p (const gimple *g)
2431 : : {
2432 : 0 : GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2433 : 0 : return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
2434 : : }
2435 : :
2436 : :
2437 : : /* Set the GF_OMP_SECTION_LAST flag on G. */
2438 : :
2439 : : inline void
2440 : 378 : gimple_omp_section_set_last (gimple *g)
2441 : : {
2442 : 378 : GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2443 : 378 : g->subcode |= GF_OMP_SECTION_LAST;
2444 : 378 : }
2445 : :
2446 : :
2447 : : /* Return true if OMP ordered construct is stand-alone
2448 : : (G has the GF_OMP_ORDERED_STANDALONE flag set). */
2449 : :
2450 : : inline bool
2451 : 5830 : gimple_omp_ordered_standalone_p (const gimple *g)
2452 : : {
2453 : 5830 : GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2454 : 5830 : return (gimple_omp_subcode (g) & GF_OMP_ORDERED_STANDALONE) != 0;
2455 : : }
2456 : :
2457 : :
2458 : : /* Set the GF_OMP_ORDERED_STANDALONE flag on G. */
2459 : :
2460 : : inline void
2461 : 1015 : gimple_omp_ordered_standalone (gimple *g)
2462 : : {
2463 : 1015 : GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2464 : 1015 : g->subcode |= GF_OMP_ORDERED_STANDALONE;
2465 : 1015 : }
2466 : :
2467 : :
2468 : : /* Return true if OMP parallel statement G has the
2469 : : GF_OMP_PARALLEL_COMBINED flag set. */
2470 : :
2471 : : inline bool
2472 : 35460 : gimple_omp_parallel_combined_p (const gimple *g)
2473 : : {
2474 : 35460 : GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2475 : 35460 : return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
2476 : : }
2477 : :
2478 : :
2479 : : /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2480 : : value of COMBINED_P. */
2481 : :
2482 : : inline void
2483 : 377 : gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
2484 : : {
2485 : 377 : GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2486 : 377 : if (combined_p)
2487 : 377 : g->subcode |= GF_OMP_PARALLEL_COMBINED;
2488 : : else
2489 : 0 : g->subcode &= ~GF_OMP_PARALLEL_COMBINED;
2490 : 377 : }
2491 : :
2492 : :
2493 : : /* Return true if OMP atomic load/store statement G has the
2494 : : GF_OMP_ATOMIC_NEED_VALUE flag set. */
2495 : :
2496 : : inline bool
2497 : 12731 : gimple_omp_atomic_need_value_p (const gimple *g)
2498 : : {
2499 : 12731 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2500 : 5935 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2501 : 12731 : return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0;
2502 : : }
2503 : :
2504 : :
2505 : : /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2506 : :
2507 : : inline void
2508 : 2933 : gimple_omp_atomic_set_need_value (gimple *g)
2509 : : {
2510 : 2933 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2511 : 868 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2512 : 2933 : g->subcode |= GF_OMP_ATOMIC_NEED_VALUE;
2513 : 2933 : }
2514 : :
2515 : :
2516 : : /* Return true if OMP atomic load/store statement G has the
2517 : : GF_OMP_ATOMIC_WEAK flag set. */
2518 : :
2519 : : inline bool
2520 : 1343 : gimple_omp_atomic_weak_p (const gimple *g)
2521 : : {
2522 : 1343 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2523 : 526 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2524 : 1343 : return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_WEAK) != 0;
2525 : : }
2526 : :
2527 : :
2528 : : /* Set the GF_OMP_ATOMIC_WEAK flag on G. */
2529 : :
2530 : : inline void
2531 : 74 : gimple_omp_atomic_set_weak (gimple *g)
2532 : : {
2533 : 74 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2534 : 37 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2535 : 74 : g->subcode |= GF_OMP_ATOMIC_WEAK;
2536 : 74 : }
2537 : :
2538 : :
2539 : : /* Return the memory order of the OMP atomic load/store statement G. */
2540 : :
2541 : : inline enum omp_memory_order
2542 : 10908 : gimple_omp_atomic_memory_order (const gimple *g)
2543 : : {
2544 : 10908 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2545 : 1387 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2546 : 10908 : return (enum omp_memory_order)
2547 : 10908 : (gimple_omp_subcode (g) & GF_OMP_ATOMIC_MEMORY_ORDER);
2548 : : }
2549 : :
2550 : :
2551 : : /* Set the memory order on G. */
2552 : :
2553 : : inline void
2554 : 20634 : gimple_omp_atomic_set_memory_order (gimple *g, enum omp_memory_order mo)
2555 : : {
2556 : 20634 : if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2557 : 10317 : GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2558 : 20634 : g->subcode = ((g->subcode & ~GF_OMP_ATOMIC_MEMORY_ORDER)
2559 : 20634 : | (mo & GF_OMP_ATOMIC_MEMORY_ORDER));
2560 : 20634 : }
2561 : :
2562 : :
2563 : : /* Return the number of operands for statement GS. */
2564 : :
2565 : : inline unsigned
2566 : >18506*10^7 : gimple_num_ops (const gimple *gs)
2567 : : {
2568 : 80043269627 : return gs->num_ops;
2569 : : }
2570 : :
2571 : :
2572 : : /* Set the number of operands for statement GS. */
2573 : :
2574 : : inline void
2575 : 311875913 : gimple_set_num_ops (gimple *gs, unsigned num_ops)
2576 : : {
2577 : 7135709 : gs->num_ops = num_ops;
2578 : : }
2579 : :
2580 : :
2581 : : /* Return the array of operands for statement GS. */
2582 : :
2583 : : inline tree *
2584 : 85125610566 : gimple_ops (gimple *gs)
2585 : : {
2586 : 85125610566 : size_t off;
2587 : :
2588 : : /* All the tuples have their operand vector at the very bottom
2589 : : of the structure. Note that those structures that do not
2590 : : have an operand vector have a zero offset. */
2591 : 85125610566 : off = gimple_ops_offset_[gimple_statement_structure (gs)];
2592 : 85125610566 : gcc_gimple_checking_assert (off != 0);
2593 : :
2594 : 85125610566 : return (tree *) ((char *) gs + off);
2595 : : }
2596 : :
2597 : :
2598 : : /* Return operand I for statement GS. */
2599 : :
2600 : : inline tree
2601 : 20854164746 : gimple_op (const gimple *gs, unsigned i)
2602 : : {
2603 : 20854164746 : if (gimple_has_ops (gs))
2604 : : {
2605 : 20854164746 : gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2606 : 20854164746 : return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
2607 : : }
2608 : : else
2609 : : return NULL_TREE;
2610 : : }
2611 : :
2612 : : /* Return a pointer to operand I for statement GS. */
2613 : :
2614 : : inline tree *
2615 : 63960120871 : gimple_op_ptr (gimple *gs, unsigned i)
2616 : : {
2617 : 63960120871 : if (gimple_has_ops (gs))
2618 : : {
2619 : 63960120871 : gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2620 : 63960120871 : return gimple_ops (gs) + i;
2621 : : }
2622 : : else
2623 : : return NULL;
2624 : : }
2625 : :
2626 : : /* Set operand I of statement GS to OP. */
2627 : :
2628 : : inline void
2629 : 311324949 : gimple_set_op (gimple *gs, unsigned i, tree op)
2630 : : {
2631 : 622649898 : gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
2632 : :
2633 : : /* Note. It may be tempting to assert that OP matches
2634 : : is_gimple_operand, but that would be wrong. Different tuples
2635 : : accept slightly different sets of tree operands. Each caller
2636 : : should perform its own validation. */
2637 : 311324949 : gimple_ops (gs)[i] = op;
2638 : 311324949 : }
2639 : :
2640 : : /* Return true if GS is a GIMPLE_ASSIGN. */
2641 : :
2642 : : inline bool
2643 : 22301638520 : is_gimple_assign (const gimple *gs)
2644 : : {
2645 : 14331388753 : return gimple_code (gs) == GIMPLE_ASSIGN;
2646 : : }
2647 : :
2648 : : /* Determine if expression CODE is one of the valid expressions that can
2649 : : be used on the RHS of GIMPLE assignments. */
2650 : :
2651 : : inline enum gimple_rhs_class
2652 : 75968495607 : get_gimple_rhs_class (enum tree_code code)
2653 : : {
2654 : 69338805425 : return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
2655 : : }
2656 : :
2657 : : /* Return the LHS of assignment statement GS. */
2658 : :
2659 : : inline tree
2660 : 25094579515 : gimple_assign_lhs (const gassign *gs)
2661 : : {
2662 : 20312505731 : return gs->op[0];
2663 : : }
2664 : :
2665 : : inline tree
2666 : 18252568503 : gimple_assign_lhs (const gimple *gs)
2667 : : {
2668 : 18252568503 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2669 : 18252568503 : return gimple_assign_lhs (ass);
2670 : : }
2671 : :
2672 : :
2673 : : /* Return a pointer to the LHS of assignment statement GS. */
2674 : :
2675 : : inline tree *
2676 : 188136806 : gimple_assign_lhs_ptr (gassign *gs)
2677 : : {
2678 : 188136806 : return &gs->op[0];
2679 : : }
2680 : :
2681 : : inline tree *
2682 : 188136806 : gimple_assign_lhs_ptr (gimple *gs)
2683 : : {
2684 : 188136806 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2685 : 188136806 : return gimple_assign_lhs_ptr (ass);
2686 : : }
2687 : :
2688 : :
2689 : : /* Set LHS to be the LHS operand of assignment statement GS. */
2690 : :
2691 : : inline void
2692 : 97017456 : gimple_assign_set_lhs (gassign *gs, tree lhs)
2693 : : {
2694 : 97017456 : gs->op[0] = lhs;
2695 : :
2696 : 97017456 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
2697 : 44908750 : SSA_NAME_DEF_STMT (lhs) = gs;
2698 : : }
2699 : :
2700 : : inline void
2701 : 3935154 : gimple_assign_set_lhs (gimple *gs, tree lhs)
2702 : : {
2703 : 3935154 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2704 : 3935154 : gimple_assign_set_lhs (ass, lhs);
2705 : 3935154 : }
2706 : :
2707 : :
2708 : : /* Return the first operand on the RHS of assignment statement GS. */
2709 : :
2710 : : inline tree
2711 : 25397658700 : gimple_assign_rhs1 (const gassign *gs)
2712 : : {
2713 : 23056933546 : return gs->op[1];
2714 : : }
2715 : :
2716 : : inline tree
2717 : 20055849508 : gimple_assign_rhs1 (const gimple *gs)
2718 : : {
2719 : 20055849508 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2720 : 20055849508 : return gimple_assign_rhs1 (ass);
2721 : : }
2722 : :
2723 : :
2724 : : /* Return a pointer to the first operand on the RHS of assignment
2725 : : statement GS. */
2726 : :
2727 : : inline tree *
2728 : 201909388 : gimple_assign_rhs1_ptr (gassign *gs)
2729 : : {
2730 : 201909388 : return &gs->op[1];
2731 : : }
2732 : :
2733 : : inline tree *
2734 : 201722357 : gimple_assign_rhs1_ptr (gimple *gs)
2735 : : {
2736 : 201722357 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2737 : 201722357 : return gimple_assign_rhs1_ptr (ass);
2738 : : }
2739 : :
2740 : : /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2741 : :
2742 : : inline void
2743 : 104346557 : gimple_assign_set_rhs1 (gassign *gs, tree rhs)
2744 : : {
2745 : 93301863 : gs->op[1] = rhs;
2746 : 130 : }
2747 : :
2748 : : inline void
2749 : 11299856 : gimple_assign_set_rhs1 (gimple *gs, tree rhs)
2750 : : {
2751 : 11299856 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2752 : 11299856 : gimple_assign_set_rhs1 (ass, rhs);
2753 : 11299856 : }
2754 : :
2755 : :
2756 : : /* Return the second operand on the RHS of assignment statement GS.
2757 : : If GS does not have two operands, NULL is returned instead. */
2758 : :
2759 : : inline tree
2760 : 4011303651 : gimple_assign_rhs2 (const gassign *gs)
2761 : : {
2762 : 3631856572 : if (gimple_num_ops (gs) >= 3)
2763 : 2477977187 : return gs->op[2];
2764 : : else
2765 : : return NULL_TREE;
2766 : : }
2767 : :
2768 : : inline tree
2769 : 1155596503 : gimple_assign_rhs2 (const gimple *gs)
2770 : : {
2771 : 1155596503 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2772 : 1155596503 : return gimple_assign_rhs2 (ass);
2773 : : }
2774 : :
2775 : :
2776 : : /* Return a pointer to the second operand on the RHS of assignment
2777 : : statement GS. */
2778 : :
2779 : : inline tree *
2780 : 739868 : gimple_assign_rhs2_ptr (gassign *gs)
2781 : : {
2782 : 739868 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2783 : 739868 : return &gs->op[2];
2784 : : }
2785 : :
2786 : : inline tree *
2787 : 739482 : gimple_assign_rhs2_ptr (gimple *gs)
2788 : : {
2789 : 739482 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2790 : 739482 : return gimple_assign_rhs2_ptr (ass);
2791 : : }
2792 : :
2793 : :
2794 : : /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2795 : :
2796 : : inline void
2797 : 21092819 : gimple_assign_set_rhs2 (gassign *gs, tree rhs)
2798 : : {
2799 : 21092819 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2800 : 21092819 : gs->op[2] = rhs;
2801 : 21092819 : }
2802 : :
2803 : : inline void
2804 : 5127665 : gimple_assign_set_rhs2 (gimple *gs, tree rhs)
2805 : : {
2806 : 5127665 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2807 : 5127665 : return gimple_assign_set_rhs2 (ass, rhs);
2808 : : }
2809 : :
2810 : : /* Return the third operand on the RHS of assignment statement GS.
2811 : : If GS does not have two operands, NULL is returned instead. */
2812 : :
2813 : : inline tree
2814 : 18608670 : gimple_assign_rhs3 (const gassign *gs)
2815 : : {
2816 : 13423025 : if (gimple_num_ops (gs) >= 4)
2817 : 13630493 : return gs->op[3];
2818 : : else
2819 : : return NULL_TREE;
2820 : : }
2821 : :
2822 : : inline tree
2823 : 7631305 : gimple_assign_rhs3 (const gimple *gs)
2824 : : {
2825 : 7631305 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2826 : 7631305 : return gimple_assign_rhs3 (ass);
2827 : : }
2828 : :
2829 : : /* Return a pointer to the third operand on the RHS of assignment
2830 : : statement GS. */
2831 : :
2832 : : inline tree *
2833 : 379 : gimple_assign_rhs3_ptr (gimple *gs)
2834 : : {
2835 : 379 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2836 : 379 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2837 : 379 : return &ass->op[3];
2838 : : }
2839 : :
2840 : :
2841 : : /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2842 : :
2843 : : inline void
2844 : 455358 : gimple_assign_set_rhs3 (gassign *gs, tree rhs)
2845 : : {
2846 : 455358 : gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2847 : 455358 : gs->op[3] = rhs;
2848 : 455358 : }
2849 : :
2850 : : inline void
2851 : 33050 : gimple_assign_set_rhs3 (gimple *gs, tree rhs)
2852 : : {
2853 : 33050 : gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2854 : 33050 : gimple_assign_set_rhs3 (ass, rhs);
2855 : 33050 : }
2856 : :
2857 : :
2858 : : /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2859 : : which expect to see only two operands. */
2860 : :
2861 : : inline void
2862 : 311422 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2863 : : tree op1, tree op2)
2864 : : {
2865 : 311422 : gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
2866 : 1483 : }
2867 : :
2868 : : /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2869 : : which expect to see only one operands. */
2870 : :
2871 : : inline void
2872 : 66423 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2873 : : tree op1)
2874 : : {
2875 : 66423 : gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
2876 : 55063 : }
2877 : :
2878 : : /* Returns true if GS is a nontemporal move. */
2879 : :
2880 : : inline bool
2881 : 4537929915 : gimple_assign_nontemporal_move_p (const gassign *gs)
2882 : : {
2883 : 4537929915 : return gs->nontemporal_move;
2884 : : }
2885 : :
2886 : : /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2887 : :
2888 : : inline void
2889 : 2 : gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
2890 : : {
2891 : 2 : GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
2892 : 2 : gs->nontemporal_move = nontemporal;
2893 : 2 : }
2894 : :
2895 : :
2896 : : /* Return the code of the expression computed on the rhs of assignment
2897 : : statement GS. In case that the RHS is a single object, returns the
2898 : : tree code of the object. */
2899 : :
2900 : : inline enum tree_code
2901 : 44891099306 : gimple_assign_rhs_code (const gassign *gs)
2902 : : {
2903 : 44976165013 : enum tree_code code = (enum tree_code) gs->subcode;
2904 : : /* While we initially set subcode to the TREE_CODE of the rhs for
2905 : : GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2906 : : in sync when we rewrite stmts into SSA form or do SSA propagations. */
2907 : 35506185117 : if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
2908 : 28537030149 : code = TREE_CODE (gs->op[1]);
2909 : :
2910 : 35392756953 : return code;
2911 : : }
2912 : :
2913 : : inline enum tree_code
2914 : 33650253934 : gimple_assign_rhs_code (const gimple *gs)
2915 : : {
2916 : 33650253934 : const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2917 : 33650253934 : return gimple_assign_rhs_code (ass);
2918 : : }
2919 : :
2920 : :
2921 : : /* Set CODE to be the code for the expression computed on the RHS of
2922 : : assignment S. */
2923 : :
2924 : : inline void
2925 : 2230309 : gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
2926 : : {
2927 : 2230309 : GIMPLE_CHECK (s, GIMPLE_ASSIGN);
2928 : 2230309 : s->subcode = code;
2929 : 2230309 : }
2930 : :
2931 : :
2932 : : /* Return the gimple rhs class of the code of the expression computed on
2933 : : the rhs of assignment statement GS.
2934 : : This will never return GIMPLE_INVALID_RHS. */
2935 : :
2936 : : inline enum gimple_rhs_class
2937 : 28688329403 : gimple_assign_rhs_class (const gimple *gs)
2938 : : {
2939 : 28680583161 : return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
2940 : : }
2941 : :
2942 : : /* Return true if GS is an assignment with a singleton RHS, i.e.,
2943 : : there is no operator associated with the assignment itself.
2944 : : Unlike gimple_assign_copy_p, this predicate returns true for
2945 : : any RHS operand, including those that perform an operation
2946 : : and do not have the semantics of a copy, such as COND_EXPR. */
2947 : :
2948 : : inline bool
2949 : 16049866439 : gimple_assign_single_p (const gimple *gs)
2950 : : {
2951 : 16049866439 : return (is_gimple_assign (gs)
2952 : 27881027870 : && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
2953 : : }
2954 : :
2955 : : /* Return true if GS performs a store to its lhs. */
2956 : :
2957 : : inline bool
2958 : 1102431441 : gimple_store_p (const gimple *gs)
2959 : : {
2960 : 1102431441 : tree lhs = gimple_get_lhs (gs);
2961 : 1102431441 : return lhs && !is_gimple_reg (lhs);
2962 : : }
2963 : :
2964 : : /* Return true if S is a type-cast assignment. */
2965 : :
2966 : : inline bool
2967 : 26725644 : gimple_assign_cast_p (const gimple *s)
2968 : : {
2969 : 26725644 : if (is_gimple_assign (s))
2970 : : {
2971 : 14953588 : enum tree_code sc = gimple_assign_rhs_code (s);
2972 : 14953588 : return CONVERT_EXPR_CODE_P (sc)
2973 : 12726326 : || sc == VIEW_CONVERT_EXPR
2974 : 14953588 : || sc == FIX_TRUNC_EXPR;
2975 : : }
2976 : :
2977 : : return false;
2978 : : }
2979 : :
2980 : : /* Return true if S is a clobber statement. */
2981 : :
2982 : : inline bool
2983 : 8030051788 : gimple_clobber_p (const gimple *s)
2984 : : {
2985 : 8030051788 : return gimple_assign_single_p (s)
2986 : 8030051788 : && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
2987 : : }
2988 : :
2989 : : /* Return true if S is a clobber statement. */
2990 : :
2991 : : inline bool
2992 : 89503545 : gimple_clobber_p (const gimple *s, enum clobber_kind kind)
2993 : : {
2994 : 89503545 : return gimple_clobber_p (s)
2995 : 89503545 : && CLOBBER_KIND (gimple_assign_rhs1 (s)) == kind;
2996 : : }
2997 : :
2998 : : /* Return true if GS is a GIMPLE_CALL. */
2999 : :
3000 : : inline bool
3001 : 18296426631 : is_gimple_call (const gimple *gs)
3002 : : {
3003 : 20737695417 : return gimple_code (gs) == GIMPLE_CALL;
3004 : : }
3005 : :
3006 : : /* Return the LHS of call statement GS. */
3007 : :
3008 : : inline tree
3009 : 5624013653 : gimple_call_lhs (const gcall *gs)
3010 : : {
3011 : 1656934787 : return gs->op[0];
3012 : : }
3013 : :
3014 : : inline tree
3015 : 4121364116 : gimple_call_lhs (const gimple *gs)
3016 : : {
3017 : 4121364116 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3018 : 4121364116 : return gimple_call_lhs (gc);
3019 : : }
3020 : :
3021 : :
3022 : : /* Return a pointer to the LHS of call statement GS. */
3023 : :
3024 : : inline tree *
3025 : 832704803 : gimple_call_lhs_ptr (gcall *gs)
3026 : : {
3027 : 832704803 : return &gs->op[0];
3028 : : }
3029 : :
3030 : : inline tree *
3031 : 775511084 : gimple_call_lhs_ptr (gimple *gs)
3032 : : {
3033 : 775511084 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3034 : 775511084 : return gimple_call_lhs_ptr (gc);
3035 : : }
3036 : :
3037 : :
3038 : : /* Set LHS to be the LHS operand of call statement GS. */
3039 : :
3040 : : inline void
3041 : 6416406 : gimple_call_set_lhs (gcall *gs, tree lhs)
3042 : : {
3043 : 6416406 : gs->op[0] = lhs;
3044 : 6339080 : if (lhs && TREE_CODE (lhs) == SSA_NAME)
3045 : 2764591 : SSA_NAME_DEF_STMT (lhs) = gs;
3046 : 3 : }
3047 : :
3048 : : inline void
3049 : 1323505 : gimple_call_set_lhs (gimple *gs, tree lhs)
3050 : : {
3051 : 1323505 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3052 : 1323505 : gimple_call_set_lhs (gc, lhs);
3053 : 1323505 : }
3054 : :
3055 : :
3056 : : /* Return true if call GS calls an internal-only function, as enumerated
3057 : : by internal_fn. */
3058 : :
3059 : : inline bool
3060 : 13312420398 : gimple_call_internal_p (const gcall *gs)
3061 : : {
3062 : 3814806126 : return (gs->subcode & GF_CALL_INTERNAL) != 0;
3063 : : }
3064 : :
3065 : : inline bool
3066 : 5831399410 : gimple_call_internal_p (const gimple *gs)
3067 : : {
3068 : 5831399410 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3069 : 5831399410 : return gimple_call_internal_p (gc);
3070 : : }
3071 : :
3072 : : /* Return true if call GS is marked as nocf_check. */
3073 : :
3074 : : inline bool
3075 : 8240982 : gimple_call_nocf_check_p (const gcall *gs)
3076 : : {
3077 : 8240982 : return (gs->subcode & GF_CALL_NOCF_CHECK) != 0;
3078 : : }
3079 : :
3080 : : /* Mark statement GS as nocf_check call. */
3081 : :
3082 : : inline void
3083 : 21 : gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
3084 : : {
3085 : 21 : if (nocf_check)
3086 : 21 : gs->subcode |= GF_CALL_NOCF_CHECK;
3087 : : else
3088 : : gs->subcode &= ~GF_CALL_NOCF_CHECK;
3089 : 21 : }
3090 : :
3091 : : /* Return the target of internal call GS. */
3092 : :
3093 : : inline enum internal_fn
3094 : 151992746 : gimple_call_internal_fn (const gcall *gs)
3095 : : {
3096 : 151992746 : gcc_gimple_checking_assert (gimple_call_internal_p (gs));
3097 : 151992746 : return gs->u.internal_fn;
3098 : : }
3099 : :
3100 : : inline enum internal_fn
3101 : 130730511 : gimple_call_internal_fn (const gimple *gs)
3102 : : {
3103 : 130730511 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3104 : 130730511 : return gimple_call_internal_fn (gc);
3105 : : }
3106 : :
3107 : : /* Return true, if this internal gimple call is unique. */
3108 : :
3109 : : inline bool
3110 : 852628 : gimple_call_internal_unique_p (const gcall *gs)
3111 : : {
3112 : 1704783 : return gimple_call_internal_fn (gs) == IFN_UNIQUE;
3113 : : }
3114 : :
3115 : : inline bool
3116 : 852155 : gimple_call_internal_unique_p (const gimple *gs)
3117 : : {
3118 : 852155 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3119 : 852155 : return gimple_call_internal_unique_p (gc);
3120 : : }
3121 : :
3122 : : /* Return true if GS is an internal function FN. */
3123 : :
3124 : : inline bool
3125 : 3200566613 : gimple_call_internal_p (const gimple *gs, internal_fn fn)
3126 : : {
3127 : 3200566613 : return (is_gimple_call (gs)
3128 : 1379719662 : && gimple_call_internal_p (gs)
3129 : 3242582161 : && gimple_call_internal_fn (gs) == fn);
3130 : : }
3131 : :
3132 : : /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
3133 : : that could alter control flow. */
3134 : :
3135 : : inline void
3136 : 33088260 : gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
3137 : : {
3138 : 33088260 : if (ctrl_altering_p)
3139 : 23977386 : s->subcode |= GF_CALL_CTRL_ALTERING;
3140 : : else
3141 : 9110874 : s->subcode &= ~GF_CALL_CTRL_ALTERING;
3142 : : }
3143 : :
3144 : : inline void
3145 : 32843970 : gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
3146 : : {
3147 : 32843970 : gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3148 : 32843970 : gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
3149 : 32843970 : }
3150 : :
3151 : : /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
3152 : : flag is set. Such call could not be a stmt in the middle of a bb. */
3153 : :
3154 : : inline bool
3155 : 2210615425 : gimple_call_ctrl_altering_p (const gcall *gs)
3156 : : {
3157 : 1144786189 : return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
3158 : : }
3159 : :
3160 : : inline bool
3161 : 1139098360 : gimple_call_ctrl_altering_p (const gimple *gs)
3162 : : {
3163 : 1139098360 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3164 : 1139098360 : return gimple_call_ctrl_altering_p (gc);
3165 : : }
3166 : :
3167 : :
3168 : : /* Return the function type of the function called by GS. */
3169 : :
3170 : : inline tree
3171 : 5608303581 : gimple_call_fntype (const gcall *gs)
3172 : : {
3173 : 1163554291 : if (gimple_call_internal_p (gs))
3174 : : return NULL_TREE;
3175 : 5561947378 : return gs->u.fntype;
3176 : : }
3177 : :
3178 : : inline tree
3179 : 4100653680 : gimple_call_fntype (const gimple *gs)
3180 : : {
3181 : 4100653680 : const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
3182 : 4100653680 : return gimple_call_fntype (call_stmt);
3183 : : }
3184 : :
3185 : : /* Set the type of the function called by CALL_STMT to FNTYPE. */
3186 : :
3187 : : inline void
3188 : 23030251 : gimple_call_set_fntype (gcall *call_stmt, tree fntype)
3189 : : {
3190 : 23030251 : gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt));
3191 : 23030251 : call_stmt->u.fntype = fntype;
3192 : 23030251 : }
3193 : :
3194 : :
3195 : : /* Return the tree node representing the function called by call
3196 : : statement GS. */
3197 : :
3198 : : inline tree
3199 : 9840693266 : gimple_call_fn (const gcall *gs)
3200 : : {
3201 : 2155406926 : return gs->op[1];
3202 : : }
3203 : :
3204 : : inline tree
3205 : 86241436 : gimple_call_fn (const gimple *gs)
3206 : : {
3207 : 86241436 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3208 : 86241436 : return gimple_call_fn (gc);
3209 : : }
3210 : :
3211 : : /* Return a pointer to the tree node representing the function called by call
3212 : : statement GS. */
3213 : :
3214 : : inline tree *
3215 : 1960214567 : gimple_call_fn_ptr (gcall *gs)
3216 : : {
3217 : 1960214567 : return &gs->op[1];
3218 : : }
3219 : :
3220 : : inline tree *
3221 : 1960214567 : gimple_call_fn_ptr (gimple *gs)
3222 : : {
3223 : 1960214567 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3224 : 1960214567 : return gimple_call_fn_ptr (gc);
3225 : : }
3226 : :
3227 : :
3228 : : /* Set FN to be the function called by call statement GS. */
3229 : :
3230 : : inline void
3231 : 3620 : gimple_call_set_fn (gcall *gs, tree fn)
3232 : : {
3233 : 3620 : gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3234 : 3620 : gs->op[1] = fn;
3235 : 3620 : }
3236 : :
3237 : :
3238 : : /* Set FNDECL to be the function called by call statement GS. */
3239 : :
3240 : : inline void
3241 : 589994 : gimple_call_set_fndecl (gcall *gs, tree decl)
3242 : : {
3243 : 589994 : gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3244 : 589994 : gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
3245 : 589994 : build_pointer_type (TREE_TYPE (decl)), decl);
3246 : 589994 : }
3247 : :
3248 : : inline void
3249 : 33610 : gimple_call_set_fndecl (gimple *gs, tree decl)
3250 : : {
3251 : 33610 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3252 : 33610 : gimple_call_set_fndecl (gc, decl);
3253 : 33610 : }
3254 : :
3255 : :
3256 : : /* Set internal function FN to be the function called by call statement CALL_STMT. */
3257 : :
3258 : : inline void
3259 : 648920 : gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
3260 : : {
3261 : 648920 : gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt));
3262 : 648920 : call_stmt->u.internal_fn = fn;
3263 : 648920 : }
3264 : :
3265 : :
3266 : : /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
3267 : : Otherwise return NULL. This function is analogous to
3268 : : get_callee_fndecl in tree land. */
3269 : :
3270 : : inline tree
3271 : 8597835116 : gimple_call_fndecl (const gcall *gs)
3272 : : {
3273 : 2558410141 : return gimple_call_addr_fndecl (gimple_call_fn (gs));
3274 : : }
3275 : :
3276 : : inline tree
3277 : 6318195569 : gimple_call_fndecl (const gimple *gs)
3278 : : {
3279 : 6318195569 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3280 : 6318195569 : return gimple_call_fndecl (gc);
3281 : : }
3282 : :
3283 : :
3284 : : /* Return the type returned by call statement GS. */
3285 : :
3286 : : inline tree
3287 : 12499140 : gimple_call_return_type (const gcall *gs)
3288 : : {
3289 : 12499140 : tree type = gimple_call_fntype (gs);
3290 : :
3291 : 12497475 : if (type == NULL_TREE)
3292 : 1665 : return TREE_TYPE (gimple_call_lhs (gs));
3293 : :
3294 : : /* The type returned by a function is the type of its
3295 : : function type. */
3296 : 12497475 : return TREE_TYPE (type);
3297 : : }
3298 : :
3299 : :
3300 : : /* Return the static chain for call statement GS. */
3301 : :
3302 : : inline tree
3303 : 2309400245 : gimple_call_chain (const gcall *gs)
3304 : : {
3305 : 1276030477 : return gs->op[2];
3306 : : }
3307 : :
3308 : : inline tree
3309 : 16712461 : gimple_call_chain (const gimple *gs)
3310 : : {
3311 : 16712461 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3312 : 16712461 : return gimple_call_chain (gc);
3313 : : }
3314 : :
3315 : :
3316 : : /* Return a pointer to the static chain for call statement CALL_STMT. */
3317 : :
3318 : : inline tree *
3319 : 1960243270 : gimple_call_chain_ptr (gcall *call_stmt)
3320 : : {
3321 : 1960243270 : return &call_stmt->op[2];
3322 : : }
3323 : :
3324 : : /* Set CHAIN to be the static chain for call statement CALL_STMT. */
3325 : :
3326 : : inline void
3327 : 10938955 : gimple_call_set_chain (gcall *call_stmt, tree chain)
3328 : : {
3329 : 10938955 : call_stmt->op[2] = chain;
3330 : 0 : }
3331 : :
3332 : :
3333 : : /* Return the number of arguments used by call statement GS. */
3334 : :
3335 : : inline unsigned
3336 : 11403606255 : gimple_call_num_args (const gcall *gs)
3337 : : {
3338 : 4758436016 : return gimple_num_ops (gs) - 3;
3339 : : }
3340 : :
3341 : : inline unsigned
3342 : 6961365010 : gimple_call_num_args (const gimple *gs)
3343 : : {
3344 : 6961365010 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3345 : 6961365010 : return gimple_call_num_args (gc);
3346 : : }
3347 : :
3348 : :
3349 : : /* Return the argument at position INDEX for call statement GS. */
3350 : :
3351 : : inline tree
3352 : 8051382708 : gimple_call_arg (const gcall *gs, unsigned index)
3353 : : {
3354 : 8046963953 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3355 : 5548794128 : return gs->op[index + 3];
3356 : : }
3357 : :
3358 : : inline tree
3359 : 5125122563 : gimple_call_arg (const gimple *gs, unsigned index)
3360 : : {
3361 : 5125122563 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3362 : 5125122563 : return gimple_call_arg (gc, index);
3363 : : }
3364 : :
3365 : :
3366 : : /* Return a pointer to the argument at position INDEX for call
3367 : : statement GS. */
3368 : :
3369 : : inline tree *
3370 : 4050963847 : gimple_call_arg_ptr (gcall *gs, unsigned index)
3371 : : {
3372 : 4050963847 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3373 : 4050957383 : return &gs->op[index + 3];
3374 : : }
3375 : :
3376 : : inline tree *
3377 : 3923837512 : gimple_call_arg_ptr (gimple *gs, unsigned index)
3378 : : {
3379 : 3923837512 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3380 : 3923837512 : return gimple_call_arg_ptr (gc, index);
3381 : : }
3382 : :
3383 : :
3384 : : /* Set ARG to be the argument at position INDEX for call statement GS. */
3385 : :
3386 : : inline void
3387 : 23255518 : gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
3388 : : {
3389 : 23186593 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3390 : 23094672 : gs->op[index + 3] = arg;
3391 : 23219914 : }
3392 : :
3393 : : inline void
3394 : 518069 : gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
3395 : : {
3396 : 518069 : gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3397 : 518069 : gimple_call_set_arg (gc, index, arg);
3398 : 518069 : }
3399 : :
3400 : :
3401 : : /* If TAIL_P is true, mark call statement S as being a tail call
3402 : : (i.e., a call just before the exit of a function). These calls are
3403 : : candidate for tail call optimization. */
3404 : :
3405 : : inline void
3406 : 10664149 : gimple_call_set_tail (gcall *s, bool tail_p)
3407 : : {
3408 : 10664149 : if (tail_p)
3409 : 192996 : s->subcode |= GF_CALL_TAILCALL;
3410 : : else
3411 : 10471153 : s->subcode &= ~GF_CALL_TAILCALL;
3412 : 82 : }
3413 : :
3414 : :
3415 : : /* Return true if GIMPLE_CALL S is marked as a tail call. */
3416 : :
3417 : : inline bool
3418 : 23506207 : gimple_call_tail_p (const gcall *s)
3419 : : {
3420 : 23506207 : return (s->subcode & GF_CALL_TAILCALL) != 0;
3421 : : }
3422 : :
3423 : : /* Mark (or clear) call statement S as requiring tail call optimization. */
3424 : :
3425 : : inline void
3426 : 10470383 : gimple_call_set_must_tail (gcall *s, bool must_tail_p)
3427 : : {
3428 : 10470383 : if (must_tail_p)
3429 : 797 : s->subcode |= GF_CALL_MUST_TAIL_CALL;
3430 : : else
3431 : 10469586 : s->subcode &= ~GF_CALL_MUST_TAIL_CALL;
3432 : 18 : }
3433 : :
3434 : : /* Return true if call statement has been marked as requiring
3435 : : tail call optimization. */
3436 : :
3437 : : inline bool
3438 : 69409349 : gimple_call_must_tail_p (const gcall *s)
3439 : : {
3440 : 69409341 : return (s->subcode & GF_CALL_MUST_TAIL_CALL) != 0;
3441 : : }
3442 : :
3443 : : /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
3444 : : slot optimization. This transformation uses the target of the call
3445 : : expansion as the return slot for calls that return in memory. */
3446 : :
3447 : : inline void
3448 : 10477990 : gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
3449 : : {
3450 : 10477990 : if (return_slot_opt_p)
3451 : 325449 : s->subcode |= GF_CALL_RETURN_SLOT_OPT;
3452 : : else
3453 : 10152541 : s->subcode &= ~GF_CALL_RETURN_SLOT_OPT;
3454 : 383 : }
3455 : :
3456 : :
3457 : : /* Return true if S is marked for return slot optimization. */
3458 : :
3459 : : inline bool
3460 : 144989762 : gimple_call_return_slot_opt_p (const gcall *s)
3461 : : {
3462 : 144989762 : return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
3463 : : }
3464 : :
3465 : :
3466 : : /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
3467 : : thunk to the thunked-to function. */
3468 : :
3469 : : inline void
3470 : 10325821 : gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
3471 : : {
3472 : 10325821 : if (from_thunk_p)
3473 : 20409 : s->subcode |= GF_CALL_FROM_THUNK;
3474 : : else
3475 : 10305412 : s->subcode &= ~GF_CALL_FROM_THUNK;
3476 : 122 : }
3477 : :
3478 : :
3479 : : /* Return true if GIMPLE_CALL S is a jump from a thunk. */
3480 : :
3481 : : inline bool
3482 : 33745966 : gimple_call_from_thunk_p (gcall *s)
3483 : : {
3484 : 33745966 : return (s->subcode & GF_CALL_FROM_THUNK) != 0;
3485 : : }
3486 : :
3487 : :
3488 : : /* If FROM_NEW_OR_DELETE_P is true, mark GIMPLE_CALL S as being a call
3489 : : to operator new or delete created from a new or delete expression. */
3490 : :
3491 : : inline void
3492 : 125820 : gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
3493 : : {
3494 : 125820 : if (from_new_or_delete_p)
3495 : 119485 : s->subcode |= GF_CALL_FROM_NEW_OR_DELETE;
3496 : : else
3497 : 6335 : s->subcode &= ~GF_CALL_FROM_NEW_OR_DELETE;
3498 : : }
3499 : :
3500 : :
3501 : : /* Return true if GIMPLE_CALL S is a call to operator new or delete from
3502 : : from a new or delete expression. */
3503 : :
3504 : : inline bool
3505 : 115039275 : gimple_call_from_new_or_delete (const gcall *s)
3506 : : {
3507 : 115039275 : return (s->subcode & GF_CALL_FROM_NEW_OR_DELETE) != 0;
3508 : : }
3509 : :
3510 : :
3511 : : /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
3512 : : argument pack in its argument list. */
3513 : :
3514 : : inline void
3515 : 10470631 : gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
3516 : : {
3517 : 10470631 : if (pass_arg_pack_p)
3518 : 130 : s->subcode |= GF_CALL_VA_ARG_PACK;
3519 : : else
3520 : 10470501 : s->subcode &= ~GF_CALL_VA_ARG_PACK;
3521 : : }
3522 : :
3523 : :
3524 : : /* Return true if GIMPLE_CALL S is a stdarg call that needs the
3525 : : argument pack in its argument list. */
3526 : :
3527 : : inline bool
3528 : 21556200 : gimple_call_va_arg_pack_p (const gcall *s)
3529 : : {
3530 : 21556200 : return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
3531 : : }
3532 : :
3533 : :
3534 : : /* Return true if S is a noreturn call. */
3535 : :
3536 : : inline bool
3537 : 345467026 : gimple_call_noreturn_p (const gcall *s)
3538 : : {
3539 : 477856956 : return (gimple_call_flags (s) & ECF_NORETURN) != 0;
3540 : : }
3541 : :
3542 : : inline bool
3543 : 195279820 : gimple_call_noreturn_p (const gimple *s)
3544 : : {
3545 : 195279820 : const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
3546 : 195279820 : return gimple_call_noreturn_p (gc);
3547 : : }
3548 : :
3549 : :
3550 : : /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
3551 : : even if the called function can throw in other cases. */
3552 : :
3553 : : inline void
3554 : 10718884 : gimple_call_set_nothrow (gcall *s, bool nothrow_p)
3555 : : {
3556 : 10705442 : if (nothrow_p)
3557 : 2935391 : s->subcode |= GF_CALL_NOTHROW;
3558 : : else
3559 : 7781439 : s->subcode &= ~GF_CALL_NOTHROW;
3560 : 252 : }
3561 : :
3562 : : /* Return true if S is a nothrow call. */
3563 : :
3564 : : inline bool
3565 : 1035929815 : gimple_call_nothrow_p (const gcall *s)
3566 : : {
3567 : 1035929815 : return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
3568 : : }
3569 : :
3570 : : /* If EXPECTED_THROW_P is true, GIMPLE_CALL S is a call that is known
3571 : : to be more likely to throw than to run forever, terminate the
3572 : : program or return by other means. */
3573 : :
3574 : : static inline void
3575 : 10309472 : gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
3576 : : {
3577 : 10309472 : if (expected_throw_p)
3578 : 22559 : s->subcode |= GF_CALL_XTHROW;
3579 : : else
3580 : 10286913 : s->subcode &= ~GF_CALL_XTHROW;
3581 : : }
3582 : :
3583 : : /* Return true if S is a call that is more likely to end by
3584 : : propagating an exception than by other means. */
3585 : :
3586 : : static inline bool
3587 : 323 : gimple_call_expected_throw_p (gcall *s)
3588 : : {
3589 : 323 : return (gimple_call_flags (s) & ECF_XTHROW) != 0;
3590 : : }
3591 : :
3592 : : /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
3593 : : is known to be emitted for VLA objects. Those are wrapped by
3594 : : stack_save/stack_restore calls and hence can't lead to unbounded
3595 : : stack growth even when they occur in loops. */
3596 : :
3597 : : inline void
3598 : 38774 : gimple_call_set_alloca_for_var (gcall *s, bool for_var)
3599 : : {
3600 : 38774 : if (for_var)
3601 : 9912 : s->subcode |= GF_CALL_ALLOCA_FOR_VAR;
3602 : : else
3603 : 28862 : s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR;
3604 : : }
3605 : :
3606 : : /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3607 : :
3608 : : inline bool
3609 : 322984 : gimple_call_alloca_for_var_p (gcall *s)
3610 : : {
3611 : 322984 : return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3612 : : }
3613 : :
3614 : : inline bool
3615 : 303201 : gimple_call_alloca_for_var_p (gimple *s)
3616 : : {
3617 : 303201 : const gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3618 : 303201 : return (gc->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3619 : : }
3620 : :
3621 : : /* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
3622 : : pointers to nested function are descriptors instead of trampolines. */
3623 : :
3624 : : inline void
3625 : 10470326 : gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
3626 : : {
3627 : 10470326 : if (by_descriptor_p)
3628 : 0 : s->subcode |= GF_CALL_BY_DESCRIPTOR;
3629 : : else
3630 : 10470326 : s->subcode &= ~GF_CALL_BY_DESCRIPTOR;
3631 : : }
3632 : :
3633 : : /* Return true if S is a by-descriptor call. */
3634 : :
3635 : : inline bool
3636 : 6537474 : gimple_call_by_descriptor_p (gcall *s)
3637 : : {
3638 : 6537474 : return (s->subcode & GF_CALL_BY_DESCRIPTOR) != 0;
3639 : : }
3640 : :
3641 : : /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3642 : :
3643 : : inline void
3644 : 450601 : gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
3645 : : {
3646 : 450601 : dest_call->subcode = orig_call->subcode;
3647 : : }
3648 : :
3649 : :
3650 : : /* Return a pointer to the points-to solution for the set of call-used
3651 : : variables of the call CALL_STMT. */
3652 : :
3653 : : inline struct pt_solution *
3654 : 51710591 : gimple_call_use_set (gcall *call_stmt)
3655 : : {
3656 : 51710591 : return &call_stmt->call_used;
3657 : : }
3658 : :
3659 : : /* As above, but const. */
3660 : :
3661 : : inline const pt_solution *
3662 : 492 : gimple_call_use_set (const gcall *call_stmt)
3663 : : {
3664 : 492 : return &call_stmt->call_used;
3665 : : }
3666 : :
3667 : : /* Return a pointer to the points-to solution for the set of call-used
3668 : : variables of the call CALL_STMT. */
3669 : :
3670 : : inline struct pt_solution *
3671 : 125745191 : gimple_call_clobber_set (gcall *call_stmt)
3672 : : {
3673 : 125745191 : return &call_stmt->call_clobbered;
3674 : : }
3675 : :
3676 : : /* As above, but const. */
3677 : :
3678 : : inline const pt_solution *
3679 : 492 : gimple_call_clobber_set (const gcall *call_stmt)
3680 : : {
3681 : 492 : return &call_stmt->call_clobbered;
3682 : : }
3683 : :
3684 : :
3685 : : /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
3686 : : non-NULL lhs. */
3687 : :
3688 : : inline bool
3689 : 605115129 : gimple_has_lhs (const gimple *stmt)
3690 : : {
3691 : 604680662 : if (is_gimple_assign (stmt))
3692 : : return true;
3693 : 1037964608 : if (const gcall *call = dyn_cast <const gcall *> (stmt))
3694 : 49467285 : return gimple_call_lhs (call) != NULL_TREE;
3695 : : return false;
3696 : : }
3697 : :
3698 : :
3699 : : /* Return the code of the predicate computed by conditional statement GS. */
3700 : :
3701 : : inline enum tree_code
3702 : 3435570481 : gimple_cond_code (const gcond *gs)
3703 : : {
3704 : 2244085631 : return (enum tree_code) gs->subcode;
3705 : : }
3706 : :
3707 : : inline enum tree_code
3708 : 560810698 : gimple_cond_code (const gimple *gs)
3709 : : {
3710 : 560810698 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3711 : 560810698 : return gimple_cond_code (gc);
3712 : : }
3713 : :
3714 : :
3715 : : /* Set CODE to be the predicate code for the conditional statement GS. */
3716 : :
3717 : : inline void
3718 : 15634707 : gimple_cond_set_code (gcond *gs, enum tree_code code)
3719 : : {
3720 : 15634707 : gcc_gimple_checking_assert (TREE_CODE_CLASS (code) == tcc_comparison);
3721 : 15634707 : gs->subcode = code;
3722 : 15634707 : }
3723 : :
3724 : :
3725 : : /* Return the LHS of the predicate computed by conditional statement GS. */
3726 : :
3727 : : inline tree
3728 : 3102683580 : gimple_cond_lhs (const gcond *gs)
3729 : : {
3730 : 1841125157 : return gs->op[0];
3731 : : }
3732 : :
3733 : : inline tree
3734 : 726301354 : gimple_cond_lhs (const gimple *gs)
3735 : : {
3736 : 726301354 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3737 : 726301354 : return gimple_cond_lhs (gc);
3738 : : }
3739 : :
3740 : : /* Return the pointer to the LHS of the predicate computed by conditional
3741 : : statement GS. */
3742 : :
3743 : : inline tree *
3744 : 7101304 : gimple_cond_lhs_ptr (gcond *gs)
3745 : : {
3746 : 7101304 : return &gs->op[0];
3747 : : }
3748 : :
3749 : : /* Set LHS to be the LHS operand of the predicate computed by
3750 : : conditional statement GS. */
3751 : :
3752 : : inline void
3753 : 28724646 : gimple_cond_set_lhs (gcond *gs, tree lhs)
3754 : : {
3755 : 25097923 : gs->op[0] = lhs;
3756 : : }
3757 : :
3758 : :
3759 : : /* Return the RHS operand of the predicate computed by conditional GS. */
3760 : :
3761 : : inline tree
3762 : 2244575000 : gimple_cond_rhs (const gcond *gs)
3763 : : {
3764 : 1730930981 : return gs->op[1];
3765 : : }
3766 : :
3767 : : inline tree
3768 : 696906436 : gimple_cond_rhs (const gimple *gs)
3769 : : {
3770 : 696906436 : const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3771 : 696906436 : return gimple_cond_rhs (gc);
3772 : : }
3773 : :
3774 : : /* Return the pointer to the RHS operand of the predicate computed by
3775 : : conditional GS. */
3776 : :
3777 : : inline tree *
3778 : 7099330 : gimple_cond_rhs_ptr (gcond *gs)
3779 : : {
3780 : 7099330 : return &gs->op[1];
3781 : : }
3782 : :
3783 : :
3784 : : /* Set RHS to be the RHS operand of the predicate computed by
3785 : : conditional statement GS. */
3786 : :
3787 : : inline void
3788 : 28880675 : gimple_cond_set_rhs (gcond *gs, tree rhs)
3789 : : {
3790 : 25648590 : gs->op[1] = rhs;
3791 : 35873 : }
3792 : :
3793 : :
3794 : : /* Return the label used by conditional statement GS when its
3795 : : predicate evaluates to true. */
3796 : :
3797 : : inline tree
3798 : 763473192 : gimple_cond_true_label (const gcond *gs)
3799 : : {
3800 : 763473049 : return gs->op[2];
3801 : : }
3802 : :
3803 : :
3804 : : /* Set LABEL to be the label used by conditional statement GS when its
3805 : : predicate evaluates to true. */
3806 : :
3807 : : inline void
3808 : 15772165 : gimple_cond_set_true_label (gcond *gs, tree label)
3809 : : {
3810 : 15772165 : gs->op[2] = label;
3811 : 8289 : }
3812 : :
3813 : :
3814 : : /* Set LABEL to be the label used by conditional statement GS when its
3815 : : predicate evaluates to false. */
3816 : :
3817 : : inline void
3818 : 15864653 : gimple_cond_set_false_label (gcond *gs, tree label)
3819 : : {
3820 : 15864653 : gs->op[3] = label;
3821 : 100777 : }
3822 : :
3823 : :
3824 : : /* Return the label used by conditional statement GS when its
3825 : : predicate evaluates to false. */
3826 : :
3827 : : inline tree
3828 : 763480141 : gimple_cond_false_label (const gcond *gs)
3829 : : {
3830 : 763480141 : return gs->op[3];
3831 : : }
3832 : :
3833 : :
3834 : : /* Set the conditional COND_STMT to be of the form 'if (0 != 0)'. */
3835 : :
3836 : : inline void
3837 : 1904877 : gimple_cond_make_false (gcond *gs)
3838 : : {
3839 : 1904877 : gimple_cond_set_lhs (gs, boolean_false_node);
3840 : 1904877 : gimple_cond_set_rhs (gs, boolean_false_node);
3841 : 1904326 : gs->subcode = NE_EXPR;
3842 : 1752137 : }
3843 : :
3844 : :
3845 : : /* Set the conditional COND_STMT to be of the form 'if (1 != 0)'. */
3846 : :
3847 : : inline void
3848 : 963387 : gimple_cond_make_true (gcond *gs)
3849 : : {
3850 : 963387 : gimple_cond_set_lhs (gs, boolean_true_node);
3851 : 963387 : gimple_cond_set_rhs (gs, boolean_false_node);
3852 : 963143 : gs->subcode = NE_EXPR;
3853 : 875123 : }
3854 : :
3855 : : /* Check if conditional statement GS is of the form 'if (1 == 1)',
3856 : : 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
3857 : :
3858 : : inline bool
3859 : 180693445 : gimple_cond_true_p (const gcond *gs)
3860 : : {
3861 : 180693445 : tree lhs = gimple_cond_lhs (gs);
3862 : 180693445 : tree rhs = gimple_cond_rhs (gs);
3863 : 180693445 : enum tree_code code = gimple_cond_code (gs);
3864 : :
3865 : 180693445 : if (lhs != boolean_true_node && lhs != boolean_false_node)
3866 : : return false;
3867 : :
3868 : 388371 : if (rhs != boolean_true_node && rhs != boolean_false_node)
3869 : : return false;
3870 : :
3871 : 388371 : if (code == NE_EXPR && lhs != rhs)
3872 : : return true;
3873 : :
3874 : 281006 : if (code == EQ_EXPR && lhs == rhs)
3875 : : return true;
3876 : :
3877 : : return false;
3878 : : }
3879 : :
3880 : : /* Check if conditional statement GS is in the caonical form of 'if (1 != 0)'. */
3881 : :
3882 : : inline bool
3883 : 315748 : gimple_cond_true_canonical_p (const gcond *gs)
3884 : : {
3885 : 315748 : tree lhs = gimple_cond_lhs (gs);
3886 : 315748 : tree rhs = gimple_cond_rhs (gs);
3887 : 315748 : tree_code code = gimple_cond_code (gs);
3888 : 315748 : if (code == NE_EXPR
3889 : 223636 : && lhs == boolean_true_node
3890 : 153733 : && rhs == boolean_false_node)
3891 : 153619 : return true;
3892 : : return false;
3893 : : }
3894 : :
3895 : : /* Check if conditional statement GS is of the form 'if (1 != 1)',
3896 : : 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
3897 : :
3898 : : inline bool
3899 : 180586080 : gimple_cond_false_p (const gcond *gs)
3900 : : {
3901 : 180586080 : tree lhs = gimple_cond_lhs (gs);
3902 : 180586080 : tree rhs = gimple_cond_rhs (gs);
3903 : 180586080 : enum tree_code code = gimple_cond_code (gs);
3904 : :
3905 : 180586080 : if (lhs != boolean_true_node && lhs != boolean_false_node)
3906 : : return false;
3907 : :
3908 : 281006 : if (rhs != boolean_true_node && rhs != boolean_false_node)
3909 : : return false;
3910 : :
3911 : 281006 : if (code == NE_EXPR && lhs == rhs)
3912 : : return true;
3913 : :
3914 : 0 : if (code == EQ_EXPR && lhs != rhs)
3915 : : return true;
3916 : :
3917 : : return false;
3918 : : }
3919 : :
3920 : : /* Check if conditional statement GS is in the caonical form of 'if (0 != 0)'. */
3921 : :
3922 : : inline bool
3923 : 770951 : gimple_cond_false_canonical_p (const gcond *gs)
3924 : : {
3925 : 770951 : tree lhs = gimple_cond_lhs (gs);
3926 : 770951 : tree rhs = gimple_cond_rhs (gs);
3927 : 770951 : tree_code code = gimple_cond_code (gs);
3928 : 770951 : if (code == NE_EXPR
3929 : 517272 : && lhs == boolean_false_node
3930 : 316687 : && rhs == boolean_false_node)
3931 : : return true;
3932 : : return false;
3933 : : }
3934 : :
3935 : : /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3936 : :
3937 : : inline void
3938 : 2112200 : gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs,
3939 : : tree rhs)
3940 : : {
3941 : 2112200 : gimple_cond_set_code (stmt, code);
3942 : 2112200 : gimple_cond_set_lhs (stmt, lhs);
3943 : 2112200 : gimple_cond_set_rhs (stmt, rhs);
3944 : 1700639 : }
3945 : :
3946 : :
3947 : : /* Return the tree code for the expression computed by STMT. This is
3948 : : only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
3949 : : GIMPLE_CALL, return CALL_EXPR as the expression code for
3950 : : consistency. This is useful when the caller needs to deal with the
3951 : : three kinds of computation that GIMPLE supports. */
3952 : :
3953 : : inline enum tree_code
3954 : 320776659 : gimple_expr_code (const gimple *stmt)
3955 : : {
3956 : 320776659 : if (const gassign *ass = dyn_cast<const gassign *> (stmt))
3957 : 219586113 : return gimple_assign_rhs_code (ass);
3958 : 101190546 : if (const gcond *cond = dyn_cast<const gcond *> (stmt))
3959 : 100036917 : return gimple_cond_code (cond);
3960 : : else
3961 : : {
3962 : 1153629 : gcc_gimple_checking_assert (gimple_code (stmt) == GIMPLE_CALL);
3963 : : return CALL_EXPR;
3964 : : }
3965 : : }
3966 : :
3967 : :
3968 : : /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3969 : :
3970 : : inline tree
3971 : 510159236 : gimple_label_label (const glabel *gs)
3972 : : {
3973 : 510159236 : return gs->op[0];
3974 : : }
3975 : :
3976 : :
3977 : : /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3978 : : GS. */
3979 : :
3980 : : inline void
3981 : 18989106 : gimple_label_set_label (glabel *gs, tree label)
3982 : : {
3983 : 18989106 : gs->op[0] = label;
3984 : : }
3985 : :
3986 : :
3987 : : /* Return the destination of the unconditional jump GS. */
3988 : :
3989 : : inline tree
3990 : 50556848 : gimple_goto_dest (const gimple *gs)
3991 : : {
3992 : 50556848 : GIMPLE_CHECK (gs, GIMPLE_GOTO);
3993 : 50556848 : return gimple_op (gs, 0);
3994 : : }
3995 : :
3996 : :
3997 : : /* Set DEST to be the destination of the unconditonal jump GS. */
3998 : :
3999 : : inline void
4000 : 7913090 : gimple_goto_set_dest (ggoto *gs, tree dest)
4001 : : {
4002 : 7913090 : gs->op[0] = dest;
4003 : 1080087 : }
4004 : :
4005 : :
4006 : : /* Return the variables declared in the GIMPLE_BIND statement GS. */
4007 : :
4008 : : inline tree
4009 : 17595465 : gimple_bind_vars (const gbind *bind_stmt)
4010 : : {
4011 : 17595465 : return bind_stmt->vars;
4012 : : }
4013 : :
4014 : :
4015 : : /* Set VARS to be the set of variables declared in the GIMPLE_BIND
4016 : : statement GS. */
4017 : :
4018 : : inline void
4019 : 9383006 : gimple_bind_set_vars (gbind *bind_stmt, tree vars)
4020 : : {
4021 : 7501092 : bind_stmt->vars = vars;
4022 : 1881914 : }
4023 : :
4024 : :
4025 : : /* Append VARS to the set of variables declared in the GIMPLE_BIND
4026 : : statement GS. */
4027 : :
4028 : : inline void
4029 : 77216 : gimple_bind_append_vars (gbind *bind_stmt, tree vars)
4030 : : {
4031 : 77216 : bind_stmt->vars = chainon (bind_stmt->vars, vars);
4032 : : }
4033 : :
4034 : :
4035 : : inline gimple_seq *
4036 : 10334034 : gimple_bind_body_ptr (gbind *bind_stmt)
4037 : : {
4038 : 10334034 : return &bind_stmt->body;
4039 : : }
4040 : :
4041 : : /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
4042 : :
4043 : : inline gimple_seq
4044 : 30313589 : gimple_bind_body (const gbind *gs)
4045 : : {
4046 : 30313589 : return *gimple_bind_body_ptr (const_cast <gbind *> (gs));
4047 : : }
4048 : :
4049 : :
4050 : : /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
4051 : : statement GS. */
4052 : :
4053 : : inline void
4054 : 8161214 : gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
4055 : : {
4056 : 6725485 : bind_stmt->body = seq;
4057 : 1435351 : }
4058 : :
4059 : :
4060 : : /* Append a statement to the end of a GIMPLE_BIND's body. */
4061 : :
4062 : : inline void
4063 : 67177 : gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
4064 : : {
4065 : 67177 : gimple_seq_add_stmt (&bind_stmt->body, stmt);
4066 : 0 : }
4067 : :
4068 : :
4069 : : /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
4070 : :
4071 : : inline void
4072 : 128462 : gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
4073 : : {
4074 : 124620 : gimple_seq_add_seq (&bind_stmt->body, seq);
4075 : : }
4076 : :
4077 : :
4078 : : /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
4079 : : GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
4080 : :
4081 : : inline tree
4082 : 24199013 : gimple_bind_block (const gbind *bind_stmt)
4083 : : {
4084 : 24197853 : return bind_stmt->block;
4085 : : }
4086 : :
4087 : :
4088 : : /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
4089 : : statement GS. */
4090 : :
4091 : : inline void
4092 : 5902473 : gimple_bind_set_block (gbind *bind_stmt, tree block)
4093 : : {
4094 : 5902473 : gcc_gimple_checking_assert (block == NULL_TREE
4095 : : || TREE_CODE (block) == BLOCK);
4096 : 5902473 : bind_stmt->block = block;
4097 : 5902473 : }
4098 : :
4099 : :
4100 : : /* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
4101 : :
4102 : : inline unsigned
4103 : 48918339 : gimple_asm_ninputs (const gasm *asm_stmt)
4104 : : {
4105 : 48918339 : return asm_stmt->ni;
4106 : : }
4107 : :
4108 : :
4109 : : /* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
4110 : :
4111 : : inline unsigned
4112 : 80333884 : gimple_asm_noutputs (const gasm *asm_stmt)
4113 : : {
4114 : 67696616 : return asm_stmt->no;
4115 : : }
4116 : :
4117 : :
4118 : : /* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
4119 : :
4120 : : inline unsigned
4121 : 16739146 : gimple_asm_nclobbers (const gasm *asm_stmt)
4122 : : {
4123 : 16739146 : return asm_stmt->nc;
4124 : : }
4125 : :
4126 : : /* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
4127 : :
4128 : : inline unsigned
4129 : 39957048 : gimple_asm_nlabels (const gasm *asm_stmt)
4130 : : {
4131 : 39951663 : return asm_stmt->nl;
4132 : : }
4133 : :
4134 : : /* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
4135 : :
4136 : : inline tree
4137 : 22046863 : gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
4138 : : {
4139 : 22046863 : gcc_gimple_checking_assert (index < asm_stmt->ni);
4140 : 22046863 : return asm_stmt->op[index + asm_stmt->no];
4141 : : }
4142 : :
4143 : : /* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */
4144 : :
4145 : : inline void
4146 : 44188 : gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
4147 : : {
4148 : 44188 : gcc_gimple_checking_assert (index < asm_stmt->ni
4149 : : && TREE_CODE (in_op) == TREE_LIST);
4150 : 44188 : asm_stmt->op[index + asm_stmt->no] = in_op;
4151 : 44188 : }
4152 : :
4153 : :
4154 : : /* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
4155 : :
4156 : : inline tree
4157 : 32977989 : gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
4158 : : {
4159 : 32977989 : gcc_gimple_checking_assert (index < asm_stmt->no);
4160 : 32977989 : return asm_stmt->op[index];
4161 : : }
4162 : :
4163 : : /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
4164 : :
4165 : : inline void
4166 : 62185 : gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
4167 : : {
4168 : 62185 : gcc_gimple_checking_assert (index < asm_stmt->no
4169 : : && TREE_CODE (out_op) == TREE_LIST);
4170 : 62185 : asm_stmt->op[index] = out_op;
4171 : 62185 : }
4172 : :
4173 : :
4174 : : /* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
4175 : :
4176 : : inline tree
4177 : 9657609 : gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
4178 : : {
4179 : 9657609 : gcc_gimple_checking_assert (index < asm_stmt->nc);
4180 : 9657609 : return asm_stmt->op[index + asm_stmt->ni + asm_stmt->no];
4181 : : }
4182 : :
4183 : :
4184 : : /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */
4185 : :
4186 : : inline void
4187 : 94434 : gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
4188 : : {
4189 : 94434 : gcc_gimple_checking_assert (index < asm_stmt->nc
4190 : : && TREE_CODE (clobber_op) == TREE_LIST);
4191 : 94434 : asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op;
4192 : 94434 : }
4193 : :
4194 : : /* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
4195 : :
4196 : : inline tree
4197 : 186212 : gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
4198 : : {
4199 : 186212 : gcc_gimple_checking_assert (index < asm_stmt->nl);
4200 : 186212 : return asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc];
4201 : : }
4202 : :
4203 : : /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */
4204 : :
4205 : : inline void
4206 : 763 : gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
4207 : : {
4208 : 763 : gcc_gimple_checking_assert (index < asm_stmt->nl
4209 : : && TREE_CODE (label_op) == TREE_LIST);
4210 : 763 : asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc] = label_op;
4211 : 763 : }
4212 : :
4213 : : /* Return the string representing the assembly instruction in
4214 : : GIMPLE_ASM ASM_STMT. */
4215 : :
4216 : : inline const char *
4217 : 1155761 : gimple_asm_string (const gasm *asm_stmt)
4218 : : {
4219 : 1155761 : return asm_stmt->string;
4220 : : }
4221 : :
4222 : :
4223 : : /* Return true if ASM_STMT is marked volatile. */
4224 : :
4225 : : inline bool
4226 : 1546172 : gimple_asm_volatile_p (const gasm *asm_stmt)
4227 : : {
4228 : 1546172 : return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0;
4229 : : }
4230 : :
4231 : :
4232 : : /* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
4233 : :
4234 : : inline void
4235 : 7198 : gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
4236 : : {
4237 : 7198 : if (volatile_p)
4238 : 87703 : asm_stmt->subcode |= GF_ASM_VOLATILE;
4239 : : else
4240 : 7198 : asm_stmt->subcode &= ~GF_ASM_VOLATILE;
4241 : : }
4242 : :
4243 : :
4244 : : /* Return true if ASM_STMT is marked inline. */
4245 : :
4246 : : inline bool
4247 : 747217 : gimple_asm_inline_p (const gasm *asm_stmt)
4248 : : {
4249 : 747217 : return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
4250 : : }
4251 : :
4252 : :
4253 : : /* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
4254 : :
4255 : : inline void
4256 : 94901 : gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
4257 : : {
4258 : 94901 : if (inline_p)
4259 : 98 : asm_stmt->subcode |= GF_ASM_INLINE;
4260 : : else
4261 : 94803 : asm_stmt->subcode &= ~GF_ASM_INLINE;
4262 : : }
4263 : :
4264 : :
4265 : : /* Mark whether asm ASM_STMT is a basic asm or an extended asm, based on
4266 : : BASIC_P. */
4267 : :
4268 : : inline void
4269 : 94901 : gimple_asm_set_basic (gasm *asm_stmt, bool basic_p)
4270 : : {
4271 : 94901 : if (basic_p)
4272 : 2423 : asm_stmt->subcode |= GF_ASM_BASIC;
4273 : : else
4274 : 92478 : asm_stmt->subcode &= ~GF_ASM_BASIC;
4275 : : }
4276 : :
4277 : :
4278 : : /* Return true if asm ASM_STMT is a basic asm rather than an extended asm. */
4279 : :
4280 : : inline bool
4281 : 7187916 : gimple_asm_basic_p (const gasm *asm_stmt)
4282 : : {
4283 : 7187916 : return (asm_stmt->subcode & GF_ASM_BASIC) != 0;
4284 : : }
4285 : :
4286 : :
4287 : : /* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4288 : :
4289 : : inline tree
4290 : 60872 : gimple_catch_types (const gcatch *catch_stmt)
4291 : : {
4292 : 60872 : return catch_stmt->types;
4293 : : }
4294 : :
4295 : :
4296 : : /* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4297 : :
4298 : : inline tree *
4299 : 17644 : gimple_catch_types_ptr (gcatch *catch_stmt)
4300 : : {
4301 : 17644 : return &catch_stmt->types;
4302 : : }
4303 : :
4304 : :
4305 : : /* Return a pointer to the GIMPLE sequence representing the body of
4306 : : the handler of GIMPLE_CATCH statement CATCH_STMT. */
4307 : :
4308 : : inline gimple_seq *
4309 : 74279 : gimple_catch_handler_ptr (gcatch *catch_stmt)
4310 : : {
4311 : 74279 : return &catch_stmt->handler;
4312 : : }
4313 : :
4314 : :
4315 : : /* Return the GIMPLE sequence representing the body of the handler of
4316 : : GIMPLE_CATCH statement CATCH_STMT. */
4317 : :
4318 : : inline gimple_seq
4319 : 360771 : gimple_catch_handler (const gcatch *catch_stmt)
4320 : : {
4321 : 360771 : return *gimple_catch_handler_ptr (const_cast <gcatch *> (catch_stmt));
4322 : : }
4323 : :
4324 : :
4325 : : /* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */
4326 : :
4327 : : inline void
4328 : 56367 : gimple_catch_set_types (gcatch *catch_stmt, tree t)
4329 : : {
4330 : 56367 : catch_stmt->types = t;
4331 : 17498 : }
4332 : :
4333 : :
4334 : : /* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4335 : :
4336 : : inline void
4337 : 56355 : gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
4338 : : {
4339 : 17498 : catch_stmt->handler = handler;
4340 : 38857 : }
4341 : :
4342 : :
4343 : : /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4344 : :
4345 : : inline tree
4346 : 4283 : gimple_eh_filter_types (const gimple *gs)
4347 : : {
4348 : 4283 : const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
4349 : 4283 : return eh_filter_stmt->types;
4350 : : }
4351 : :
4352 : :
4353 : : /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4354 : : GS. */
4355 : :
4356 : : inline tree *
4357 : 71 : gimple_eh_filter_types_ptr (gimple *gs)
4358 : : {
4359 : 71 : geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4360 : 71 : return &eh_filter_stmt->types;
4361 : : }
4362 : :
4363 : :
4364 : : /* Return a pointer to the sequence of statement to execute when
4365 : : GIMPLE_EH_FILTER statement fails. */
4366 : :
4367 : : inline gimple_seq *
4368 : 39199 : gimple_eh_filter_failure_ptr (gimple *gs)
4369 : : {
4370 : 30136 : geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4371 : 30136 : return &eh_filter_stmt->failure;
4372 : : }
4373 : :
4374 : :
4375 : : /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4376 : : statement fails. */
4377 : :
4378 : : inline gimple_seq
4379 : 34328 : gimple_eh_filter_failure (const gimple *gs)
4380 : : {
4381 : 34328 : return *gimple_eh_filter_failure_ptr (const_cast <gimple *> (gs));
4382 : : }
4383 : :
4384 : :
4385 : : /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4386 : : EH_FILTER_STMT. */
4387 : :
4388 : : inline void
4389 : 4271 : gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
4390 : : {
4391 : 4271 : eh_filter_stmt->types = types;
4392 : 0 : }
4393 : :
4394 : :
4395 : : /* Set FAILURE to be the sequence of statements to execute on failure
4396 : : for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4397 : :
4398 : : inline void
4399 : 4271 : gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt,
4400 : : gimple_seq failure)
4401 : : {
4402 : 0 : eh_filter_stmt->failure = failure;
4403 : 4271 : }
4404 : :
4405 : : /* Get the function decl to be called by the MUST_NOT_THROW region. */
4406 : :
4407 : : inline tree
4408 : 1262192 : gimple_eh_must_not_throw_fndecl (const geh_mnt *eh_mnt_stmt)
4409 : : {
4410 : 1262192 : return eh_mnt_stmt->fndecl;
4411 : : }
4412 : :
4413 : : /* Set the function decl to be called by GS to DECL. */
4414 : :
4415 : : inline void
4416 : 1255646 : gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt,
4417 : : tree decl)
4418 : : {
4419 : 1255646 : eh_mnt_stmt->fndecl = decl;
4420 : 0 : }
4421 : :
4422 : : /* GIMPLE_EH_ELSE accessors. */
4423 : :
4424 : : inline gimple_seq *
4425 : 906 : gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
4426 : : {
4427 : 906 : return &eh_else_stmt->n_body;
4428 : : }
4429 : :
4430 : : inline gimple_seq
4431 : 3990 : gimple_eh_else_n_body (const geh_else *eh_else_stmt)
4432 : : {
4433 : 3723 : return *gimple_eh_else_n_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4434 : : }
4435 : :
4436 : : inline gimple_seq *
4437 : 906 : gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
4438 : : {
4439 : 906 : return &eh_else_stmt->e_body;
4440 : : }
4441 : :
4442 : : inline gimple_seq
4443 : 3233 : gimple_eh_else_e_body (const geh_else *eh_else_stmt)
4444 : : {
4445 : 3233 : return *gimple_eh_else_e_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4446 : : }
4447 : :
4448 : : inline void
4449 : 636 : gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
4450 : : {
4451 : 273 : eh_else_stmt->n_body = seq;
4452 : : }
4453 : :
4454 : : inline void
4455 : 636 : gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
4456 : : {
4457 : 273 : eh_else_stmt->e_body = seq;
4458 : 273 : }
4459 : :
4460 : : /* GIMPLE_TRY accessors. */
4461 : :
4462 : : /* Return the kind of try block represented by GIMPLE_TRY GS. This is
4463 : : either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
4464 : :
4465 : : inline enum gimple_try_flags
4466 : 10311279 : gimple_try_kind (const gimple *gs)
4467 : : {
4468 : 10311279 : GIMPLE_CHECK (gs, GIMPLE_TRY);
4469 : 10311279 : return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
4470 : : }
4471 : :
4472 : :
4473 : : /* Set the kind of try block represented by GIMPLE_TRY GS. */
4474 : :
4475 : : inline void
4476 : 1 : gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
4477 : : {
4478 : 1 : gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
4479 : : || kind == GIMPLE_TRY_FINALLY);
4480 : 1 : if (gimple_try_kind (gs) != kind)
4481 : 1 : gs->subcode = (unsigned int) kind;
4482 : 1 : }
4483 : :
4484 : :
4485 : : /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4486 : :
4487 : : inline bool
4488 : 5894 : gimple_try_catch_is_cleanup (const gimple *gs)
4489 : : {
4490 : 5894 : gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
4491 : 5894 : return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
4492 : : }
4493 : :
4494 : :
4495 : : /* Return a pointer to the sequence of statements used as the
4496 : : body for GIMPLE_TRY GS. */
4497 : :
4498 : : inline gimple_seq *
4499 : 28418158 : gimple_try_eval_ptr (gimple *gs)
4500 : : {
4501 : 19558959 : gtry *try_stmt = as_a <gtry *> (gs);
4502 : 19558959 : return &try_stmt->eval;
4503 : : }
4504 : :
4505 : :
4506 : : /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4507 : :
4508 : : inline gimple_seq
4509 : 24044306 : gimple_try_eval (const gimple *gs)
4510 : : {
4511 : 24044306 : return *gimple_try_eval_ptr (const_cast <gimple *> (gs));
4512 : : }
4513 : :
4514 : :
4515 : : /* Return a pointer to the sequence of statements used as the cleanup body for
4516 : : GIMPLE_TRY GS. */
4517 : :
4518 : : inline gimple_seq *
4519 : 28840343 : gimple_try_cleanup_ptr (gimple *gs)
4520 : : {
4521 : 17261800 : gtry *try_stmt = as_a <gtry *> (gs);
4522 : 17261800 : return &try_stmt->cleanup;
4523 : : }
4524 : :
4525 : :
4526 : : /* Return the sequence of statements used as the cleanup body for
4527 : : GIMPLE_TRY GS. */
4528 : :
4529 : : inline gimple_seq
4530 : 13887956 : gimple_try_cleanup (const gimple *gs)
4531 : : {
4532 : 24928874 : return *gimple_try_cleanup_ptr (const_cast <gimple *> (gs));
4533 : : }
4534 : :
4535 : :
4536 : : /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4537 : :
4538 : : inline void
4539 : 181773 : gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
4540 : : {
4541 : 181773 : gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
4542 : 181773 : if (catch_is_cleanup)
4543 : 215 : g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
4544 : : else
4545 : 181558 : g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
4546 : 181773 : }
4547 : :
4548 : :
4549 : : /* Set EVAL to be the sequence of statements to use as the body for
4550 : : GIMPLE_TRY TRY_STMT. */
4551 : :
4552 : : inline void
4553 : 2989282 : gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
4554 : : {
4555 : 23939 : try_stmt->eval = eval;
4556 : 2965343 : }
4557 : :
4558 : :
4559 : : /* Set CLEANUP to be the sequence of statements to use as the cleanup
4560 : : body for GIMPLE_TRY TRY_STMT. */
4561 : :
4562 : : inline void
4563 : 3163172 : gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
4564 : : {
4565 : 65160 : try_stmt->cleanup = cleanup;
4566 : 3121950 : }
4567 : :
4568 : :
4569 : : /* Return a pointer to the cleanup sequence for cleanup statement GS. */
4570 : :
4571 : : inline gimple_seq *
4572 : 592215 : gimple_wce_cleanup_ptr (gimple *gs)
4573 : : {
4574 : 592215 : gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4575 : 592215 : return &wce_stmt->cleanup;
4576 : : }
4577 : :
4578 : :
4579 : : /* Return the cleanup sequence for cleanup statement GS. */
4580 : :
4581 : : inline gimple_seq
4582 : 592215 : gimple_wce_cleanup (gimple *gs)
4583 : : {
4584 : 592215 : return *gimple_wce_cleanup_ptr (gs);
4585 : : }
4586 : :
4587 : :
4588 : : /* Set CLEANUP to be the cleanup sequence for GS. */
4589 : :
4590 : : inline void
4591 : 592646 : gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
4592 : : {
4593 : 592646 : gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4594 : 592646 : wce_stmt->cleanup = cleanup;
4595 : 592646 : }
4596 : :
4597 : :
4598 : : /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4599 : :
4600 : : inline bool
4601 : 592646 : gimple_wce_cleanup_eh_only (const gimple *gs)
4602 : : {
4603 : 592646 : GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4604 : 592646 : return gs->subcode != 0;
4605 : : }
4606 : :
4607 : :
4608 : : /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4609 : :
4610 : : inline void
4611 : 580756 : gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
4612 : : {
4613 : 580756 : GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4614 : 580756 : gs->subcode = (unsigned int) eh_only_p;
4615 : 580756 : }
4616 : :
4617 : :
4618 : : /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4619 : :
4620 : : inline unsigned
4621 : 407030819 : gimple_phi_capacity (const gimple *gs)
4622 : : {
4623 : 363947320 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4624 : 407030819 : return phi_stmt->capacity;
4625 : : }
4626 : :
4627 : :
4628 : : /* Return the number of arguments in GIMPLE_PHI GS. This must always
4629 : : be exactly the number of incoming edges for the basic block holding
4630 : : GS. */
4631 : :
4632 : : inline unsigned
4633 : 7278344788 : gimple_phi_num_args (const gimple *gs)
4634 : : {
4635 : 7280954536 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4636 : 7281683955 : return phi_stmt->nargs;
4637 : : }
4638 : :
4639 : :
4640 : : /* Return the SSA name created by GIMPLE_PHI GS. */
4641 : :
4642 : : inline tree
4643 : 8717783085 : gimple_phi_result (const gphi *gs)
4644 : : {
4645 : 8275840763 : return gs->result;
4646 : : }
4647 : :
4648 : : inline tree
4649 : 805136652 : gimple_phi_result (const gimple *gs)
4650 : : {
4651 : 797469691 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4652 : 806655696 : return gimple_phi_result (phi_stmt);
4653 : : }
4654 : :
4655 : : /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4656 : :
4657 : : inline tree *
4658 : 16199680 : gimple_phi_result_ptr (gphi *gs)
4659 : : {
4660 : 16199680 : return &gs->result;
4661 : : }
4662 : :
4663 : : inline tree *
4664 : : gimple_phi_result_ptr (gimple *gs)
4665 : : {
4666 : : gphi *phi_stmt = as_a <gphi *> (gs);
4667 : : return gimple_phi_result_ptr (phi_stmt);
4668 : : }
4669 : :
4670 : : /* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4671 : :
4672 : : inline void
4673 : 14493661 : gimple_phi_set_result (gphi *phi, tree result)
4674 : : {
4675 : 14493661 : phi->result = result;
4676 : 14493661 : if (result && TREE_CODE (result) == SSA_NAME)
4677 : 14493661 : SSA_NAME_DEF_STMT (result) = phi;
4678 : : }
4679 : :
4680 : :
4681 : : /* Return the PHI argument corresponding to incoming edge INDEX for
4682 : : GIMPLE_PHI GS. */
4683 : :
4684 : : inline struct phi_arg_d *
4685 : 3297009872 : gimple_phi_arg (gphi *gs, unsigned index)
4686 : : {
4687 : 132074564 : gcc_gimple_checking_assert (index < gs->nargs);
4688 : 3296966054 : return &(gs->args[index]);
4689 : : }
4690 : :
4691 : : inline const phi_arg_d *
4692 : 7841333918 : gimple_phi_arg (const gphi *gs, unsigned index)
4693 : : {
4694 : 0 : gcc_gimple_checking_assert (index < gs->nargs);
4695 : 7841305018 : return &(gs->args[index]);
4696 : : }
4697 : :
4698 : : inline const phi_arg_d *
4699 : 1122194505 : gimple_phi_arg (const gimple *gs, unsigned index)
4700 : : {
4701 : 1122194505 : const gphi *phi_stmt = as_a <const gphi *> (gs);
4702 : 1122194505 : return gimple_phi_arg (phi_stmt, index);
4703 : : }
4704 : :
4705 : : inline struct phi_arg_d *
4706 : 2805097821 : gimple_phi_arg (gimple *gs, unsigned index)
4707 : : {
4708 : 2805097821 : gphi *phi_stmt = as_a <gphi *> (gs);
4709 : 2805097821 : return gimple_phi_arg (phi_stmt, index);
4710 : : }
4711 : :
4712 : : /* Set PHIARG to be the argument corresponding to incoming edge INDEX
4713 : : for GIMPLE_PHI PHI. */
4714 : :
4715 : : inline void
4716 : : gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d * phiarg)
4717 : : {
4718 : : gcc_gimple_checking_assert (index < phi->nargs);
4719 : : phi->args[index] = *phiarg;
4720 : : }
4721 : :
4722 : : /* Return the PHI nodes for basic block BB, or NULL if there are no
4723 : : PHI nodes. */
4724 : :
4725 : : inline gimple_seq
4726 : 719881004 : phi_nodes (const_basic_block bb)
4727 : : {
4728 : 719881004 : gcc_checking_assert (!(bb->flags & BB_RTL));
4729 : 719881004 : return bb->il.gimple.phi_nodes;
4730 : : }
4731 : :
4732 : : /* Return a pointer to the PHI nodes for basic block BB. */
4733 : :
4734 : : inline gimple_seq *
4735 : 11829315980 : phi_nodes_ptr (basic_block bb)
4736 : : {
4737 : 11829315980 : gcc_checking_assert (!(bb->flags & BB_RTL));
4738 : 11829315980 : return &bb->il.gimple.phi_nodes;
4739 : : }
4740 : :
4741 : : /* Return the tree operand for argument I of PHI node GS. */
4742 : :
4743 : : inline tree
4744 : 3954408452 : gimple_phi_arg_def (const gphi *gs, size_t index)
4745 : : {
4746 : 3971622579 : return gimple_phi_arg (gs, index)->def;
4747 : : }
4748 : :
4749 : : inline tree
4750 : 801020225 : gimple_phi_arg_def (const gimple *gs, size_t index)
4751 : : {
4752 : 801014658 : return gimple_phi_arg (gs, index)->def;
4753 : : }
4754 : :
4755 : : /* Return the tree operand for the argument associated with
4756 : : edge E of PHI node GS. */
4757 : :
4758 : : inline tree
4759 : 949960522 : gimple_phi_arg_def_from_edge (const gphi *gs, const_edge e)
4760 : : {
4761 : 949960522 : gcc_checking_assert (e->dest == gimple_bb (gs));
4762 : 949960522 : return gimple_phi_arg (gs, e->dest_idx)->def;
4763 : : }
4764 : :
4765 : : inline tree
4766 : 321173424 : gimple_phi_arg_def_from_edge (const gimple *gs, const_edge e)
4767 : : {
4768 : 321173424 : gcc_checking_assert (e->dest == gimple_bb (gs));
4769 : 321173424 : return gimple_phi_arg (gs, e->dest_idx)->def;
4770 : : }
4771 : :
4772 : : /* Return a pointer to the tree operand for argument I of phi node PHI. */
4773 : :
4774 : : inline tree *
4775 : 97322461 : gimple_phi_arg_def_ptr (gphi *phi, size_t index)
4776 : : {
4777 : 97322461 : return &gimple_phi_arg (phi, index)->def;
4778 : : }
4779 : :
4780 : : /* Return the edge associated with argument I of phi node PHI. */
4781 : :
4782 : : inline edge
4783 : 473088251 : gimple_phi_arg_edge (const gphi *phi, size_t i)
4784 : : {
4785 : 487447698 : return EDGE_PRED (gimple_bb (phi), i);
4786 : : }
4787 : :
4788 : : /* Return the source location of gimple argument I of phi node PHI. */
4789 : :
4790 : : inline location_t
4791 : 1793672507 : gimple_phi_arg_location (const gphi *phi, size_t i)
4792 : : {
4793 : 1793672507 : return gimple_phi_arg (phi, i)->locus;
4794 : : }
4795 : :
4796 : : /* Return the source location of the argument on edge E of phi node PHI. */
4797 : :
4798 : : inline location_t
4799 : 16694012 : gimple_phi_arg_location_from_edge (gphi *phi, edge e)
4800 : : {
4801 : 16694012 : return gimple_phi_arg (phi, e->dest_idx)->locus;
4802 : : }
4803 : :
4804 : : /* Set the source location of gimple argument I of phi node PHI to LOC. */
4805 : :
4806 : : inline void
4807 : 245599060 : gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
4808 : : {
4809 : 245599060 : gimple_phi_arg (phi, i)->locus = loc;
4810 : 245599060 : }
4811 : :
4812 : : /* Return address of source location of gimple argument I of phi node PHI. */
4813 : :
4814 : : inline location_t *
4815 : 178136 : gimple_phi_arg_location_ptr (gphi *phi, size_t i)
4816 : : {
4817 : 178136 : return &gimple_phi_arg (phi, i)->locus;
4818 : : }
4819 : :
4820 : : /* Return TRUE if argument I of phi node PHI has a location record. */
4821 : :
4822 : : inline bool
4823 : 7752030 : gimple_phi_arg_has_location (const gphi *phi, size_t i)
4824 : : {
4825 : 7752030 : return gimple_phi_arg_location (phi, i) != UNKNOWN_LOCATION;
4826 : : }
4827 : :
4828 : : /* Return the number of arguments that can be accessed by gimple_arg. */
4829 : :
4830 : : inline unsigned
4831 : 18640678 : gimple_num_args (const gimple *gs)
4832 : : {
4833 : 18640678 : if (auto phi = dyn_cast<const gphi *> (gs))
4834 : 1468408 : return gimple_phi_num_args (phi);
4835 : 17172270 : if (auto call = dyn_cast<const gcall *> (gs))
4836 : 117603 : return gimple_call_num_args (call);
4837 : 17054667 : return gimple_num_ops (as_a <const gassign *> (gs)) - 1;
4838 : : }
4839 : :
4840 : : /* GS must be an assignment, a call, or a PHI.
4841 : : If it's an assignment, return rhs operand I.
4842 : : If it's a call, return function argument I.
4843 : : If it's a PHI, return the value of PHI argument I. */
4844 : :
4845 : : inline tree
4846 : 28502772 : gimple_arg (const gimple *gs, unsigned int i)
4847 : : {
4848 : 28502772 : if (auto phi = dyn_cast<const gphi *> (gs))
4849 : 1516549 : return gimple_phi_arg_def (phi, i);
4850 : 26986223 : if (auto call = dyn_cast<const gcall *> (gs))
4851 : 71226 : return gimple_call_arg (call, i);
4852 : 26914997 : return gimple_op (as_a <const gassign *> (gs), i + 1);
4853 : : }
4854 : :
4855 : : /* Return a pointer to gimple_arg (GS, I). */
4856 : :
4857 : : inline tree *
4858 : : gimple_arg_ptr (gimple *gs, unsigned int i)
4859 : : {
4860 : : if (auto phi = dyn_cast<gphi *> (gs))
4861 : : return gimple_phi_arg_def_ptr (phi, i);
4862 : : if (auto call = dyn_cast<gcall *> (gs))
4863 : : return gimple_call_arg_ptr (call, i);
4864 : : return gimple_op_ptr (as_a <gassign *> (gs), i + 1);
4865 : : }
4866 : :
4867 : : /* Return the region number for GIMPLE_RESX RESX_STMT. */
4868 : :
4869 : : inline int
4870 : 1333108 : gimple_resx_region (const gresx *resx_stmt)
4871 : : {
4872 : 1333108 : return resx_stmt->region;
4873 : : }
4874 : :
4875 : : /* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4876 : :
4877 : : inline void
4878 : 81798 : gimple_resx_set_region (gresx *resx_stmt, int region)
4879 : : {
4880 : 81798 : resx_stmt->region = region;
4881 : 81798 : }
4882 : :
4883 : : /* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4884 : :
4885 : : inline int
4886 : 2024139 : gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
4887 : : {
4888 : 2023750 : return eh_dispatch_stmt->region;
4889 : : }
4890 : :
4891 : : /* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4892 : : EH_DISPATCH_STMT. */
4893 : :
4894 : : inline void
4895 : 9140 : gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
4896 : : {
4897 : 9140 : eh_dispatch_stmt->region = region;
4898 : 9140 : }
4899 : :
4900 : : /* Return the number of labels associated with the switch statement GS. */
4901 : :
4902 : : inline unsigned
4903 : 14847542 : gimple_switch_num_labels (const gswitch *gs)
4904 : : {
4905 : 14847542 : unsigned num_ops;
4906 : 14847542 : GIMPLE_CHECK (gs, GIMPLE_SWITCH);
4907 : 14847542 : num_ops = gimple_num_ops (gs);
4908 : 14847542 : gcc_gimple_checking_assert (num_ops > 1);
4909 : 14847542 : return num_ops - 1;
4910 : : }
4911 : :
4912 : :
4913 : : /* Set NLABELS to be the number of labels for the switch statement GS. */
4914 : :
4915 : : inline void
4916 : 24313 : gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
4917 : : {
4918 : 24313 : GIMPLE_CHECK (g, GIMPLE_SWITCH);
4919 : 24313 : gimple_set_num_ops (g, nlabels + 1);
4920 : 24313 : }
4921 : :
4922 : :
4923 : : /* Return the index variable used by the switch statement GS. */
4924 : :
4925 : : inline tree
4926 : 13789699 : gimple_switch_index (const gswitch *gs)
4927 : : {
4928 : 13720616 : return gs->op[0];
4929 : : }
4930 : :
4931 : :
4932 : : /* Return a pointer to the index variable for the switch statement GS. */
4933 : :
4934 : : inline tree *
4935 : 0 : gimple_switch_index_ptr (gswitch *gs)
4936 : : {
4937 : 0 : return &gs->op[0];
4938 : : }
4939 : :
4940 : :
4941 : : /* Set INDEX to be the index variable for switch statement GS. */
4942 : :
4943 : : inline void
4944 : 116237 : gimple_switch_set_index (gswitch *gs, tree index)
4945 : : {
4946 : 116237 : gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
4947 : 116237 : gs->op[0] = index;
4948 : 116237 : }
4949 : :
4950 : :
4951 : : /* Return the label numbered INDEX. The default label is 0, followed by any
4952 : : labels in a switch statement. */
4953 : :
4954 : : inline tree
4955 : 148837723 : gimple_switch_label (const gswitch *gs, unsigned index)
4956 : : {
4957 : 148780595 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
4958 : 11789840 : return gs->op[index + 1];
4959 : : }
4960 : :
4961 : : /* Set the label number INDEX to LABEL. 0 is always the default label. */
4962 : :
4963 : : inline void
4964 : 1277722 : gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
4965 : : {
4966 : 1277722 : gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
4967 : : && (label == NULL_TREE
4968 : : || TREE_CODE (label) == CASE_LABEL_EXPR));
4969 : 1277722 : gs->op[index + 1] = label;
4970 : 1277722 : }
4971 : :
4972 : : /* Return the default label for a switch statement. */
4973 : :
4974 : : inline tree
4975 : 57128 : gimple_switch_default_label (const gswitch *gs)
4976 : : {
4977 : 57128 : tree label = gimple_switch_label (gs, 0);
4978 : 57128 : gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4979 : 57128 : return label;
4980 : : }
4981 : :
4982 : : /* Set the default label for a switch statement. */
4983 : :
4984 : : inline void
4985 : 69448 : gimple_switch_set_default_label (gswitch *gs, tree label)
4986 : : {
4987 : 69448 : gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4988 : 69448 : gimple_switch_set_label (gs, 0, label);
4989 : 69448 : }
4990 : :
4991 : : /* Return true if GS is a GIMPLE_DEBUG statement. */
4992 : :
4993 : : inline bool
4994 : 65560676314 : is_gimple_debug (const gimple *gs)
4995 : : {
4996 : 55888094044 : return gimple_code (gs) == GIMPLE_DEBUG;
4997 : : }
4998 : :
4999 : :
5000 : : /* Return the first nondebug statement in GIMPLE sequence S. */
5001 : :
5002 : : inline gimple *
5003 : 4433090 : gimple_seq_first_nondebug_stmt (gimple_seq s)
5004 : : {
5005 : 4433090 : gimple_seq_node n = gimple_seq_first (s);
5006 : 4499225 : while (n && is_gimple_debug (n))
5007 : 66135 : n = n->next;
5008 : 4433090 : return n;
5009 : : }
5010 : :
5011 : :
5012 : : /* Return the last nondebug statement in GIMPLE sequence S. */
5013 : :
5014 : : inline gimple *
5015 : 16292825 : gimple_seq_last_nondebug_stmt (gimple_seq s)
5016 : : {
5017 : 16292825 : gimple_seq_node n;
5018 : 16292825 : for (n = gimple_seq_last (s);
5019 : 16449445 : n && is_gimple_debug (n);
5020 : 156620 : n = n->prev)
5021 : 159234 : if (n == s)
5022 : : return NULL;
5023 : : return n;
5024 : : }
5025 : :
5026 : :
5027 : : /* Return true if S is a GIMPLE_DEBUG BIND statement. */
5028 : :
5029 : : inline bool
5030 : 34473913182 : gimple_debug_bind_p (const gimple *s)
5031 : : {
5032 : 16125502029 : if (is_gimple_debug (s))
5033 : 15448538452 : return s->subcode == GIMPLE_DEBUG_BIND;
5034 : :
5035 : : return false;
5036 : : }
5037 : :
5038 : : /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
5039 : :
5040 : : inline tree
5041 : 915951855 : gimple_debug_bind_get_var (const gimple *dbg)
5042 : : {
5043 : 915951855 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5044 : 915951855 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5045 : 915951855 : return gimple_op (dbg, 0);
5046 : : }
5047 : :
5048 : : /* Return the value bound to the variable in a GIMPLE_DEBUG bind
5049 : : statement. */
5050 : :
5051 : : inline tree
5052 : 535459981 : gimple_debug_bind_get_value (const gimple *dbg)
5053 : : {
5054 : 535459981 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5055 : 535459981 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5056 : 535459981 : return gimple_op (dbg, 1);
5057 : : }
5058 : :
5059 : : /* Return a pointer to the value bound to the variable in a
5060 : : GIMPLE_DEBUG bind statement. */
5061 : :
5062 : : inline tree *
5063 : 2774546027 : gimple_debug_bind_get_value_ptr (gimple *dbg)
5064 : : {
5065 : 2774546027 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5066 : 2774546027 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5067 : 2774546027 : return gimple_op_ptr (dbg, 1);
5068 : : }
5069 : :
5070 : : /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
5071 : :
5072 : : inline void
5073 : 95048059 : gimple_debug_bind_set_var (gimple *dbg, tree var)
5074 : : {
5075 : 95048059 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5076 : 95048059 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5077 : 95048059 : gimple_set_op (dbg, 0, var);
5078 : 95048059 : }
5079 : :
5080 : : /* Set the value bound to the variable in a GIMPLE_DEBUG bind
5081 : : statement. */
5082 : :
5083 : : inline void
5084 : 58043662 : gimple_debug_bind_set_value (gimple *dbg, tree value)
5085 : : {
5086 : 58043662 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5087 : 58043662 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5088 : 58043662 : gimple_set_op (dbg, 1, value);
5089 : 58043662 : }
5090 : :
5091 : : /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
5092 : : optimized away. */
5093 : : #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
5094 : :
5095 : : /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
5096 : : statement. */
5097 : :
5098 : : inline void
5099 : 7150007 : gimple_debug_bind_reset_value (gimple *dbg)
5100 : : {
5101 : 7150007 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5102 : 7150007 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5103 : 7150007 : gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
5104 : 7150007 : }
5105 : :
5106 : : /* Return true if the GIMPLE_DEBUG bind statement is bound to a
5107 : : value. */
5108 : :
5109 : : inline bool
5110 : 9185830017 : gimple_debug_bind_has_value_p (gimple *dbg)
5111 : : {
5112 : 9185830017 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5113 : 9185830017 : gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5114 : 9185830017 : return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
5115 : : }
5116 : :
5117 : : #undef GIMPLE_DEBUG_BIND_NOVALUE
5118 : :
5119 : : /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
5120 : :
5121 : : inline bool
5122 : 85560149 : gimple_debug_source_bind_p (const gimple *s)
5123 : : {
5124 : 84714923 : if (is_gimple_debug (s))
5125 : 55531854 : return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
5126 : :
5127 : : return false;
5128 : : }
5129 : :
5130 : : /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
5131 : :
5132 : : inline tree
5133 : 1064654 : gimple_debug_source_bind_get_var (const gimple *dbg)
5134 : : {
5135 : 1064654 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5136 : 1064654 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5137 : 1064654 : return gimple_op (dbg, 0);
5138 : : }
5139 : :
5140 : : /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
5141 : : statement. */
5142 : :
5143 : : inline tree
5144 : 1034925 : gimple_debug_source_bind_get_value (const gimple *dbg)
5145 : : {
5146 : 1034925 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5147 : 1034925 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5148 : 1034925 : return gimple_op (dbg, 1);
5149 : : }
5150 : :
5151 : : /* Return a pointer to the value bound to the variable in a
5152 : : GIMPLE_DEBUG source bind statement. */
5153 : :
5154 : : inline tree *
5155 : 113872 : gimple_debug_source_bind_get_value_ptr (gimple *dbg)
5156 : : {
5157 : 113872 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5158 : 113872 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5159 : 113872 : return gimple_op_ptr (dbg, 1);
5160 : : }
5161 : :
5162 : : /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
5163 : :
5164 : : inline void
5165 : 1026658 : gimple_debug_source_bind_set_var (gimple *dbg, tree var)
5166 : : {
5167 : 1026658 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5168 : 1026658 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5169 : 1026658 : gimple_set_op (dbg, 0, var);
5170 : 1026658 : }
5171 : :
5172 : : /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
5173 : : statement. */
5174 : :
5175 : : inline void
5176 : 579983 : gimple_debug_source_bind_set_value (gimple *dbg, tree value)
5177 : : {
5178 : 579983 : GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5179 : 579983 : gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5180 : 579983 : gimple_set_op (dbg, 1, value);
5181 : 579983 : }
5182 : :
5183 : : /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
5184 : :
5185 : : inline bool
5186 : 289854409 : gimple_debug_begin_stmt_p (const gimple *s)
5187 : : {
5188 : 301052947 : if (is_gimple_debug (s))
5189 : 80615062 : return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
5190 : :
5191 : : return false;
5192 : : }
5193 : :
5194 : : /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
5195 : :
5196 : : inline bool
5197 : 1299940 : gimple_debug_inline_entry_p (const gimple *s)
5198 : : {
5199 : 8468327 : if (is_gimple_debug (s))
5200 : 12866 : return s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5201 : :
5202 : : return false;
5203 : : }
5204 : :
5205 : : /* Return true if S is a GIMPLE_DEBUG non-binding marker statement. */
5206 : :
5207 : : inline bool
5208 : 713548934 : gimple_debug_nonbind_marker_p (const gimple *s)
5209 : : {
5210 : 675142558 : if (is_gimple_debug (s))
5211 : 553097040 : return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
5212 : 553097040 : || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5213 : :
5214 : : return false;
5215 : : }
5216 : :
5217 : : /* Return the line number for EXPR, or return -1 if we have no line
5218 : : number information for it. */
5219 : : inline int
5220 : 0 : get_lineno (const gimple *stmt)
5221 : : {
5222 : 0 : location_t loc;
5223 : :
5224 : 0 : if (!stmt)
5225 : : return -1;
5226 : :
5227 : 0 : loc = gimple_location (stmt);
5228 : 0 : if (loc == UNKNOWN_LOCATION)
5229 : : return -1;
5230 : :
5231 : 0 : return LOCATION_LINE (loc);
5232 : : }
5233 : :
5234 : : /* Return a pointer to the body for the OMP statement GS. */
5235 : :
5236 : : inline gimple_seq *
5237 : 447343 : gimple_omp_body_ptr (gimple *gs)
5238 : : {
5239 : 447260 : return &static_cast <gimple_statement_omp *> (gs)->body;
5240 : : }
5241 : :
5242 : : /* Return the body for the OMP statement GS. */
5243 : :
5244 : : inline gimple_seq
5245 : 397067 : gimple_omp_body (const gimple *gs)
5246 : : {
5247 : 397067 : return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
5248 : : }
5249 : :
5250 : : /* Set BODY to be the body for the OMP statement GS. */
5251 : :
5252 : : inline void
5253 : 292026 : gimple_omp_set_body (gimple *gs, gimple_seq body)
5254 : : {
5255 : 170264 : static_cast <gimple_statement_omp *> (gs)->body = body;
5256 : 119243 : }
5257 : :
5258 : :
5259 : : /* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
5260 : :
5261 : : inline tree
5262 : 820 : gimple_omp_critical_name (const gomp_critical *crit_stmt)
5263 : : {
5264 : 820 : return crit_stmt->name;
5265 : : }
5266 : :
5267 : :
5268 : : /* Return a pointer to the name associated with OMP critical statement
5269 : : CRIT_STMT. */
5270 : :
5271 : : inline tree *
5272 : 1352 : gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
5273 : : {
5274 : 1352 : return &crit_stmt->name;
5275 : : }
5276 : :
5277 : :
5278 : : /* Set NAME to be the name associated with OMP critical statement
5279 : : CRIT_STMT. */
5280 : :
5281 : : inline void
5282 : 546 : gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
5283 : : {
5284 : 546 : crit_stmt->name = name;
5285 : : }
5286 : :
5287 : :
5288 : : /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
5289 : :
5290 : : inline tree
5291 : 16 : gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
5292 : : {
5293 : 16 : return crit_stmt->clauses;
5294 : : }
5295 : :
5296 : :
5297 : : /* Return a pointer to the clauses associated with OMP critical statement
5298 : : CRIT_STMT. */
5299 : :
5300 : : inline tree *
5301 : 1352 : gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
5302 : : {
5303 : 1352 : return &crit_stmt->clauses;
5304 : : }
5305 : :
5306 : :
5307 : : /* Set CLAUSES to be the clauses associated with OMP critical statement
5308 : : CRIT_STMT. */
5309 : :
5310 : : inline void
5311 : 546 : gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
5312 : : {
5313 : 546 : crit_stmt->clauses = clauses;
5314 : : }
5315 : :
5316 : :
5317 : : /* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
5318 : :
5319 : : inline tree
5320 : 7030 : gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
5321 : : {
5322 : 7030 : return ord_stmt->clauses;
5323 : : }
5324 : :
5325 : :
5326 : : /* Return a pointer to the clauses associated with OMP ordered statement
5327 : : ORD_STMT. */
5328 : :
5329 : : inline tree *
5330 : 5431 : gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
5331 : : {
5332 : 5431 : return &ord_stmt->clauses;
5333 : : }
5334 : :
5335 : :
5336 : : /* Set CLAUSES to be the clauses associated with OMP ordered statement
5337 : : ORD_STMT. */
5338 : :
5339 : : inline void
5340 : 1838 : gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
5341 : : {
5342 : 1838 : ord_stmt->clauses = clauses;
5343 : : }
5344 : :
5345 : :
5346 : : /* Return the clauses associated with OMP_SCAN statement SCAN_STMT. */
5347 : :
5348 : : inline tree
5349 : 3171 : gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
5350 : : {
5351 : 3171 : return scan_stmt->clauses;
5352 : : }
5353 : :
5354 : :
5355 : : /* Return a pointer to the clauses associated with OMP scan statement
5356 : : ORD_STMT. */
5357 : :
5358 : : inline tree *
5359 : 824 : gimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
5360 : : {
5361 : 824 : return &scan_stmt->clauses;
5362 : : }
5363 : :
5364 : :
5365 : : /* Set CLAUSES to be the clauses associated with OMP scan statement
5366 : : ORD_STMT. */
5367 : :
5368 : : inline void
5369 : 1284 : gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
5370 : : {
5371 : 1284 : scan_stmt->clauses = clauses;
5372 : : }
5373 : :
5374 : :
5375 : : /* Return the clauses associated with OMP_TASKGROUP statement GS. */
5376 : :
5377 : : inline tree
5378 : 1143 : gimple_omp_taskgroup_clauses (const gimple *gs)
5379 : : {
5380 : 1143 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5381 : 1143 : return
5382 : 1143 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5383 : : }
5384 : :
5385 : :
5386 : : /* Return a pointer to the clauses associated with OMP taskgroup statement
5387 : : GS. */
5388 : :
5389 : : inline tree *
5390 : 76 : gimple_omp_taskgroup_clauses_ptr (gimple *gs)
5391 : : {
5392 : 76 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5393 : 76 : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5394 : : }
5395 : :
5396 : :
5397 : : /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
5398 : : GS. */
5399 : :
5400 : : inline void
5401 : 611 : gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
5402 : : {
5403 : 611 : GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5404 : 611 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5405 : 611 : = clauses;
5406 : 611 : }
5407 : :
5408 : :
5409 : : /* Return the clauses associated with OMP_MASKED statement GS. */
5410 : :
5411 : : inline tree
5412 : 792 : gimple_omp_masked_clauses (const gimple *gs)
5413 : : {
5414 : 792 : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5415 : 792 : return
5416 : 792 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5417 : : }
5418 : :
5419 : :
5420 : : /* Return a pointer to the clauses associated with OMP masked statement
5421 : : GS. */
5422 : :
5423 : : inline tree *
5424 : : gimple_omp_masked_clauses_ptr (gimple *gs)
5425 : : {
5426 : : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5427 : : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5428 : : }
5429 : :
5430 : :
5431 : : /* Set CLAUSES to be the clauses associated with OMP masked statement
5432 : : GS. */
5433 : :
5434 : : inline void
5435 : 446 : gimple_omp_masked_set_clauses (gimple *gs, tree clauses)
5436 : : {
5437 : 446 : GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5438 : 446 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5439 : 446 : = clauses;
5440 : 446 : }
5441 : :
5442 : :
5443 : : /* Return the clauses associated with OMP_SCOPE statement GS. */
5444 : :
5445 : : inline tree
5446 : 864 : gimple_omp_scope_clauses (const gimple *gs)
5447 : : {
5448 : 864 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5449 : 864 : return
5450 : 864 : static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5451 : : }
5452 : :
5453 : :
5454 : : /* Return a pointer to the clauses associated with OMP scope statement
5455 : : GS. */
5456 : :
5457 : : inline tree *
5458 : 0 : gimple_omp_scope_clauses_ptr (gimple *gs)
5459 : : {
5460 : 0 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5461 : 0 : return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5462 : : }
5463 : :
5464 : :
5465 : : /* Set CLAUSES to be the clauses associated with OMP scope statement
5466 : : GS. */
5467 : :
5468 : : inline void
5469 : 260 : gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
5470 : : {
5471 : 260 : GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5472 : 260 : static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5473 : 260 : = clauses;
5474 : 260 : }
5475 : :
5476 : : /* Return the clauses associated with OMP_DISPATCH statement GS. */
5477 : :
5478 : : inline tree
5479 : 401 : gimple_omp_dispatch_clauses (const gimple *gs)
5480 : : {
5481 : 401 : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5482 : 401 : return static_cast<const gimple_statement_omp_single_layout *> (gs)->clauses;
5483 : : }
5484 : :
5485 : : /* Return a pointer to the clauses associated with OMP dispatch statement
5486 : : GS. */
5487 : :
5488 : : inline tree *
5489 : : gimple_omp_dispatch_clauses_ptr (gimple *gs)
5490 : : {
5491 : : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5492 : : return &static_cast<gimple_statement_omp_single_layout *> (gs)->clauses;
5493 : : }
5494 : :
5495 : : /* Set CLAUSES to be the clauses associated with OMP dispatch statement
5496 : : GS. */
5497 : :
5498 : : inline void
5499 : 845 : gimple_omp_dispatch_set_clauses (gimple *gs, tree clauses)
5500 : : {
5501 : 845 : GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5502 : 845 : static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5503 : 845 : }
5504 : :
5505 : : /* Return the clauses associated with OMP_INTEROP statement GS. */
5506 : :
5507 : : inline tree
5508 : 164 : gimple_omp_interop_clauses (const gimple *gs)
5509 : : {
5510 : 164 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5511 : 164 : return static_cast<const gimple_statement_omp_single_layout *> (gs)->clauses;
5512 : : }
5513 : :
5514 : : /* Return a pointer to the clauses associated with OMP_INTEROP statement GS. */
5515 : :
5516 : : inline tree *
5517 : 35 : gimple_omp_interop_clauses_ptr (gimple *gs)
5518 : : {
5519 : 35 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5520 : 35 : return &static_cast<gimple_statement_omp_single_layout *> (gs)->clauses;
5521 : : }
5522 : :
5523 : : /* Set CLAUSES to be the clauses associated with OMP interop statement
5524 : : GS. */
5525 : :
5526 : : inline void
5527 : 612 : gimple_omp_interop_set_clauses (gimple *gs, tree clauses)
5528 : : {
5529 : 612 : GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5530 : 612 : static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5531 : 612 : }
5532 : :
5533 : : /* Return the kind of the OMP_FOR statemement G. */
5534 : :
5535 : : inline int
5536 : 1193335 : gimple_omp_for_kind (const gimple *g)
5537 : : {
5538 : 1193335 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5539 : 1193335 : return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
5540 : : }
5541 : :
5542 : :
5543 : : /* Set the kind of the OMP_FOR statement G. */
5544 : :
5545 : : inline void
5546 : 53374 : gimple_omp_for_set_kind (gomp_for *g, int kind)
5547 : : {
5548 : 53374 : g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
5549 : 53374 : | (kind & GF_OMP_FOR_KIND_MASK);
5550 : : }
5551 : :
5552 : :
5553 : : /* Return true if OMP_FOR statement G has the
5554 : : GF_OMP_FOR_COMBINED flag set. */
5555 : :
5556 : : inline bool
5557 : 162788 : gimple_omp_for_combined_p (const gimple *g)
5558 : : {
5559 : 162788 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5560 : 162788 : return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
5561 : : }
5562 : :
5563 : :
5564 : : /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5565 : : the boolean value of COMBINED_P. */
5566 : :
5567 : : inline void
5568 : 15525 : gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
5569 : : {
5570 : 15525 : if (combined_p)
5571 : 1579 : g->subcode |= GF_OMP_FOR_COMBINED;
5572 : : else
5573 : : g->subcode &= ~GF_OMP_FOR_COMBINED;
5574 : 13946 : }
5575 : :
5576 : :
5577 : : /* Return true if the OMP_FOR statement G has the
5578 : : GF_OMP_FOR_COMBINED_INTO flag set. */
5579 : :
5580 : : inline bool
5581 : 171163 : gimple_omp_for_combined_into_p (const gimple *g)
5582 : : {
5583 : 171163 : GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5584 : 171163 : return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
5585 : : }
5586 : :
5587 : :
5588 : : /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5589 : : on the boolean value of COMBINED_P. */
5590 : :
5591 : : inline void
5592 : 15525 : gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
5593 : : {
5594 : 15525 : if (combined_p)
5595 : 15525 : g->subcode |= GF_OMP_FOR_COMBINED_INTO;
5596 : : else
5597 : : g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
5598 : : }
5599 : :
5600 : :
5601 : : /* Return the clauses associated with the OMP_FOR statement GS. */
5602 : :
5603 : : inline tree
5604 : 607123 : gimple_omp_for_clauses (const gimple *gs)
5605 : : {
5606 : 607123 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5607 : 607123 : return omp_for_stmt->clauses;
5608 : : }
5609 : :
5610 : :
5611 : : /* Return a pointer to the clauses associated with the OMP_FOR statement
5612 : : GS. */
5613 : :
5614 : : inline tree *
5615 : 256697 : gimple_omp_for_clauses_ptr (gimple *gs)
5616 : : {
5617 : 256697 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5618 : 256697 : return &omp_for_stmt->clauses;
5619 : : }
5620 : :
5621 : :
5622 : : /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5623 : : GS. */
5624 : :
5625 : : inline void
5626 : 67833 : gimple_omp_for_set_clauses (gimple *gs, tree clauses)
5627 : : {
5628 : 67833 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5629 : 67833 : omp_for_stmt->clauses = clauses;
5630 : 11585 : }
5631 : :
5632 : :
5633 : : /* Get the collapse count of the OMP_FOR statement GS. */
5634 : :
5635 : : inline size_t
5636 : 783084 : gimple_omp_for_collapse (const gimple *gs)
5637 : : {
5638 : 783084 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5639 : 783084 : return omp_for_stmt->collapse;
5640 : : }
5641 : :
5642 : :
5643 : : /* Return the condition code associated with the OMP_FOR statement GS. */
5644 : :
5645 : : inline enum tree_code
5646 : 199298 : gimple_omp_for_cond (const gimple *gs, size_t i)
5647 : : {
5648 : 199298 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5649 : 199298 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5650 : 199298 : return omp_for_stmt->iter[i].cond;
5651 : : }
5652 : :
5653 : :
5654 : : /* Set COND to be the condition code for the OMP_FOR statement GS. */
5655 : :
5656 : : inline void
5657 : 75601 : gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
5658 : : {
5659 : 75601 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5660 : 75601 : gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
5661 : : && i < omp_for_stmt->collapse);
5662 : 75601 : omp_for_stmt->iter[i].cond = cond;
5663 : 75601 : }
5664 : :
5665 : :
5666 : : /* Return the index variable for the OMP_FOR statement GS. */
5667 : :
5668 : : inline tree
5669 : 217054 : gimple_omp_for_index (const gimple *gs, size_t i)
5670 : : {
5671 : 217054 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5672 : 217054 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5673 : 217054 : return omp_for_stmt->iter[i].index;
5674 : : }
5675 : :
5676 : :
5677 : : /* Return a pointer to the index variable for the OMP_FOR statement GS. */
5678 : :
5679 : : inline tree *
5680 : 354514 : gimple_omp_for_index_ptr (gimple *gs, size_t i)
5681 : : {
5682 : 354514 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5683 : 354514 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5684 : 354514 : return &omp_for_stmt->iter[i].index;
5685 : : }
5686 : :
5687 : :
5688 : : /* Set INDEX to be the index variable for the OMP_FOR statement GS. */
5689 : :
5690 : : inline void
5691 : 75601 : gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
5692 : : {
5693 : 75601 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5694 : 75601 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5695 : 75601 : omp_for_stmt->iter[i].index = index;
5696 : 75601 : }
5697 : :
5698 : :
5699 : : /* Return the initial value for the OMP_FOR statement GS. */
5700 : :
5701 : : inline tree
5702 : 263755 : gimple_omp_for_initial (const gimple *gs, size_t i)
5703 : : {
5704 : 263755 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5705 : 263755 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5706 : 263755 : return omp_for_stmt->iter[i].initial;
5707 : : }
5708 : :
5709 : :
5710 : : /* Return a pointer to the initial value for the OMP_FOR statement GS. */
5711 : :
5712 : : inline tree *
5713 : 422654 : gimple_omp_for_initial_ptr (gimple *gs, size_t i)
5714 : : {
5715 : 422654 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5716 : 422654 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5717 : 422654 : return &omp_for_stmt->iter[i].initial;
5718 : : }
5719 : :
5720 : :
5721 : : /* Set INITIAL to be the initial value for the OMP_FOR statement GS. */
5722 : :
5723 : : inline void
5724 : 75601 : gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
5725 : : {
5726 : 75601 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5727 : 75601 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5728 : 75601 : omp_for_stmt->iter[i].initial = initial;
5729 : 75601 : }
5730 : :
5731 : :
5732 : : /* Return the final value for the OMP_FOR statement GS. */
5733 : :
5734 : : inline tree
5735 : 263573 : gimple_omp_for_final (const gimple *gs, size_t i)
5736 : : {
5737 : 263573 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5738 : 263573 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5739 : 263573 : return omp_for_stmt->iter[i].final;
5740 : : }
5741 : :
5742 : :
5743 : : /* Return a pointer to the final value for the OMP_FOR statement GS. */
5744 : :
5745 : : inline tree *
5746 : 422654 : gimple_omp_for_final_ptr (gimple *gs, size_t i)
5747 : : {
5748 : 422654 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5749 : 422654 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5750 : 422654 : return &omp_for_stmt->iter[i].final;
5751 : : }
5752 : :
5753 : :
5754 : : /* Set FINAL to be the final value for the OMP_FOR statement GS. */
5755 : :
5756 : : inline void
5757 : 75601 : gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
5758 : : {
5759 : 75601 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5760 : 75601 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5761 : 75601 : omp_for_stmt->iter[i].final = final;
5762 : 75601 : }
5763 : :
5764 : :
5765 : : /* Return the increment value for the OMP_FOR statement GS. */
5766 : :
5767 : : inline tree
5768 : 271732 : gimple_omp_for_incr (const gimple *gs, size_t i)
5769 : : {
5770 : 271732 : const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5771 : 271732 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5772 : 271732 : return omp_for_stmt->iter[i].incr;
5773 : : }
5774 : :
5775 : :
5776 : : /* Return a pointer to the increment value for the OMP_FOR statement GS. */
5777 : :
5778 : : inline tree *
5779 : 350402 : gimple_omp_for_incr_ptr (gimple *gs, size_t i)
5780 : : {
5781 : 350402 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5782 : 350402 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5783 : 350402 : return &omp_for_stmt->iter[i].incr;
5784 : : }
5785 : :
5786 : :
5787 : : /* Set INCR to be the increment value for the OMP_FOR statement GS. */
5788 : :
5789 : : inline void
5790 : 75601 : gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
5791 : : {
5792 : 75601 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5793 : 75601 : gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5794 : 75601 : omp_for_stmt->iter[i].incr = incr;
5795 : 75601 : }
5796 : :
5797 : :
5798 : : /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5799 : : statement GS starts. */
5800 : :
5801 : : inline gimple_seq *
5802 : 294164 : gimple_omp_for_pre_body_ptr (gimple *gs)
5803 : : {
5804 : 194476 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5805 : 194476 : return &omp_for_stmt->pre_body;
5806 : : }
5807 : :
5808 : :
5809 : : /* Return the sequence of statements to execute before the OMP_FOR
5810 : : statement GS starts. */
5811 : :
5812 : : inline gimple_seq
5813 : 128252 : gimple_omp_for_pre_body (const gimple *gs)
5814 : : {
5815 : 128252 : return *gimple_omp_for_pre_body_ptr (const_cast <gimple *> (gs));
5816 : : }
5817 : :
5818 : :
5819 : : /* Set PRE_BODY to be the sequence of statements to execute before the
5820 : : OMP_FOR statement GS starts. */
5821 : :
5822 : : inline void
5823 : 51209 : gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
5824 : : {
5825 : 51209 : gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5826 : 51209 : omp_for_stmt->pre_body = pre_body;
5827 : 2448 : }
5828 : :
5829 : : /* Return the clauses associated with OMP_PARALLEL GS. */
5830 : :
5831 : : inline tree
5832 : 116403 : gimple_omp_parallel_clauses (const gimple *gs)
5833 : : {
5834 : 116403 : const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
5835 : 116403 : return omp_parallel_stmt->clauses;
5836 : : }
5837 : :
5838 : :
5839 : : /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5840 : :
5841 : : inline tree *
5842 : 65754 : gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
5843 : : {
5844 : 65754 : return &omp_parallel_stmt->clauses;
5845 : : }
5846 : :
5847 : :
5848 : : /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5849 : :
5850 : : inline void
5851 : 18472 : gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
5852 : : tree clauses)
5853 : : {
5854 : 66 : omp_parallel_stmt->clauses = clauses;
5855 : 66 : }
5856 : :
5857 : :
5858 : : /* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5859 : :
5860 : : inline tree
5861 : 18406 : gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
5862 : : {
5863 : 18406 : return omp_parallel_stmt->child_fn;
5864 : : }
5865 : :
5866 : : /* Return a pointer to the child function used to hold the body of
5867 : : OMP_PARALLEL_STMT. */
5868 : :
5869 : : inline tree *
5870 : 65754 : gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
5871 : : {
5872 : 65754 : return &omp_parallel_stmt->child_fn;
5873 : : }
5874 : :
5875 : :
5876 : : /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5877 : :
5878 : : inline void
5879 : 36509 : gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
5880 : : tree child_fn)
5881 : : {
5882 : 18103 : omp_parallel_stmt->child_fn = child_fn;
5883 : : }
5884 : :
5885 : :
5886 : : /* Return the artificial argument used to send variables and values
5887 : : from the parent to the children threads in OMP_PARALLEL_STMT. */
5888 : :
5889 : : inline tree
5890 : 16401 : gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
5891 : : {
5892 : 16401 : return omp_parallel_stmt->data_arg;
5893 : : }
5894 : :
5895 : :
5896 : : /* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5897 : :
5898 : : inline tree *
5899 : 65754 : gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
5900 : : {
5901 : 65754 : return &omp_parallel_stmt->data_arg;
5902 : : }
5903 : :
5904 : :
5905 : : /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5906 : :
5907 : : inline void
5908 : 18406 : gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
5909 : : tree data_arg)
5910 : : {
5911 : 0 : omp_parallel_stmt->data_arg = data_arg;
5912 : : }
5913 : :
5914 : : /* Return the clauses associated with OMP_TASK GS. */
5915 : :
5916 : : inline tree
5917 : 28024 : gimple_omp_task_clauses (const gimple *gs)
5918 : : {
5919 : 28024 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5920 : 28024 : return omp_task_stmt->clauses;
5921 : : }
5922 : :
5923 : :
5924 : : /* Return a pointer to the clauses associated with OMP_TASK GS. */
5925 : :
5926 : : inline tree *
5927 : 16855 : gimple_omp_task_clauses_ptr (gimple *gs)
5928 : : {
5929 : 16855 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5930 : 16855 : return &omp_task_stmt->clauses;
5931 : : }
5932 : :
5933 : :
5934 : : /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5935 : : GS. */
5936 : :
5937 : : inline void
5938 : 6101 : gimple_omp_task_set_clauses (gimple *gs, tree clauses)
5939 : : {
5940 : 6101 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5941 : 6101 : omp_task_stmt->clauses = clauses;
5942 : 513 : }
5943 : :
5944 : :
5945 : : /* Return true if OMP task statement G has the
5946 : : GF_OMP_TASK_TASKLOOP flag set. */
5947 : :
5948 : : inline bool
5949 : 21997 : gimple_omp_task_taskloop_p (const gimple *g)
5950 : : {
5951 : 21997 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5952 : 21997 : return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0;
5953 : : }
5954 : :
5955 : :
5956 : : /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5957 : : value of TASKLOOP_P. */
5958 : :
5959 : : inline void
5960 : 1579 : gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
5961 : : {
5962 : 1579 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5963 : 1579 : if (taskloop_p)
5964 : 1579 : g->subcode |= GF_OMP_TASK_TASKLOOP;
5965 : : else
5966 : 0 : g->subcode &= ~GF_OMP_TASK_TASKLOOP;
5967 : 1579 : }
5968 : :
5969 : :
5970 : : /* Return true if OMP task statement G has the
5971 : : GF_OMP_TASK_TASKWAIT flag set. */
5972 : :
5973 : : inline bool
5974 : 24826 : gimple_omp_task_taskwait_p (const gimple *g)
5975 : : {
5976 : 24826 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5977 : 24826 : return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKWAIT) != 0;
5978 : : }
5979 : :
5980 : :
5981 : : /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5982 : : value of TASKWAIT_P. */
5983 : :
5984 : : inline void
5985 : 90 : gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
5986 : : {
5987 : 90 : GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5988 : 90 : if (taskwait_p)
5989 : 90 : g->subcode |= GF_OMP_TASK_TASKWAIT;
5990 : : else
5991 : 0 : g->subcode &= ~GF_OMP_TASK_TASKWAIT;
5992 : 90 : }
5993 : :
5994 : :
5995 : : /* Return the child function used to hold the body of OMP_TASK GS. */
5996 : :
5997 : : inline tree
5998 : 4106 : gimple_omp_task_child_fn (const gimple *gs)
5999 : : {
6000 : 4106 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6001 : 4106 : return omp_task_stmt->child_fn;
6002 : : }
6003 : :
6004 : : /* Return a pointer to the child function used to hold the body of
6005 : : OMP_TASK GS. */
6006 : :
6007 : : inline tree *
6008 : 15673 : gimple_omp_task_child_fn_ptr (gimple *gs)
6009 : : {
6010 : 15673 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6011 : 15673 : return &omp_task_stmt->child_fn;
6012 : : }
6013 : :
6014 : :
6015 : : /* Set CHILD_FN to be the child function for OMP_TASK GS. */
6016 : :
6017 : : inline void
6018 : 11005 : gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
6019 : : {
6020 : 11005 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6021 : 11005 : omp_task_stmt->child_fn = child_fn;
6022 : : }
6023 : :
6024 : :
6025 : : /* Return the artificial argument used to send variables and values
6026 : : from the parent to the children threads in OMP_TASK GS. */
6027 : :
6028 : : inline tree
6029 : 3767 : gimple_omp_task_data_arg (const gimple *gs)
6030 : : {
6031 : 3767 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6032 : 3767 : return omp_task_stmt->data_arg;
6033 : : }
6034 : :
6035 : :
6036 : : /* Return a pointer to the data argument for OMP_TASK GS. */
6037 : :
6038 : : inline tree *
6039 : 15673 : gimple_omp_task_data_arg_ptr (gimple *gs)
6040 : : {
6041 : 15673 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6042 : 15673 : return &omp_task_stmt->data_arg;
6043 : : }
6044 : :
6045 : :
6046 : : /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6047 : :
6048 : : inline void
6049 : 5588 : gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
6050 : : {
6051 : 5588 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6052 : 5588 : omp_task_stmt->data_arg = data_arg;
6053 : : }
6054 : :
6055 : :
6056 : : /* Return the clauses associated with OMP_TASK GS. */
6057 : :
6058 : : inline tree
6059 : 59010 : gimple_omp_taskreg_clauses (const gimple *gs)
6060 : : {
6061 : 59010 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6062 : 59010 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6063 : 59010 : return omp_taskreg_stmt->clauses;
6064 : : }
6065 : :
6066 : :
6067 : : /* Return a pointer to the clauses associated with OMP_TASK GS. */
6068 : :
6069 : : inline tree *
6070 : 2762 : gimple_omp_taskreg_clauses_ptr (gimple *gs)
6071 : : {
6072 : 2762 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6073 : 2762 : = as_a <gimple_statement_omp_taskreg *> (gs);
6074 : 2762 : return &omp_taskreg_stmt->clauses;
6075 : : }
6076 : :
6077 : :
6078 : : /* Set CLAUSES to be the list of clauses associated with OMP_TASK
6079 : : GS. */
6080 : :
6081 : : inline void
6082 : 19833 : gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
6083 : : {
6084 : 19833 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6085 : 19833 : = as_a <gimple_statement_omp_taskreg *> (gs);
6086 : 19833 : omp_taskreg_stmt->clauses = clauses;
6087 : 961 : }
6088 : :
6089 : :
6090 : : /* Return the child function used to hold the body of OMP_TASK GS. */
6091 : :
6092 : : inline tree
6093 : 29414 : gimple_omp_taskreg_child_fn (const gimple *gs)
6094 : : {
6095 : 29414 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6096 : 29414 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6097 : 29414 : return omp_taskreg_stmt->child_fn;
6098 : : }
6099 : :
6100 : : /* Return a pointer to the child function used to hold the body of
6101 : : OMP_TASK GS. */
6102 : :
6103 : : inline tree *
6104 : : gimple_omp_taskreg_child_fn_ptr (gimple *gs)
6105 : : {
6106 : : gimple_statement_omp_taskreg *omp_taskreg_stmt
6107 : : = as_a <gimple_statement_omp_taskreg *> (gs);
6108 : : return &omp_taskreg_stmt->child_fn;
6109 : : }
6110 : :
6111 : :
6112 : : /* Set CHILD_FN to be the child function for OMP_TASK GS. */
6113 : :
6114 : : inline void
6115 : : gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
6116 : : {
6117 : : gimple_statement_omp_taskreg *omp_taskreg_stmt
6118 : : = as_a <gimple_statement_omp_taskreg *> (gs);
6119 : : omp_taskreg_stmt->child_fn = child_fn;
6120 : : }
6121 : :
6122 : :
6123 : : /* Return the artificial argument used to send variables and values
6124 : : from the parent to the children threads in OMP_TASK GS. */
6125 : :
6126 : : inline tree
6127 : 40709 : gimple_omp_taskreg_data_arg (const gimple *gs)
6128 : : {
6129 : 40709 : const gimple_statement_omp_taskreg *omp_taskreg_stmt
6130 : 18149 : = as_a <const gimple_statement_omp_taskreg *> (gs);
6131 : 40709 : return omp_taskreg_stmt->data_arg;
6132 : : }
6133 : :
6134 : :
6135 : : /* Return a pointer to the data argument for OMP_TASK GS. */
6136 : :
6137 : : inline tree *
6138 : : gimple_omp_taskreg_data_arg_ptr (gimple *gs)
6139 : : {
6140 : : gimple_statement_omp_taskreg *omp_taskreg_stmt
6141 : : = as_a <gimple_statement_omp_taskreg *> (gs);
6142 : : return &omp_taskreg_stmt->data_arg;
6143 : : }
6144 : :
6145 : :
6146 : : /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6147 : :
6148 : : inline void
6149 : 17998 : gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
6150 : : {
6151 : 17998 : gimple_statement_omp_taskreg *omp_taskreg_stmt
6152 : 17998 : = as_a <gimple_statement_omp_taskreg *> (gs);
6153 : 17998 : omp_taskreg_stmt->data_arg = data_arg;
6154 : 17998 : }
6155 : :
6156 : :
6157 : : /* Return the copy function used to hold the body of OMP_TASK GS. */
6158 : :
6159 : : inline tree
6160 : 4799 : gimple_omp_task_copy_fn (const gimple *gs)
6161 : : {
6162 : 4799 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6163 : 4799 : return omp_task_stmt->copy_fn;
6164 : : }
6165 : :
6166 : : /* Return a pointer to the copy function used to hold the body of
6167 : : OMP_TASK GS. */
6168 : :
6169 : : inline tree *
6170 : 15673 : gimple_omp_task_copy_fn_ptr (gimple *gs)
6171 : : {
6172 : 15673 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6173 : 15673 : return &omp_task_stmt->copy_fn;
6174 : : }
6175 : :
6176 : :
6177 : : /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
6178 : :
6179 : : inline void
6180 : 6152 : gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
6181 : : {
6182 : 6152 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6183 : 6152 : omp_task_stmt->copy_fn = copy_fn;
6184 : 564 : }
6185 : :
6186 : :
6187 : : /* Return size of the data block in bytes in OMP_TASK GS. */
6188 : :
6189 : : inline tree
6190 : 3763 : gimple_omp_task_arg_size (const gimple *gs)
6191 : : {
6192 : 3763 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6193 : 3763 : return omp_task_stmt->arg_size;
6194 : : }
6195 : :
6196 : :
6197 : : /* Return a pointer to the data block size for OMP_TASK GS. */
6198 : :
6199 : : inline tree *
6200 : 15673 : gimple_omp_task_arg_size_ptr (gimple *gs)
6201 : : {
6202 : 15673 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6203 : 15673 : return &omp_task_stmt->arg_size;
6204 : : }
6205 : :
6206 : :
6207 : : /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
6208 : :
6209 : : inline void
6210 : 11005 : gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
6211 : : {
6212 : 11005 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6213 : 11005 : omp_task_stmt->arg_size = arg_size;
6214 : : }
6215 : :
6216 : :
6217 : : /* Return align of the data block in bytes in OMP_TASK GS. */
6218 : :
6219 : : inline tree
6220 : 3763 : gimple_omp_task_arg_align (const gimple *gs)
6221 : : {
6222 : 3763 : const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6223 : 3763 : return omp_task_stmt->arg_align;
6224 : : }
6225 : :
6226 : :
6227 : : /* Return a pointer to the data block align for OMP_TASK GS. */
6228 : :
6229 : : inline tree *
6230 : 15673 : gimple_omp_task_arg_align_ptr (gimple *gs)
6231 : : {
6232 : 15673 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6233 : 15673 : return &omp_task_stmt->arg_align;
6234 : : }
6235 : :
6236 : :
6237 : : /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
6238 : :
6239 : : inline void
6240 : 11005 : gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
6241 : : {
6242 : 11005 : gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6243 : 5417 : omp_task_stmt->arg_align = arg_align;
6244 : 1982 : }
6245 : :
6246 : :
6247 : : /* Return the clauses associated with OMP_SINGLE GS. */
6248 : :
6249 : : inline tree
6250 : 3607 : gimple_omp_single_clauses (const gimple *gs)
6251 : : {
6252 : 3607 : const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
6253 : 3607 : return omp_single_stmt->clauses;
6254 : : }
6255 : :
6256 : :
6257 : : /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
6258 : :
6259 : : inline tree *
6260 : 5032 : gimple_omp_single_clauses_ptr (gimple *gs)
6261 : : {
6262 : 5032 : gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
6263 : 5032 : return &omp_single_stmt->clauses;
6264 : : }
6265 : :
6266 : :
6267 : : /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
6268 : :
6269 : : inline void
6270 : 1274 : gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
6271 : : {
6272 : 0 : omp_single_stmt->clauses = clauses;
6273 : : }
6274 : :
6275 : :
6276 : : /* Return the clauses associated with OMP_TARGET GS. */
6277 : :
6278 : : inline tree
6279 : 179499 : gimple_omp_target_clauses (const gimple *gs)
6280 : : {
6281 : 179499 : const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
6282 : 179499 : return omp_target_stmt->clauses;
6283 : : }
6284 : :
6285 : :
6286 : : /* Return a pointer to the clauses associated with OMP_TARGET GS. */
6287 : :
6288 : : inline tree *
6289 : 159971 : gimple_omp_target_clauses_ptr (gimple *gs)
6290 : : {
6291 : 159971 : gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
6292 : 159971 : return &omp_target_stmt->clauses;
6293 : : }
6294 : :
6295 : :
6296 : : /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
6297 : :
6298 : : inline void
6299 : 42543 : gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
6300 : : tree clauses)
6301 : : {
6302 : 693 : omp_target_stmt->clauses = clauses;
6303 : 88 : }
6304 : :
6305 : :
6306 : : /* Return the kind of the OMP_TARGET G. */
6307 : :
6308 : : inline int
6309 : 1528889 : gimple_omp_target_kind (const gimple *g)
6310 : : {
6311 : 1528889 : GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
6312 : 1528889 : return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
6313 : : }
6314 : :
6315 : :
6316 : : /* Set the kind of the OMP_TARGET G. */
6317 : :
6318 : : inline void
6319 : 41762 : gimple_omp_target_set_kind (gomp_target *g, int kind)
6320 : : {
6321 : 41762 : g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
6322 : 41762 : | (kind & GF_OMP_TARGET_KIND_MASK);
6323 : : }
6324 : :
6325 : :
6326 : : /* Return the child function used to hold the body of OMP_TARGET_STMT. */
6327 : :
6328 : : inline tree
6329 : 27214 : gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
6330 : : {
6331 : 27214 : return omp_target_stmt->child_fn;
6332 : : }
6333 : :
6334 : : /* Return a pointer to the child function used to hold the body of
6335 : : OMP_TARGET_STMT. */
6336 : :
6337 : : inline tree *
6338 : 144737 : gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
6339 : : {
6340 : 144737 : return &omp_target_stmt->child_fn;
6341 : : }
6342 : :
6343 : :
6344 : : /* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
6345 : :
6346 : : inline void
6347 : 23909 : gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
6348 : : tree child_fn)
6349 : : {
6350 : 23909 : omp_target_stmt->child_fn = child_fn;
6351 : 23909 : }
6352 : :
6353 : :
6354 : : /* Return the artificial argument used to send variables and values
6355 : : from the parent to the children threads in OMP_TARGET_STMT. */
6356 : :
6357 : : inline tree
6358 : 56118 : gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
6359 : : {
6360 : 56118 : return omp_target_stmt->data_arg;
6361 : : }
6362 : :
6363 : :
6364 : : /* Return a pointer to the data argument for OMP_TARGET GS. */
6365 : :
6366 : : inline tree *
6367 : 144737 : gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
6368 : : {
6369 : 144737 : return &omp_target_stmt->data_arg;
6370 : : }
6371 : :
6372 : :
6373 : : /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
6374 : :
6375 : : inline void
6376 : 31275 : gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
6377 : : tree data_arg)
6378 : : {
6379 : 31275 : omp_target_stmt->data_arg = data_arg;
6380 : : }
6381 : :
6382 : :
6383 : : /* Return the clauses associated with OMP_TEAMS GS. */
6384 : :
6385 : : inline tree
6386 : 35481 : gimple_omp_teams_clauses (const gimple *gs)
6387 : : {
6388 : 35481 : const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
6389 : 35481 : return omp_teams_stmt->clauses;
6390 : : }
6391 : :
6392 : :
6393 : : /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
6394 : :
6395 : : inline tree *
6396 : 33964 : gimple_omp_teams_clauses_ptr (gimple *gs)
6397 : : {
6398 : 33964 : gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
6399 : 33964 : return &omp_teams_stmt->clauses;
6400 : : }
6401 : :
6402 : :
6403 : : /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
6404 : :
6405 : : inline void
6406 : 8813 : gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
6407 : : {
6408 : 8813 : omp_teams_stmt->clauses = clauses;
6409 : 0 : }
6410 : :
6411 : : /* Return the child function used to hold the body of OMP_TEAMS_STMT. */
6412 : :
6413 : : inline tree
6414 : 2535 : gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
6415 : : {
6416 : 2535 : return omp_teams_stmt->child_fn;
6417 : : }
6418 : :
6419 : : /* Return a pointer to the child function used to hold the body of
6420 : : OMP_TEAMS_STMT. */
6421 : :
6422 : : inline tree *
6423 : : gimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
6424 : : {
6425 : : return &omp_teams_stmt->child_fn;
6426 : : }
6427 : :
6428 : :
6429 : : /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT. */
6430 : :
6431 : : inline void
6432 : 2657 : gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
6433 : : {
6434 : 2657 : omp_teams_stmt->child_fn = child_fn;
6435 : : }
6436 : :
6437 : :
6438 : : /* Return the artificial argument used to send variables and values
6439 : : from the parent to the children threads in OMP_TEAMS_STMT. */
6440 : :
6441 : : inline tree
6442 : 2535 : gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
6443 : : {
6444 : 2535 : return omp_teams_stmt->data_arg;
6445 : : }
6446 : :
6447 : :
6448 : : /* Return a pointer to the data argument for OMP_TEAMS_STMT. */
6449 : :
6450 : : inline tree *
6451 : : gimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
6452 : : {
6453 : : return &omp_teams_stmt->data_arg;
6454 : : }
6455 : :
6456 : :
6457 : : /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT. */
6458 : :
6459 : : inline void
6460 : : gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
6461 : : {
6462 : : omp_teams_stmt->data_arg = data_arg;
6463 : : }
6464 : :
6465 : : /* Return the host flag of an OMP_TEAMS_STMT. */
6466 : :
6467 : : inline bool
6468 : 106439 : gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
6469 : : {
6470 : 106439 : return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
6471 : : }
6472 : :
6473 : : /* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6474 : :
6475 : : inline void
6476 : 2671 : gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
6477 : : {
6478 : 2671 : if (value)
6479 : 2671 : omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
6480 : : else
6481 : : omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
6482 : : }
6483 : :
6484 : : /* Return the clauses associated with OMP_SECTIONS GS. */
6485 : :
6486 : : inline tree
6487 : 3297 : gimple_omp_sections_clauses (const gimple *gs)
6488 : : {
6489 : 2919 : const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6490 : 3297 : return omp_sections_stmt->clauses;
6491 : : }
6492 : :
6493 : :
6494 : : /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6495 : :
6496 : : inline tree *
6497 : 2016 : gimple_omp_sections_clauses_ptr (gimple *gs)
6498 : : {
6499 : 2016 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6500 : 2016 : return &omp_sections_stmt->clauses;
6501 : : }
6502 : :
6503 : :
6504 : : /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6505 : : GS. */
6506 : :
6507 : : inline void
6508 : 634 : gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
6509 : : {
6510 : 634 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6511 : 8 : omp_sections_stmt->clauses = clauses;
6512 : : }
6513 : :
6514 : :
6515 : : /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6516 : : in GS. */
6517 : :
6518 : : inline tree
6519 : 420 : gimple_omp_sections_control (const gimple *gs)
6520 : : {
6521 : 420 : const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6522 : 420 : return omp_sections_stmt->control;
6523 : : }
6524 : :
6525 : :
6526 : : /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6527 : : GS. */
6528 : :
6529 : : inline tree *
6530 : 1554 : gimple_omp_sections_control_ptr (gimple *gs)
6531 : : {
6532 : 1554 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6533 : 1554 : return &omp_sections_stmt->control;
6534 : : }
6535 : :
6536 : :
6537 : : /* Set CONTROL to be the set of clauses associated with the
6538 : : GIMPLE_OMP_SECTIONS in GS. */
6539 : :
6540 : : inline void
6541 : 378 : gimple_omp_sections_set_control (gimple *gs, tree control)
6542 : : {
6543 : 378 : gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6544 : 378 : omp_sections_stmt->control = control;
6545 : : }
6546 : :
6547 : :
6548 : : /* Set the value being stored in an atomic store. */
6549 : :
6550 : : inline void
6551 : 10317 : gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
6552 : : {
6553 : 10317 : store_stmt->val = val;
6554 : : }
6555 : :
6556 : :
6557 : : /* Return the value being stored in an atomic store. */
6558 : :
6559 : : inline tree
6560 : 10019 : gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
6561 : : {
6562 : 10019 : return store_stmt->val;
6563 : : }
6564 : :
6565 : :
6566 : : /* Return a pointer to the value being stored in an atomic store. */
6567 : :
6568 : : inline tree *
6569 : 49383 : gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
6570 : : {
6571 : 49383 : return &store_stmt->val;
6572 : : }
6573 : :
6574 : :
6575 : : /* Set the LHS of an atomic load. */
6576 : :
6577 : : inline void
6578 : 10317 : gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
6579 : : {
6580 : 10317 : load_stmt->lhs = lhs;
6581 : : }
6582 : :
6583 : :
6584 : : /* Get the LHS of an atomic load. */
6585 : :
6586 : : inline tree
6587 : 10019 : gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
6588 : : {
6589 : 10019 : return load_stmt->lhs;
6590 : : }
6591 : :
6592 : :
6593 : : /* Return a pointer to the LHS of an atomic load. */
6594 : :
6595 : : inline tree *
6596 : 48373 : gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
6597 : : {
6598 : 48373 : return &load_stmt->lhs;
6599 : : }
6600 : :
6601 : :
6602 : : /* Set the RHS of an atomic load. */
6603 : :
6604 : : inline void
6605 : 10317 : gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
6606 : : {
6607 : 10317 : load_stmt->rhs = rhs;
6608 : : }
6609 : :
6610 : :
6611 : : /* Get the RHS of an atomic load. */
6612 : :
6613 : : inline tree
6614 : 10019 : gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
6615 : : {
6616 : 10019 : return load_stmt->rhs;
6617 : : }
6618 : :
6619 : :
6620 : : /* Return a pointer to the RHS of an atomic load. */
6621 : :
6622 : : inline tree *
6623 : 52233 : gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
6624 : : {
6625 : 52233 : return &load_stmt->rhs;
6626 : : }
6627 : :
6628 : :
6629 : : /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6630 : :
6631 : : inline tree
6632 : 25103 : gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
6633 : : {
6634 : 25103 : return cont_stmt->control_def;
6635 : : }
6636 : :
6637 : : /* The same as above, but return the address. */
6638 : :
6639 : : inline tree *
6640 : 195938 : gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
6641 : : {
6642 : 195938 : return &cont_stmt->control_def;
6643 : : }
6644 : :
6645 : : /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6646 : :
6647 : : inline void
6648 : 51841 : gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
6649 : : {
6650 : 51841 : cont_stmt->control_def = def;
6651 : : }
6652 : :
6653 : :
6654 : : /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6655 : :
6656 : : inline tree
6657 : 25103 : gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
6658 : : {
6659 : 25103 : return cont_stmt->control_use;
6660 : : }
6661 : :
6662 : :
6663 : : /* The same as above, but return the address. */
6664 : :
6665 : : inline tree *
6666 : 195938 : gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
6667 : : {
6668 : 195938 : return &cont_stmt->control_use;
6669 : : }
6670 : :
6671 : :
6672 : : /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6673 : :
6674 : : inline void
6675 : 51841 : gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
6676 : : {
6677 : 51841 : cont_stmt->control_use = use;
6678 : : }
6679 : :
6680 : : /* Return the guard associated with the GIMPLE_ASSUME statement GS. */
6681 : :
6682 : : inline tree
6683 : 124 : gimple_assume_guard (const gimple *gs)
6684 : : {
6685 : 124 : const gimple_statement_assume *assume_stmt
6686 : 124 : = as_a <const gimple_statement_assume *> (gs);
6687 : 124 : return assume_stmt->guard;
6688 : : }
6689 : :
6690 : : /* Set the guard associated with the GIMPLE_ASSUME statement GS. */
6691 : :
6692 : : inline void
6693 : 124 : gimple_assume_set_guard (gimple *gs, tree guard)
6694 : : {
6695 : 124 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6696 : 124 : assume_stmt->guard = guard;
6697 : 0 : }
6698 : :
6699 : : inline tree *
6700 : 12 : gimple_assume_guard_ptr (gimple *gs)
6701 : : {
6702 : 12 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6703 : 12 : return &assume_stmt->guard;
6704 : : }
6705 : :
6706 : : /* Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
6707 : : statement GS. */
6708 : :
6709 : : inline gimple_seq *
6710 : 275 : gimple_assume_body_ptr (gimple *gs)
6711 : : {
6712 : 275 : gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6713 : 151 : return &assume_stmt->body;
6714 : : }
6715 : :
6716 : : /* Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS. */
6717 : :
6718 : : inline gimple_seq
6719 : 502 : gimple_assume_body (const gimple *gs)
6720 : : {
6721 : 502 : const gimple_statement_assume *assume_stmt
6722 : 502 : = as_a <const gimple_statement_assume *> (gs);
6723 : 502 : return assume_stmt->body;
6724 : : }
6725 : :
6726 : : /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6727 : : TRANSACTION_STMT. */
6728 : :
6729 : : inline gimple_seq *
6730 : 1645 : gimple_transaction_body_ptr (gtransaction *transaction_stmt)
6731 : : {
6732 : 1645 : return &transaction_stmt->body;
6733 : : }
6734 : :
6735 : : /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6736 : :
6737 : : inline gimple_seq
6738 : 35107 : gimple_transaction_body (const gtransaction *transaction_stmt)
6739 : : {
6740 : 35107 : return transaction_stmt->body;
6741 : : }
6742 : :
6743 : : /* Return the label associated with a GIMPLE_TRANSACTION. */
6744 : :
6745 : : inline tree
6746 : 35381 : gimple_transaction_label_norm (const gtransaction *transaction_stmt)
6747 : : {
6748 : 35381 : return transaction_stmt->label_norm;
6749 : : }
6750 : :
6751 : : inline tree *
6752 : 61988 : gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
6753 : : {
6754 : 61988 : return &transaction_stmt->label_norm;
6755 : : }
6756 : :
6757 : : inline tree
6758 : 35381 : gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
6759 : : {
6760 : 35381 : return transaction_stmt->label_uninst;
6761 : : }
6762 : :
6763 : : inline tree *
6764 : 61988 : gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
6765 : : {
6766 : 61988 : return &transaction_stmt->label_uninst;
6767 : : }
6768 : :
6769 : : inline tree
6770 : 35381 : gimple_transaction_label_over (const gtransaction *transaction_stmt)
6771 : : {
6772 : 35381 : return transaction_stmt->label_over;
6773 : : }
6774 : :
6775 : : inline tree *
6776 : 61988 : gimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
6777 : : {
6778 : 61988 : return &transaction_stmt->label_over;
6779 : : }
6780 : :
6781 : : /* Return the subcode associated with a GIMPLE_TRANSACTION. */
6782 : :
6783 : : inline unsigned int
6784 : 3927 : gimple_transaction_subcode (const gtransaction *transaction_stmt)
6785 : : {
6786 : 3919 : return transaction_stmt->subcode;
6787 : : }
6788 : :
6789 : : /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6790 : : TRANSACTION_STMT. */
6791 : :
6792 : : inline void
6793 : 1025 : gimple_transaction_set_body (gtransaction *transaction_stmt,
6794 : : gimple_seq body)
6795 : : {
6796 : 480 : transaction_stmt->body = body;
6797 : 6 : }
6798 : :
6799 : : /* Set the label associated with a GIMPLE_TRANSACTION. */
6800 : :
6801 : : inline void
6802 : 1149 : gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
6803 : : {
6804 : 1149 : transaction_stmt->label_norm = label;
6805 : 135 : }
6806 : :
6807 : : inline void
6808 : 1133 : gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
6809 : : {
6810 : 1133 : transaction_stmt->label_uninst = label;
6811 : 520 : }
6812 : :
6813 : : inline void
6814 : 1102 : gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
6815 : : {
6816 : 1102 : transaction_stmt->label_over = label;
6817 : 557 : }
6818 : :
6819 : : /* Set the subcode associated with a GIMPLE_TRANSACTION. */
6820 : :
6821 : : inline void
6822 : 1970 : gimple_transaction_set_subcode (gtransaction *transaction_stmt,
6823 : : unsigned int subcode)
6824 : : {
6825 : 946 : transaction_stmt->subcode = subcode;
6826 : 1024 : }
6827 : :
6828 : : /* Return a pointer to the return value for GIMPLE_RETURN GS. */
6829 : :
6830 : : inline tree *
6831 : 563743 : gimple_return_retval_ptr (greturn *gs)
6832 : : {
6833 : 563743 : return &gs->op[0];
6834 : : }
6835 : :
6836 : : /* Return the return value for GIMPLE_RETURN GS. */
6837 : :
6838 : : inline tree
6839 : 358662657 : gimple_return_retval (const greturn *gs)
6840 : : {
6841 : 358662657 : return gs->op[0];
6842 : : }
6843 : :
6844 : :
6845 : : /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6846 : :
6847 : : inline void
6848 : 2140476 : gimple_return_set_retval (greturn *gs, tree retval)
6849 : : {
6850 : 2140476 : gs->op[0] = retval;
6851 : 2140148 : }
6852 : :
6853 : :
6854 : : /* Returns true when the gimple statement STMT is any of the OMP types. */
6855 : :
6856 : : #define CASE_GIMPLE_OMP \
6857 : : case GIMPLE_OMP_PARALLEL: \
6858 : : case GIMPLE_OMP_TASK: \
6859 : : case GIMPLE_OMP_FOR: \
6860 : : case GIMPLE_OMP_SECTIONS: \
6861 : : case GIMPLE_OMP_SECTIONS_SWITCH: \
6862 : : case GIMPLE_OMP_SINGLE: \
6863 : : case GIMPLE_OMP_TARGET: \
6864 : : case GIMPLE_OMP_TEAMS: \
6865 : : case GIMPLE_OMP_SCOPE: \
6866 : : case GIMPLE_OMP_DISPATCH: \
6867 : : case GIMPLE_OMP_INTEROP: \
6868 : : case GIMPLE_OMP_SECTION: \
6869 : : case GIMPLE_OMP_STRUCTURED_BLOCK: \
6870 : : case GIMPLE_OMP_MASTER: \
6871 : : case GIMPLE_OMP_MASKED: \
6872 : : case GIMPLE_OMP_TASKGROUP: \
6873 : : case GIMPLE_OMP_ORDERED: \
6874 : : case GIMPLE_OMP_CRITICAL: \
6875 : : case GIMPLE_OMP_SCAN: \
6876 : : case GIMPLE_OMP_RETURN: \
6877 : : case GIMPLE_OMP_ATOMIC_LOAD: \
6878 : : case GIMPLE_OMP_ATOMIC_STORE: \
6879 : : case GIMPLE_OMP_CONTINUE
6880 : :
6881 : : inline bool
6882 : 8612960 : is_gimple_omp (const gimple *stmt)
6883 : : {
6884 : 7220320 : switch (gimple_code (stmt))
6885 : : {
6886 : : CASE_GIMPLE_OMP:
6887 : : return true;
6888 : 3081298 : default:
6889 : 3081298 : return false;
6890 : : }
6891 : : }
6892 : :
6893 : : /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6894 : : specifically. */
6895 : :
6896 : : inline bool
6897 : 1107935 : is_gimple_omp_oacc (const gimple *stmt)
6898 : : {
6899 : 1107935 : gcc_assert (is_gimple_omp (stmt));
6900 : 1107935 : switch (gimple_code (stmt))
6901 : : {
6902 : 0 : case GIMPLE_OMP_ATOMIC_LOAD:
6903 : 0 : case GIMPLE_OMP_ATOMIC_STORE:
6904 : 0 : case GIMPLE_OMP_CONTINUE:
6905 : 0 : case GIMPLE_OMP_RETURN:
6906 : : /* Codes shared between OpenACC and OpenMP cannot be used to disambiguate
6907 : : the two. */
6908 : 0 : gcc_unreachable ();
6909 : :
6910 : 398539 : case GIMPLE_OMP_FOR:
6911 : 398539 : switch (gimple_omp_for_kind (stmt))
6912 : : {
6913 : : case GF_OMP_FOR_KIND_OACC_LOOP:
6914 : : return true;
6915 : : default:
6916 : : return false;
6917 : : }
6918 : 471755 : case GIMPLE_OMP_TARGET:
6919 : 471755 : switch (gimple_omp_target_kind (stmt))
6920 : : {
6921 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6922 : : case GF_OMP_TARGET_KIND_OACC_KERNELS:
6923 : : case GF_OMP_TARGET_KIND_OACC_SERIAL:
6924 : : case GF_OMP_TARGET_KIND_OACC_DATA:
6925 : : case GF_OMP_TARGET_KIND_OACC_UPDATE:
6926 : : case GF_OMP_TARGET_KIND_OACC_ENTER_DATA:
6927 : : case GF_OMP_TARGET_KIND_OACC_EXIT_DATA:
6928 : : case GF_OMP_TARGET_KIND_OACC_DECLARE:
6929 : : case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
6930 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
6931 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
6932 : : case GF_OMP_TARGET_KIND_OACC_DATA_KERNELS:
6933 : : return true;
6934 : : default:
6935 : : return false;
6936 : : }
6937 : : default:
6938 : : return false;
6939 : : }
6940 : : }
6941 : :
6942 : :
6943 : : /* Return true if the OMP gimple statement STMT is offloaded. */
6944 : :
6945 : : inline bool
6946 : 688004 : is_gimple_omp_offloaded (const gimple *stmt)
6947 : : {
6948 : 688004 : gcc_assert (is_gimple_omp (stmt));
6949 : 688004 : switch (gimple_code (stmt))
6950 : : {
6951 : 489639 : case GIMPLE_OMP_TARGET:
6952 : 489639 : switch (gimple_omp_target_kind (stmt))
6953 : : {
6954 : : case GF_OMP_TARGET_KIND_REGION:
6955 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6956 : : case GF_OMP_TARGET_KIND_OACC_KERNELS:
6957 : : case GF_OMP_TARGET_KIND_OACC_SERIAL:
6958 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
6959 : : case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
6960 : : return true;
6961 : : default:
6962 : : return false;
6963 : : }
6964 : : default:
6965 : : return false;
6966 : : }
6967 : : }
6968 : :
6969 : :
6970 : : /* Returns TRUE if statement G is a GIMPLE_NOP. */
6971 : :
6972 : : inline bool
6973 : 23993926076 : gimple_nop_p (const gimple *g)
6974 : : {
6975 : 24301559102 : return gimple_code (g) == GIMPLE_NOP;
6976 : : }
6977 : :
6978 : :
6979 : : /* Return true if GS is a GIMPLE_RESX. */
6980 : :
6981 : : inline bool
6982 : 2355573 : is_gimple_resx (const gimple *gs)
6983 : : {
6984 : 2355573 : return gimple_code (gs) == GIMPLE_RESX;
6985 : : }
6986 : :
6987 : :
6988 : : /* Enum and arrays used for allocation stats. Keep in sync with
6989 : : gimple.cc:gimple_alloc_kind_names. */
6990 : : enum gimple_alloc_kind
6991 : : {
6992 : : gimple_alloc_kind_assign, /* Assignments. */
6993 : : gimple_alloc_kind_phi, /* PHI nodes. */
6994 : : gimple_alloc_kind_cond, /* Conditionals. */
6995 : : gimple_alloc_kind_rest, /* Everything else. */
6996 : : gimple_alloc_kind_all
6997 : : };
6998 : :
6999 : : extern uint64_t gimple_alloc_counts[];
7000 : : extern uint64_t gimple_alloc_sizes[];
7001 : :
7002 : : /* Return the allocation kind for a given stmt CODE. */
7003 : : inline enum gimple_alloc_kind
7004 : : gimple_alloc_kind (enum gimple_code code)
7005 : : {
7006 : : switch (code)
7007 : : {
7008 : : case GIMPLE_ASSIGN:
7009 : : return gimple_alloc_kind_assign;
7010 : : case GIMPLE_PHI:
7011 : : return gimple_alloc_kind_phi;
7012 : : case GIMPLE_COND:
7013 : : return gimple_alloc_kind_cond;
7014 : : default:
7015 : : return gimple_alloc_kind_rest;
7016 : : }
7017 : : }
7018 : :
7019 : : /* Return true if a location should not be emitted for this statement
7020 : : by annotate_all_with_location. */
7021 : :
7022 : : inline bool
7023 : 335181522 : gimple_do_not_emit_location_p (gimple *g)
7024 : : {
7025 : 335181522 : return gimple_plf (g, GF_PLF_1);
7026 : : }
7027 : :
7028 : : /* Mark statement G so a location will not be emitted by
7029 : : annotate_one_with_location. */
7030 : :
7031 : : inline void
7032 : 1806263 : gimple_set_do_not_emit_location (gimple *g)
7033 : : {
7034 : : /* The PLF flags are initialized to 0 when a new tuple is created,
7035 : : so no need to initialize it anywhere. */
7036 : 1806263 : gimple_set_plf (g, GF_PLF_1, true);
7037 : : }
7038 : :
7039 : : #endif /* GCC_GIMPLE_H */
|
