GCC Middle and Back End API Reference
gimple.h
Go to the documentation of this file.
1/* Gimple IR definitions.
2
3 Copyright (C) 2007-2025 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along 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
29
31#define DEFGSCODE(SYM, STRING, STRUCT) SYM,
32#include "gimple.def"
33#undef DEFGSCODE
34 LAST_AND_UNUSED_GIMPLE_CODE
35};
36
37extern const char *const gimple_code_name[];
38extern 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)
43extern 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)
55template <typename T>
56inline T
57GIMPLE_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 T ret = dyn_cast <T> (gs);
69 if (!ret)
70 gimple_check_failed (gs, file, line, fun,
71 std::remove_pointer<T>::type::code_, ERROR_MARK);
72 return ret;
73}
74template <typename T>
75inline T
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 T ret = dyn_cast <T> (gs);
88 if (!ret)
89 gimple_check_failed (gs, file, line, fun,
90 std::remove_pointer<T>::type::code_, ERROR_MARK);
91 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
96template <typename T>
97inline T
99{
100 return as_a <T> (gs);
101}
102template <typename T>
103inline T
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. */
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. */
134 GF_ASM_BASIC = 1 << 0,
149 GF_CALL_XTHROW = 1 << 13,
153 GF_OMP_FOR_KIND_MASK = (1 << 3) - 1,
176 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
177 decomposed part, parallelized. */
179 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
180 decomposed part, "gang-single". */
182 /* A 'GF_OMP_TARGET_KIND_OACC_DATA' representing an OpenACC 'kernels'
183 decomposed parts' 'data' construct. */
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. */
192
199};
200
201/* This subcode tells apart different kinds of stmts that are not used
202 for codegen, but rather to retain debug information. */
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. */
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
220struct 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;
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;
250 /* Nonzero if this statement contains volatile operands. */
251 unsigned has_volatile_ops : 1;
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. */
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. */
294/* This gimple subclass has no tag value. */
295struct GTY(())
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
309/* Statements that take register operands. */
310
311struct GTY((tag("GSS_WITH_OPS")))
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};
323
324/* Base for statements that take both memory and register operands. */
325
326struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
328{
329 /* [ WORD 1-7 ] : base class */
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;
337
338
339/* Statements that take both memory and register operands. */
340
341struct GTY((tag("GSS_WITH_MEM_OPS")))
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. */
357struct GTY((tag("GSS_CALL")))
359{
360 /* [ WORD 1-9 ] : base class */
362 /* [ WORD 10-13 ] */
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;
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];
378 static const enum gimple_code code_ = GIMPLE_CALL;
379};
380
381
382/* OMP statements. */
383
384struct GTY((tag("GSS_OMP")))
386{
387 /* [ WORD 1-6 ] : base class */
389 /* [ WORD 7 ] */
391};
392
393
394/* GIMPLE_BIND */
395
396struct 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};
417
418/* GIMPLE_CATCH */
420struct 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};
432
433/* GIMPLE_EH_FILTER */
434
435struct 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. */
447};
448
449/* GIMPLE_EH_ELSE */
451struct GTY((tag("GSS_EH_ELSE")))
452 geh_else : public gimple
453{
454 /* [ WORD 1-6 ] : base class */
456 /* [ WORD 7,8 ] */
457 gimple_seq n_body, e_body;
458};
459
460/* GIMPLE_EH_MUST_NOT_THROW */
461
462struct GTY((tag("GSS_EH_MNT")))
463 geh_mnt : public gimple
464{
465 /* [ WORD 1-6 ] : base class */
467 /* [ WORD 7 ] Abort function decl. */
468 tree fndecl;
470
471/* GIMPLE_PHI */
473struct 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;
485 /* [ WORD 9-14 ] */
486 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
488
489
490/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
491
492struct GTY((tag("GSS_EH_CTRL")))
494{
495 /* [ WORD 1-6 ] : base class */
496
497 /* [ WORD 7 ]
498 Exception region number. */
499 int region;
500};
501
502struct GTY((tag("GSS_EH_CTRL")))
504{
505 /* No extra fields; adds invariant:
506 stmt->code == GIMPLE_RESX. */
507};
509struct GTY((tag("GSS_EH_CTRL")))
511{
512 /* No extra fields; adds invariant:
513 stmt->code == GIMPLE_EH_DISPATH. */
514};
515
517/* GIMPLE_TRY */
518
519struct GTY((tag("GSS_TRY")))
520 gtry : public gimple
521{
522 /* [ WORD 1-6 ] : base class */
524 /* [ WORD 7 ]
525 Expression to evaluate. */
527
528 /* [ WORD 8 ]
529 Cleanup expression. */
530 gimple_seq cleanup;
532
533/* Kind of GIMPLE_TRY statements. */
535{
536 /* A try/catch. */
537 GIMPLE_TRY_CATCH = 1 << 0,
538
539 /* A try/finally. */
540 GIMPLE_TRY_FINALLY = 1 << 1,
543 /* Analogous to TRY_CATCH_IS_CLEANUP. */
545};
546
547/* GIMPLE_WITH_CLEANUP_EXPR */
549struct GTY((tag("GSS_WCE")))
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. */
559 /* [ WORD 7 ]
560 Cleanup expression. */
561 gimple_seq cleanup;
562};
563
564
565/* GIMPLE_ASM */
566
567struct GTY((tag("GSS_ASM")))
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
592struct GTY((tag("GSS_OMP_CRITICAL")))
594{
595 /* [ WORD 1-7 ] : base class */
597 /* [ WORD 8 ] */
598 tree clauses;
600 /* [ WORD 9 ]
601 Critical section name. */
602 tree name;
603};
605
606struct GTY(()) gimple_omp_for_iter {
607 /* Condition code. */
608 enum tree_code cond;
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
625struct GTY((tag("GSS_OMP_FOR")))
627{
628 /* [ WORD 1-7 ] : base class */
629
630 /* [ WORD 8 ] */
633 /* [ WORD 9 ]
634 Number of elements in iter array. */
635 size_t collapse;
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};
645
646/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
647
648struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
650{
651 /* [ WORD 1-7 ] : base class */
652
653 /* [ WORD 8 ]
654 Clauses. */
656
657 /* [ WORD 9 ]
658 Child function holding the body of the parallel region. */
661 /* [ WORD 10 ]
662 Shared data argument. */
664};
665
666/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
667struct GTY((tag("GSS_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. */
675
676/* GIMPLE_OMP_PARALLEL */
677struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
680 /* No extra fields; adds invariant:
681 stmt->code == GIMPLE_OMP_PARALLEL. */
682};
683
684/* GIMPLE_OMP_TARGET */
685struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
687{
688 /* No extra fields; adds invariant:
689 stmt->code == GIMPLE_OMP_TARGET. */
690};
691
692/* GIMPLE_OMP_TASK */
693
694struct GTY((tag("GSS_OMP_TASK")))
696{
697 /* [ WORD 1-10 ] : base class */
698
699 /* [ WORD 11 ]
700 Child function holding firstprivate initialization if needed. */
702
703 /* [ WORD 12-13 ]
704 Size and alignment in bytes of the argument data block. */
705 tree arg_size;
706 tree arg_align;
708
709
710/* GIMPLE_OMP_SECTION */
711/* Uses struct gimple_statement_omp. */
713
714/* GIMPLE_OMP_SECTIONS */
716struct GTY((tag("GSS_OMP_SECTIONS")))
718{
719 /* [ WORD 1-7 ] : base class */
720
721 /* [ WORD 8 ] */
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
735struct GTY((tag("GSS_OMP_CONTINUE")))
737{
738 /* [ WORD 1-6 ] : base class */
739
740 /* [ WORD 7 ] */
741 tree control_def;
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
751struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
753{
754 /* [ WORD 1-7 ] : base class */
755
756 /* [ WORD 8 ] */
758};
760struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
762{
763 /* No extra fields; adds invariant:
764 stmt->code == GIMPLE_OMP_SINGLE. */
765};
766
767struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
769{
770 /* No extra fields; adds invariant:
771 stmt->code == GIMPLE_OMP_TEAMS. */
772};
773
774struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
776{
777 /* No extra fields; adds invariant:
778 stmt->code == GIMPLE_OMP_ORDERED. */
779};
780
781struct GTY((tag("GSS_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
793struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
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
805struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
807{
808 /* [ WORD 1-6 ] : base class */
809
810 /* [ WORD 7 ] */
811 tree val;
814struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
817{
818 /* No extra fields; adds invariant:
819 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
820};
822struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
825{
826 /* No extra fields; adds invariant:
827 stmt->code == GIMPLE_OMP_RETURN. */
829
830/* Assumptions. */
832struct GTY((tag("GSS_ASSUME")))
834{
835 /* [ WORD 1-6 ] : base class */
836
837 /* [ WORD 7 ] */
838 tree guard;
839
840 /* [ WORD 8 ] */
844/* GIMPLE_TRANSACTION. */
845
846/* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
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
872struct GTY((tag("GSS_TRANSACTION")))
874{
875 /* [ WORD 1-9 ] : base class */
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};
886#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
888#include "gsstruct.def"
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
897struct GTY((tag("GSS_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};
904/* A statement with the invariant that
905 stmt->code == GIMPLE_DEBUG
906 i.e. a debug statement. */
907
908struct GTY((tag("GSS_WITH_OPS")))
910{
911 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
912};
914/* A statement with the invariant that
915 stmt->code == GIMPLE_GOTO
916 i.e. a goto statement. */
917
918struct GTY((tag("GSS_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
928struct GTY((tag("GSS_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. */
938struct GTY((tag("GSS_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
948struct GTY((tag("GSS_WITH_MEM_OPS")))
950{
951 static const enum gimple_code code_ = GIMPLE_ASSIGN;
952 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
954
955/* A statement with the invariant that
956 stmt->code == GIMPLE_RETURN
957 i.e. a return statement. */
958
959struct GTY((tag("GSS_WITH_MEM_OPS")))
962 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
963};
964
965template <>
966template <>
967inline bool
970 return gs->code == GIMPLE_ASM;
971}
972
973template <>
974template <>
975inline bool
978 return gs->code == GIMPLE_ASSIGN;
979}
980
981template <>
982template <>
983inline bool
986 return gs->code == GIMPLE_ASSIGN;
987}
988
989template <>
990template <>
991inline bool
994 return gs->code == GIMPLE_BIND;
995}
996
997template <>
998template <>
999inline bool
1002 return gs->code == GIMPLE_CALL;
1003}
1004
1005template <>
1006template <>
1007inline bool
1010 return gs->code == GIMPLE_CATCH;
1011}
1012
1013template <>
1014template <>
1015inline bool
1018 return gs->code == GIMPLE_COND;
1019}
1020
1021template <>
1022template <>
1023inline bool
1026 return gs->code == GIMPLE_COND;
1027}
1028
1029template <>
1030template <>
1031inline bool
1034 return gs->code == GIMPLE_DEBUG;
1035}
1036
1037template <>
1038template <>
1039inline bool
1042 return gs->code == GIMPLE_DEBUG;
1043}
1044
1045template <>
1046template <>
1047inline bool
1050 return gs->code == GIMPLE_GOTO;
1051}
1052
1053template <>
1054template <>
1055inline bool
1058 return gs->code == GIMPLE_GOTO;
1059}
1060
1061template <>
1062template <>
1063inline bool
1066 return gs->code == GIMPLE_LABEL;
1067}
1068
1069template <>
1070template <>
1071inline bool
1074 return gs->code == GIMPLE_LABEL;
1075}
1076
1077template <>
1078template <>
1079inline bool
1082 return gs->code == GIMPLE_RESX;
1083}
1084
1085template <>
1086template <>
1087inline bool
1090 return gs->code == GIMPLE_EH_DISPATCH;
1091}
1092
1093template <>
1094template <>
1095inline bool
1098 return gs->code == GIMPLE_EH_ELSE;
1099}
1100
1101template <>
1102template <>
1103inline bool
1106 return gs->code == GIMPLE_EH_ELSE;
1107}
1108
1109template <>
1110template <>
1111inline bool
1114 return gs->code == GIMPLE_EH_FILTER;
1115}
1116
1117template <>
1118template <>
1119inline bool
1122 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1123}
1124
1125template <>
1126template <>
1127inline bool
1130 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1131}
1132
1133template <>
1134template <>
1135inline bool
1138 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1139}
1140
1141template <>
1142template <>
1143inline bool
1146 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1147}
1148
1149template <>
1150template <>
1151inline bool
1154 return gs->code == GIMPLE_OMP_RETURN;
1155}
1156
1157template <>
1158template <>
1159inline bool
1161{
1162 return gs->code == GIMPLE_OMP_CONTINUE;
1164
1165template <>
1166template <>
1167inline bool
1169{
1170 return gs->code == GIMPLE_OMP_CRITICAL;
1172
1173template <>
1174template <>
1175inline bool
1177{
1178 return gs->code == GIMPLE_OMP_ORDERED;
1180
1181template <>
1182template <>
1183inline bool
1185{
1186 return gs->code == GIMPLE_OMP_SCAN;
1188
1189template <>
1190template <>
1191inline bool
1193{
1194 return gs->code == GIMPLE_OMP_FOR;
1196
1197template <>
1198template <>
1199inline bool
1201{
1202 return (gs->code == GIMPLE_OMP_PARALLEL
1203 || gs->code == GIMPLE_OMP_TASK
1204 || gs->code == GIMPLE_OMP_TEAMS);
1205}
1206
1207template <>
1208template <>
1209inline bool
1212 return gs->code == GIMPLE_OMP_PARALLEL;
1213}
1214
1215template <>
1216template <>
1217inline bool
1220 return gs->code == GIMPLE_OMP_TARGET;
1221}
1222
1223template <>
1224template <>
1225inline bool
1228 return gs->code == GIMPLE_OMP_SECTIONS;
1229}
1230
1231template <>
1232template <>
1233inline bool
1236 return gs->code == GIMPLE_OMP_SINGLE;
1237}
1238
1239template <>
1240template <>
1241inline bool
1244 return gs->code == GIMPLE_OMP_TEAMS;
1245}
1246
1247template <>
1248template <>
1249inline bool
1252 return gs->code == GIMPLE_OMP_TASK;
1253}
1254
1255template <>
1256template <>
1257inline bool
1260 return gs->code == GIMPLE_PHI;
1261}
1262
1263template <>
1264template <>
1265inline bool
1268 return gs->code == GIMPLE_RETURN;
1269}
1270
1271template <>
1272template <>
1273inline bool
1276 return gs->code == GIMPLE_SWITCH;
1277}
1278
1279template <>
1280template <>
1281inline bool
1284 return gs->code == GIMPLE_SWITCH;
1285}
1286
1287template <>
1288template <>
1289inline bool
1292 return gs->code == GIMPLE_ASSUME;
1293}
1294
1295template <>
1296template <>
1297inline bool
1300 return gs->code == GIMPLE_TRANSACTION;
1301}
1302
1303template <>
1304template <>
1305inline bool
1308 return gs->code == GIMPLE_TRY;
1309}
1310
1311template <>
1312template <>
1313inline bool
1316 return gs->code == GIMPLE_TRY;
1317}
1318
1319template <>
1320template <>
1321inline bool
1324 return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
1325}
1326
1327template <>
1328template <>
1329inline bool
1332 return gs->code == GIMPLE_ASM;
1333}
1334
1335template <>
1336template <>
1337inline bool
1340 return gs->code == GIMPLE_BIND;
1341}
1342
1343template <>
1344template <>
1345inline bool
1348 return gs->code == GIMPLE_CALL;
1349}
1350
1351template <>
1352template <>
1353inline bool
1356 return gs->code == GIMPLE_CATCH;
1357}
1358
1359template <>
1360template <>
1361inline bool
1364 return gs->code == GIMPLE_RESX;
1365}
1366
1367template <>
1368template <>
1369inline bool
1372 return gs->code == GIMPLE_EH_DISPATCH;
1373}
1374
1375template <>
1376template <>
1377inline bool
1380 return gs->code == GIMPLE_EH_FILTER;
1381}
1382
1383template <>
1384template <>
1385inline bool
1388 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1389}
1390
1391template <>
1392template <>
1393inline bool
1396 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1397}
1398
1399template <>
1400template <>
1401inline bool
1404 return gs->code == GIMPLE_OMP_RETURN;
1405}
1406
1407template <>
1408template <>
1409inline bool
1411{
1412 return gs->code == GIMPLE_OMP_CONTINUE;
1414
1415template <>
1416template <>
1417inline bool
1419{
1420 return gs->code == GIMPLE_OMP_CRITICAL;
1422
1423template <>
1424template <>
1425inline bool
1427{
1428 return gs->code == GIMPLE_OMP_ORDERED;
1430
1431template <>
1432template <>
1433inline bool
1435{
1436 return gs->code == GIMPLE_OMP_SCAN;
1438
1439template <>
1440template <>
1441inline bool
1443{
1444 return gs->code == GIMPLE_OMP_FOR;
1446
1447template <>
1448template <>
1449inline bool
1451{
1452 return (gs->code == GIMPLE_OMP_PARALLEL
1453 || gs->code == GIMPLE_OMP_TASK
1454 || gs->code == GIMPLE_OMP_TEAMS);
1455}
1456
1457template <>
1458template <>
1459inline bool
1462 return gs->code == GIMPLE_OMP_PARALLEL;
1463}
1464
1465template <>
1466template <>
1467inline bool
1470 return gs->code == GIMPLE_OMP_TARGET;
1471}
1472
1473template <>
1474template <>
1475inline bool
1478 return gs->code == GIMPLE_OMP_SECTIONS;
1479}
1480
1481template <>
1482template <>
1483inline bool
1486 return gs->code == GIMPLE_OMP_SINGLE;
1487}
1488
1489template <>
1490template <>
1491inline bool
1493{
1494 return gs->code == GIMPLE_OMP_TEAMS;
1495}
1496
1497template <>
1498template <>
1499inline bool
1501{
1502 return gs->code == GIMPLE_OMP_TASK;
1504
1505template <>
1506template <>
1507inline bool
1508is_a_helper <const gphi *>::test (const gimple *gs)
1509{
1510 return gs->code == GIMPLE_PHI;
1511}
1513template <>
1514template <>
1515inline bool
1518 return gs->code == GIMPLE_RETURN;
1519}
1520
1521template <>
1522template <>
1523inline bool
1525{
1526 return gs->code == GIMPLE_ASSUME;
1527}
1528
1529template <>
1530template <>
1531inline bool
1533{
1534 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. */
1539extern size_t const gimple_ops_offset_[];
1541/* Map GIMPLE codes to GSS codes. */
1543
1544/* This variable holds the currently expanded gimple statement for purposes
1545 of comminucating the profile info to the builtin expanders. */
1547
1548size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
1549void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
1554gcall *gimple_build_call (tree, unsigned, ...);
1555gcall *gimple_build_call_valist (tree, unsigned, va_list);
1556gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
1570gimple *gimple_build_nop (void);
1580 enum gimple_try_flags);
1594 tree, tree);
1613 enum omp_memory_order);
1617extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
1622 location_t);
1623extern void annotate_all_with_location (gimple_seq, location_t);
1626bool gimple_call_same_target_p (const gimple *, const gimple *);
1627int gimple_call_flags (const gimple *);
1628int gimple_call_arg_flags (const gcall *, unsigned);
1629int gimple_call_retslot_flags (const gcall *);
1631int gimple_call_return_flags (const gcall *);
1637bool gimple_assign_load_p (const gimple *);
1641 tree, tree, tree);
1642tree gimple_get_lhs (const gimple *);
1643void gimple_set_lhs (gimple *, tree);
1645void gimple_move_vops (gimple *, gimple *);
1646bool gimple_has_side_effects (const gimple *);
1647bool gimple_could_trap_p_1 (const gimple *, bool, bool);
1648bool gimple_could_trap_p (const gimple *);
1650extern void dump_gimple_statistics (void);
1651unsigned get_gimple_rhs_num_ops (enum tree_code);
1662extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
1663extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
1664extern bool gimple_asm_clobbers_memory_p (const gasm *);
1665extern void dump_decl_set (FILE *, bitmap);
1666extern bool nonfreeing_call_p (gimple *);
1667extern bool nonbarrier_call_p (gimple *);
1668extern bool infer_nonnull_range (gimple *, tree);
1671 tree * = NULL);
1674extern void gimple_seq_set_location (gimple_seq, location_t);
1675extern void gimple_seq_discard (gimple_seq);
1676extern void maybe_remove_unused_call_args (struct function *, gimple *);
1677extern bool gimple_inexpensive_call_p (gcall *);
1678extern bool stmt_can_terminate_bb_p (gimple *);
1681
1682/* Return the disposition for a warning (or all warnings by default)
1683 for a statement. */
1684extern 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. */
1688extern 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. */
1692extern 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. */
1695extern 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. */
1698extern 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
1704typedef 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. */
1711inline unsigned int
1712gimple_stmt_max_uid (struct function *fn)
1713{
1714 return fn->last_stmt_uid;
1715}
1717/* Set the number of the next statement uid to be allocated. */
1718inline void
1719set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
1720{
1721 fn->last_stmt_uid = maxid;
1722}
1723
1724/* Set the number of the next statement uid to be allocated. */
1725inline unsigned int
1727{
1728 return fn->last_stmt_uid++;
1729}
1730
1731/* Return the first node in GIMPLE sequence S. */
1732
1733inline gimple_seq_node
1736 return s;
1737}
1738
1739
1740/* Return the first statement in GIMPLE sequence S. */
1741
1742inline gimple *
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
1752inline gbind *
1757}
1758
1759
1760/* Return the last node in GIMPLE sequence S. */
1762inline gimple_seq_node
1764{
1765 return s ? s->prev : NULL;
1766}
1767
1768
1769/* Return the last statement in GIMPLE sequence S. */
1770
1771inline gimple *
1776}
1777
1779/* Set the last node in GIMPLE sequence *PS to LAST. */
1780
1781inline void
1783{
1784 (*ps)->prev = last;
1785}
1787
1788/* Set the first node in GIMPLE sequence *PS to FIRST. */
1789
1790inline void
1792{
1793 *ps = first;
1794}
1795
1797/* Return true if GIMPLE sequence S is empty. */
1798
1799inline bool
1801{
1802 return s == NULL;
1803}
1804
1805/* Allocate a new sequence and initialize its first element with STMT. */
1806
1807inline gimple_seq
1809{
1810 gimple_seq seq = NULL;
1811 gimple_seq_add_stmt (&seq, stmt);
1812 return seq;
1813}
1814
1816/* Returns the sequence of statements in BB. */
1817
1818inline gimple_seq
1820{
1821 return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL;
1822}
1823
1824inline gimple_seq *
1826{
1827 return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL;
1828}
1829
1830/* Sets the sequence of statements in BB to SEQ. */
1831
1832inline void
1834{
1835 gcc_checking_assert (!(bb->flags & BB_RTL));
1836 bb->il.gimple.seq = seq;
1837}
1838
1839
1840/* Return the code for GIMPLE statement G. */
1841
1842inline enum gimple_code
1843gimple_code (const gimple *g)
1844{
1845 return g->code;
1846}
1847
1848
1849/* Return the GSS code used by a GIMPLE code. */
1850
1852gss_for_code (enum gimple_code code)
1853{
1854 gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
1855 return gss_for_code_[code];
1856}
1857
1858
1859/* Return which GSS code is used by GS. */
1860
1862gimple_statement_structure (gimple *gs)
1863{
1865}
1866
1867
1868/* Return true if statement G has sub-statements. This is only true for
1869 High GIMPLE statements. */
1870
1871inline bool
1874 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;
1902 default:
1903 return false;
1904 }
1905}
1906
1907
1908/* Return the basic block holding statement G. */
1910inline basic_block
1911gimple_bb (const gimple *g)
1912{
1913 return g->bb;
1914}
1915
1916
1917/* Return the lexical scope block holding statement G. */
1918
1919inline tree
1921{
1922 return LOCATION_BLOCK (g->location);
1923}
1924
1925/* Forward declare. */
1926inline void gimple_set_location (gimple *, location_t);
1927
1928/* Set BLOCK to be the lexical scope block holding statement G. */
1930inline void
1931gimple_set_block (gimple *g, tree block)
1932{
1933 gimple_set_location (g, set_block (g->location, block));
1934}
1935
1936/* Return location information for statement G. */
1937
1938inline location_t
1939gimple_location (const gimple *g)
1940{
1941 return g->location;
1942}
1943
1944/* Return location information for statement G if g is not NULL.
1945 Otherwise, UNKNOWN_LOCATION is returned. */
1946
1947inline location_t
1948gimple_location_safe (const gimple *g)
1949{
1950 return g ? gimple_location (g) : UNKNOWN_LOCATION;
1951}
1953/* Set location information for statement G. */
1954
1955inline void
1956gimple_set_location (gimple *g, location_t location)
1957{
1958 /* Copy the no-warning data to the statement location. */
1959 if (g->location != UNKNOWN_LOCATION)
1960 copy_warning (location, g->location);
1961 g->location = location;
1962}
1963
1964/* Return address of the location information for statement G. */
1965
1966inline location_t *
1967gimple_location_ptr (gimple *g)
1968{
1969 return &g->location;
1971
1972
1973/* Return true if G contains location information. */
1974
1975inline bool
1976gimple_has_location (const gimple *g)
1977{
1980
1981
1982/* Return non-artificial location information for statement G. */
1983
1984inline location_t
1985gimple_nonartificial_location (const gimple *g)
1986{
1987 location_t *ploc = NULL;
1988
1989 if (tree block = gimple_block (g))
1990 ploc = block_nonartificial_location (block);
1991
1992 return ploc ? *ploc : gimple_location (g);
1993}
1994
1995
1996/* Return the file name of the location of STMT. */
1997
1998inline const char *
1999gimple_filename (const gimple *stmt)
2000{
2001 return LOCATION_FILE (gimple_location (stmt));
2002}
2003
2004
2005/* Return the line number of the location of STMT. */
2006
2007inline int
2008gimple_lineno (const gimple *stmt)
2009{
2010 return LOCATION_LINE (gimple_location (stmt));
2011}
2012
2013
2014/* Determine whether SEQ is a singleton. */
2015
2016inline bool
2018{
2019 return ((gimple_seq_first (seq) != NULL)
2020 && (gimple_seq_first (seq) == gimple_seq_last (seq)));
2021}
2022
2023/* Return true if no warnings should be emitted for statement STMT. */
2024
2025inline bool
2026gimple_no_warning_p (const gimple *stmt)
2027{
2028 return stmt->no_warning;
2029}
2030
2031/* Set the no_warning flag of STMT to NO_WARNING. */
2032
2033inline void
2034gimple_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.
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
2051inline void
2052gimple_set_visited (gimple *stmt, bool visited_p)
2053{
2054 stmt->visited = (unsigned) visited_p;
2055}
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
2069inline bool
2071{
2072 return stmt->visited;
2073}
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
2086inline void
2087gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
2089 if (val_p)
2090 stmt->plf |= (unsigned int) plf;
2091 else
2092 stmt->plf &= ~((unsigned int) plf);
2093}
2094
2095
2096/* Return the value of pass local flag PLF on statement STMT.
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
2106inline unsigned int
2107gimple_plf (gimple *stmt, enum plf_mask plf)
2108{
2109 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
2120inline void
2121gimple_set_uid (gimple *g, unsigned uid)
2122{
2123 g->uid = uid;
2124}
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
2134inline unsigned
2135gimple_uid (const gimple *g)
2136{
2137 return g->uid;
2138}
2140
2141/* Make statement G a singleton sequence. */
2142
2143inline void
2145{
2146 g->next = NULL;
2147 g->prev = g;
2148}
2149
2150
2151/* Return true if GIMPLE statement G has register or memory operands. */
2152
2153inline bool
2154gimple_has_ops (const gimple *g)
2156 return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
2157}
2158
2159template <>
2160template <>
2161inline bool
2163{
2164 return gimple_has_ops (gs);
2165}
2166
2167template <>
2168template <>
2169inline bool
2171{
2172 return gimple_has_ops (gs);
2173}
2174
2175/* Return true if GIMPLE statement G has memory operands. */
2176
2177inline bool
2178gimple_has_mem_ops (const gimple *g)
2180 return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
2181}
2182
2183template <>
2184template <>
2185inline bool
2187{
2188 return gimple_has_mem_ops (gs);
2189}
2190
2191template <>
2192template <>
2193inline bool
2195{
2196 return gimple_has_mem_ops (gs);
2197}
2198
2199/* Return the set of USE operands for statement G. */
2200
2201inline struct use_optype_d *
2202gimple_use_ops (const gimple *g)
2204 const gimple_statement_with_ops *ops_stmt =
2206 if (!ops_stmt)
2207 return NULL;
2208 return ops_stmt->use_ops;
2209}
2210
2211
2212/* Set USE to be the set of USE operands for statement G. */
2213
2214inline void
2216{
2217 gimple_statement_with_ops *ops_stmt =
2219 ops_stmt->use_ops = use;
2220}
2221
2222
2223/* Return the single VUSE operand of the statement G. */
2224
2225inline tree
2226gimple_vuse (const gimple *g)
2228 const gimple_statement_with_memory_ops *mem_ops_stmt =
2230 if (!mem_ops_stmt)
2231 return NULL_TREE;
2232 return mem_ops_stmt->vuse;
2233}
2234
2235/* Return the single VDEF operand of the statement G. */
2236
2237inline tree
2238gimple_vdef (const gimple *g)
2239{
2240 const gimple_statement_with_memory_ops *mem_ops_stmt =
2242 if (!mem_ops_stmt)
2243 return NULL_TREE;
2244 return mem_ops_stmt->vdef;
2245}
2246
2247/* Return the single VUSE operand of the statement G. */
2248
2249inline tree *
2251{
2252 gimple_statement_with_memory_ops *mem_ops_stmt =
2254 if (!mem_ops_stmt)
2255 return NULL;
2256 return &mem_ops_stmt->vuse;
2257}
2258
2259/* Return the single VDEF operand of the statement G. */
2260
2261inline tree *
2263{
2264 gimple_statement_with_memory_ops *mem_ops_stmt =
2266 if (!mem_ops_stmt)
2267 return NULL;
2268 return &mem_ops_stmt->vdef;
2270
2271/* Set the single VUSE operand of the statement G. */
2272
2273inline void
2274gimple_set_vuse (gimple *g, tree vuse)
2275{
2276 gimple_statement_with_memory_ops *mem_ops_stmt =
2278 mem_ops_stmt->vuse = vuse;
2279}
2280
2281/* Set the single VDEF operand of the statement G. */
2282
2283inline void
2285{
2286 gimple_statement_with_memory_ops *mem_ops_stmt =
2288 mem_ops_stmt->vdef = vdef;
2289}
2291
2292/* Return true if statement G has operands and the modified field has
2293 been set. */
2294
2295inline bool
2296gimple_modified_p (const gimple *g)
2297{
2298 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
2305inline void
2306gimple_set_modified (gimple *s, bool modifiedp)
2308 if (gimple_has_ops (s))
2309 s->modified = (unsigned) modifiedp;
2310}
2311
2312
2313/* Return true if statement STMT contains volatile operands. */
2314
2315inline bool
2316gimple_has_volatile_ops (const gimple *stmt)
2318 if (gimple_has_mem_ops (stmt))
2319 return stmt->has_volatile_ops;
2320 else
2321 return false;
2322}
2323
2324
2325/* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2326
2327inline void
2329{
2330 if (gimple_has_mem_ops (stmt))
2331 stmt->has_volatile_ops = (unsigned) volatilep;
2332}
2333
2334/* Return true if STMT is in a transaction. */
2335
2336inline bool
2337gimple_in_transaction (const gimple *stmt)
2338{
2340}
2341
2342/* Return true if statement STMT may access memory. */
2343
2344inline bool
2345gimple_references_memory_p (gimple *stmt)
2346{
2347 return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
2348}
2350
2351/* Return the subcode for OMP statement S. */
2352
2353inline unsigned
2354gimple_omp_subcode (const gimple *s)
2355{
2356 gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
2357 && gimple_code (s) <= GIMPLE_OMP_ORDERED);
2358 return s->subcode;
2359}
2361/* Set the subcode for OMP statement S to SUBCODE. */
2362
2363inline void
2364gimple_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 gcc_gimple_checking_assert (subcode < (1 << 16));
2369 s->subcode = subcode;
2370}
2372/* Set the nowait flag on OMP_RETURN statement S. */
2373
2374inline void
2376{
2377 GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
2378 s->subcode |= GF_OMP_RETURN_NOWAIT;
2379}
2380
2381
2382/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2383 flag set. */
2384
2385inline bool
2387{
2388 GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
2389 return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
2390}
2391
2392
2393/* Set the LHS of OMP return. */
2394
2395inline void
2397{
2398 gimple_statement_omp_return *omp_return_stmt =
2400 omp_return_stmt->val = lhs;
2401}
2402
2403
2404/* Get the LHS of OMP return. */
2405
2406inline tree
2408{
2409 const gimple_statement_omp_return *omp_return_stmt =
2411 return omp_return_stmt->val;
2412}
2413
2415/* Return a pointer to the LHS of OMP return. */
2416
2417inline tree *
2419{
2420 gimple_statement_omp_return *omp_return_stmt =
2422 return &omp_return_stmt->val;
2423}
2424
2426/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2427 flag set. */
2428
2429inline bool
2431{
2432 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2433 return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
2434}
2435
2437/* Set the GF_OMP_SECTION_LAST flag on G. */
2438
2439inline void
2441{
2442 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2443 g->subcode |= GF_OMP_SECTION_LAST;
2444}
2445
2446
2447/* Return true if OMP ordered construct is stand-alone
2448 (G has the GF_OMP_ORDERED_STANDALONE flag set). */
2449
2450inline bool
2452{
2453 GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2455}
2456
2457
2458/* Set the GF_OMP_ORDERED_STANDALONE flag on G. */
2459
2460inline void
2462{
2463 GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2464 g->subcode |= GF_OMP_ORDERED_STANDALONE;
2465}
2466
2467
2468/* Return true if OMP parallel statement G has the
2469 GF_OMP_PARALLEL_COMBINED flag set. */
2470
2471inline bool
2472gimple_omp_parallel_combined_p (const gimple *g)
2474 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2476}
2477
2478
2479/* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2480 value of COMBINED_P. */
2481
2482inline void
2483gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
2485 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2486 if (combined_p)
2487 g->subcode |= GF_OMP_PARALLEL_COMBINED;
2488 else
2489 g->subcode &= ~GF_OMP_PARALLEL_COMBINED;
2490}
2491
2492
2493/* Return true if OMP atomic load/store statement G has the
2494 GF_OMP_ATOMIC_NEED_VALUE flag set. */
2496inline bool
2498{
2499 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2500 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2502}
2503
2504
2505/* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2506
2507inline void
2509{
2510 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2511 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2512 g->subcode |= GF_OMP_ATOMIC_NEED_VALUE;
2513}
2514
2515
2516/* Return true if OMP atomic load/store statement G has the
2517 GF_OMP_ATOMIC_WEAK flag set. */
2518
2519inline bool
2521{
2522 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2523 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2524 return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_WEAK) != 0;
2525}
2526
2527
2528/* Set the GF_OMP_ATOMIC_WEAK flag on G. */
2529
2530inline void
2532{
2533 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2534 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2535 g->subcode |= GF_OMP_ATOMIC_WEAK;
2536}
2538
2539/* Return the memory order of the OMP atomic load/store statement G. */
2540
2541inline enum omp_memory_order
2543{
2544 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2545 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2546 return (enum omp_memory_order)
2548}
2549
2550
2551/* Set the memory order on G. */
2552
2553inline void
2555{
2556 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2557 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2558 g->subcode = ((g->subcode & ~GF_OMP_ATOMIC_MEMORY_ORDER)
2560}
2561
2562
2563/* Return the number of operands for statement GS. */
2564
2565inline unsigned
2566gimple_num_ops (const gimple *gs)
2567{
2568 return gs->num_ops;
2569}
2570
2571
2572/* Set the number of operands for statement GS. */
2573
2574inline void
2575gimple_set_num_ops (gimple *gs, unsigned num_ops)
2576{
2577 gs->num_ops = num_ops;
2578}
2579
2580
2581/* Return the array of operands for statement GS. */
2583inline tree *
2584gimple_ops (gimple *gs)
2585{
2586 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. */
2592 gcc_gimple_checking_assert (off != 0);
2593
2594 return (tree *) ((char *) gs + off);
2595}
2597
2598/* Return operand I for statement GS. */
2599
2600inline tree
2601gimple_op (const gimple *gs, unsigned i)
2602{
2603 if (gimple_has_ops (gs))
2604 {
2606 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. */
2614inline tree *
2615gimple_op_ptr (gimple *gs, unsigned i)
2616{
2617 if (gimple_has_ops (gs))
2618 {
2620 return gimple_ops (gs) + i;
2621 }
2622 else
2623 return NULL;
2624}
2625
2626/* Set operand I of statement GS to OP. */
2627
2628inline void
2629gimple_set_op (gimple *gs, unsigned i, tree op)
2630{
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 gimple_ops (gs)[i] = op;
2638}
2639
2640/* Return true if GS is a GIMPLE_ASSIGN. */
2641
2642inline bool
2643is_gimple_assign (const gimple *gs)
2644{
2645 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
2651inline enum gimple_rhs_class
2653{
2654 return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
2655}
2656
2657/* Return the LHS of assignment statement GS. */
2658
2659inline tree
2660gimple_assign_lhs (const gassign *gs)
2661{
2662 return gs->op[0];
2663}
2665inline tree
2666gimple_assign_lhs (const gimple *gs)
2667{
2668 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2669 return gimple_assign_lhs (ass);
2671
2672
2673/* Return a pointer to the LHS of assignment statement GS. */
2674
2675inline tree *
2676gimple_assign_lhs_ptr (gassign *gs)
2677{
2678 return &gs->op[0];
2679}
2680
2681inline tree *
2683{
2685 return gimple_assign_lhs_ptr (ass);
2686}
2688
2689/* Set LHS to be the LHS operand of assignment statement GS. */
2690
2691inline void
2693{
2694 gs->op[0] = lhs;
2695
2696 if (lhs && TREE_CODE (lhs) == SSA_NAME)
2697 SSA_NAME_DEF_STMT (lhs) = gs;
2698}
2699
2700inline void
2701gimple_assign_set_lhs (gimple *gs, tree lhs)
2704 gimple_assign_set_lhs (ass, lhs);
2705}
2706
2707
2708/* Return the first operand on the RHS of assignment statement GS. */
2709
2710inline tree
2711gimple_assign_rhs1 (const gassign *gs)
2712{
2713 return gs->op[1];
2714}
2715
2716inline tree
2717gimple_assign_rhs1 (const gimple *gs)
2718{
2719 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2720 return gimple_assign_rhs1 (ass);
2721}
2723
2724/* Return a pointer to the first operand on the RHS of assignment
2725 statement GS. */
2726
2727inline tree *
2729{
2730 return &gs->op[1];
2731}
2732
2733inline tree *
2735{
2737 return gimple_assign_rhs1_ptr (ass);
2738}
2739
2740/* Set RHS to be the first operand on the RHS of assignment statement GS. */
2741
2742inline void
2744{
2745 gs->op[1] = rhs;
2746}
2747
2748inline void
2749gimple_assign_set_rhs1 (gimple *gs, tree rhs)
2752 gimple_assign_set_rhs1 (ass, rhs);
2753}
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
2759inline tree
2760gimple_assign_rhs2 (const gassign *gs)
2761{
2762 if (gimple_num_ops (gs) >= 3)
2763 return gs->op[2];
2764 else
2765 return NULL_TREE;
2766}
2768inline tree
2769gimple_assign_rhs2 (const gimple *gs)
2770{
2771 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2772 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
2779inline tree *
2781{
2783 return &gs->op[2];
2784}
2785
2786inline tree *
2788{
2790 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
2796inline void
2798{
2800 gs->op[2] = rhs;
2801}
2802
2803inline void
2805{
2807 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
2813inline tree
2814gimple_assign_rhs3 (const gassign *gs)
2816 if (gimple_num_ops (gs) >= 4)
2817 return gs->op[3];
2818 else
2819 return NULL_TREE;
2820}
2821
2822inline tree
2823gimple_assign_rhs3 (const gimple *gs)
2824{
2826 return gimple_assign_rhs3 (ass);
2827}
2828
2829/* Return a pointer to the third operand on the RHS of assignment
2830 statement GS. */
2831
2832inline tree *
2833gimple_assign_rhs3_ptr (gimple *gs)
2837 return &ass->op[3];
2838}
2839
2840
2841/* Set RHS to be the third operand on the RHS of assignment statement GS. */
2843inline void
2845{
2847 gs->op[3] = rhs;
2848}
2849
2850inline void
2851gimple_assign_set_rhs3 (gimple *gs, tree rhs)
2852{
2853 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2855}
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
2861inline void
2862gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2863 tree op1, tree op2)
2864{
2865 gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
2866}
2868/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2869 which expect to see only one operands. */
2870
2871inline void
2873 tree op1)
2874{
2875 gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
2876}
2877
2878/* Returns true if GS is a nontemporal move. */
2879
2880inline bool
2882{
2883 return gs->nontemporal_move;
2884}
2885
2886/* Sets nontemporal move flag of GS to NONTEMPORAL. */
2887
2888inline void
2889gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
2891 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
2892 gs->nontemporal_move = nontemporal;
2893}
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
2900inline enum tree_code
2901gimple_assign_rhs_code (const gassign *gs)
2903 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. */
2908 code = TREE_CODE (gs->op[1]);
2909
2910 return code;
2912
2913inline enum tree_code
2914gimple_assign_rhs_code (const gimple *gs)
2915{
2916 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2917 return gimple_assign_rhs_code (ass);
2918}
2919
2921/* Set CODE to be the code for the expression computed on the RHS of
2922 assignment S. */
2923
2924inline void
2926{
2927 GIMPLE_CHECK (s, GIMPLE_ASSIGN);
2928 s->subcode = code;
2929}
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
2938{
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
2948inline bool
2950{
2951 return (is_gimple_assign (gs)
2953}
2955/* Return true if GS performs a store to its lhs. */
2956
2957inline bool
2958gimple_store_p (const gimple *gs)
2959{
2960 tree lhs = gimple_get_lhs (gs);
2961 return lhs && !is_gimple_reg (lhs);
2963
2964/* Return true if S is a type-cast assignment. */
2965
2966inline bool
2967gimple_assign_cast_p (const gimple *s)
2969 if (is_gimple_assign (s))
2970 {
2972 return CONVERT_EXPR_CODE_P (sc)
2973 || sc == VIEW_CONVERT_EXPR
2974 || sc == FIX_TRUNC_EXPR;
2975 }
2976
2977 return false;
2979
2980/* Return true if S is a clobber statement. */
2981
2982inline bool
2983gimple_clobber_p (const gimple *s)
2985 return gimple_assign_single_p (s)
2987}
2988
2989/* Return true if S is a clobber statement. */
2990
2991inline bool
2992gimple_clobber_p (const gimple *s, enum clobber_kind kind)
2993{
2995 && CLOBBER_KIND (gimple_assign_rhs1 (s)) == kind;
2996}
2997
2998/* Return true if GS is a GIMPLE_CALL. */
2999
3000inline bool
3001is_gimple_call (const gimple *gs)
3003 return gimple_code (gs) == GIMPLE_CALL;
3004}
3005
3006/* Return the LHS of call statement GS. */
3007
3008inline tree
3009gimple_call_lhs (const gcall *gs)
3010{
3011 return gs->op[0];
3012}
3014inline tree
3015gimple_call_lhs (const gimple *gs)
3016{
3017 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3018 return gimple_call_lhs (gc);
3020
3021
3022/* Return a pointer to the LHS of call statement GS. */
3023
3024inline tree *
3025gimple_call_lhs_ptr (gcall *gs)
3026{
3027 return &gs->op[0];
3029
3030inline tree *
3031gimple_call_lhs_ptr (gimple *gs)
3032{
3033 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3034 return gimple_call_lhs_ptr (gc);
3035}
3037
3038/* Set LHS to be the LHS operand of call statement GS. */
3039
3040inline void
3042{
3043 gs->op[0] = lhs;
3044 if (lhs && TREE_CODE (lhs) == SSA_NAME)
3045 SSA_NAME_DEF_STMT (lhs) = gs;
3046}
3048inline void
3050{
3051 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3052 gimple_call_set_lhs (gc, lhs);
3053}
3055
3056/* Return true if call GS calls an internal-only function, as enumerated
3057 by internal_fn. */
3058
3059inline bool
3060gimple_call_internal_p (const gcall *gs)
3061{
3062 return (gs->subcode & GF_CALL_INTERNAL) != 0;
3064
3065inline bool
3066gimple_call_internal_p (const gimple *gs)
3067{
3068 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3070}
3071
3072/* Return true if call GS is marked as nocf_check. */
3073
3074inline bool
3075gimple_call_nocf_check_p (const gcall *gs)
3076{
3077 return (gs->subcode & GF_CALL_NOCF_CHECK) != 0;
3079
3080/* Mark statement GS as nocf_check call. */
3081
3082inline void
3083gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
3084{
3085 if (nocf_check)
3087 else
3088 gs->subcode &= ~GF_CALL_NOCF_CHECK;
3090
3091/* Return the target of internal call GS. */
3092
3093inline enum internal_fn
3094gimple_call_internal_fn (const gcall *gs)
3095{
3097 return gs->u.internal_fn;
3099
3100inline enum internal_fn
3101gimple_call_internal_fn (const gimple *gs)
3102{
3103 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3104 return gimple_call_internal_fn (gc);
3105}
3106
3107/* Return true, if this internal gimple call is unique. */
3109inline bool
3111{
3112 return gimple_call_internal_fn (gs) == IFN_UNIQUE;
3113}
3115inline bool
3117{
3118 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3120}
3121
3122/* Return true if GS is an internal function FN. */
3123
3124inline bool
3126{
3127 return (is_gimple_call (gs)
3129 && 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
3135inline void
3136gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
3137{
3138 if (ctrl_altering_p)
3139 s->subcode |= GF_CALL_CTRL_ALTERING;
3140 else
3142}
3143
3144inline void
3145gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
3146{
3147 gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3148 gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
3149}
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
3154inline bool
3156{
3157 return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
3159
3160inline bool
3161gimple_call_ctrl_altering_p (const gimple *gs)
3162{
3163 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3164 return gimple_call_ctrl_altering_p (gc);
3165}
3166
3167
3168/* Return the function type of the function called by GS. */
3169
3170inline tree
3171gimple_call_fntype (const gcall *gs)
3172{
3173 if (gimple_call_internal_p (gs))
3175 return gs->u.fntype;
3176}
3177
3178inline tree
3179gimple_call_fntype (const gimple *gs)
3180{
3181 const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
3182 return gimple_call_fntype (call_stmt);
3183}
3185/* Set the type of the function called by CALL_STMT to FNTYPE. */
3186
3187inline void
3188gimple_call_set_fntype (gcall *call_stmt, tree fntype)
3189{
3191 call_stmt->u.fntype = fntype;
3192}
3193
3195/* Return the tree node representing the function called by call
3196 statement GS. */
3197
3198inline tree
3199gimple_call_fn (const gcall *gs)
3200{
3201 return gs->op[1];
3203
3204inline tree
3205gimple_call_fn (const gimple *gs)
3206{
3207 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3208 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
3214inline tree *
3216{
3217 return &gs->op[1];
3218}
3219
3220inline tree *
3221gimple_call_fn_ptr (gimple *gs)
3222{
3223 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3225}
3226
3227
3228/* Set FN to be the function called by call statement GS. */
3229
3230inline void
3232{
3234 gs->op[1] = fn;
3235}
3236
3237
3238/* Set FNDECL to be the function called by call statement GS. */
3239
3240inline void
3242{
3244 gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
3246}
3247
3248inline void
3249gimple_call_set_fndecl (gimple *gs, tree decl)
3250{
3251 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3252 gimple_call_set_fndecl (gc, decl);
3253}
3254
3255
3256/* Set internal function FN to be the function called by call statement CALL_STMT. */
3257
3258inline void
3259gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
3260{
3262 call_stmt->u.internal_fn = fn;
3263}
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
3270inline tree
3271gimple_call_fndecl (const gcall *gs)
3274}
3275
3276inline tree
3277gimple_call_fndecl (const gimple *gs)
3278{
3279 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3281}
3282
3283
3284/* Return the type returned by call statement GS. */
3285
3286inline tree
3287gimple_call_return_type (const gcall *gs)
3288{
3290
3291 if (type == NULL_TREE)
3292 return TREE_TYPE (gimple_call_lhs (gs));
3293
3294 /* The type returned by a function is the type of its
3295 function type. */
3296 return TREE_TYPE (type);
3297}
3298
3299
3300/* Return the static chain for call statement GS. */
3301
3302inline tree
3303gimple_call_chain (const gcall *gs)
3304{
3305 return gs->op[2];
3306}
3307
3308inline tree
3309gimple_call_chain (const gimple *gs)
3310{
3311 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3313}
3314
3315
3316/* Return a pointer to the static chain for call statement CALL_STMT. */
3317
3318inline tree *
3319gimple_call_chain_ptr (gcall *call_stmt)
3320{
3321 return &call_stmt->op[2];
3322}
3324/* Set CHAIN to be the static chain for call statement CALL_STMT. */
3325
3326inline void
3328{
3329 call_stmt->op[2] = chain;
3331
3332
3333/* Return the number of arguments used by call statement GS. */
3334
3335inline unsigned
3336gimple_call_num_args (const gcall *gs)
3337{
3338 return gimple_num_ops (gs) - 3;
3339}
3341inline unsigned
3342gimple_call_num_args (const gimple *gs)
3343{
3344 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3345 return gimple_call_num_args (gc);
3346}
3348
3349/* Return the argument at position INDEX for call statement GS. */
3350
3351inline tree
3352gimple_call_arg (const gcall *gs, unsigned index)
3353{
3354 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3355 return gs->op[index + 3];
3356}
3357
3358inline tree
3359gimple_call_arg (const gimple *gs, unsigned index)
3360{
3361 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3362 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
3369inline tree *
3370gimple_call_arg_ptr (gcall *gs, unsigned index)
3372 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3373 return &gs->op[index + 3];
3374}
3375
3376inline tree *
3377gimple_call_arg_ptr (gimple *gs, unsigned index)
3378{
3380 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
3386inline void
3387gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
3388{
3389 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3390 gs->op[index + 3] = arg;
3392
3393inline void
3394gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
3395{
3396 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3397 gimple_call_set_arg (gc, index, arg);
3398}
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
3405inline void
3406gimple_call_set_tail (gcall *s, bool tail_p)
3407{
3408 if (tail_p)
3409 s->subcode |= GF_CALL_TAILCALL;
3410 else
3411 s->subcode &= ~GF_CALL_TAILCALL;
3412}
3414
3415/* Return true if GIMPLE_CALL S is marked as a tail call. */
3416
3417inline bool
3418gimple_call_tail_p (const gcall *s)
3419{
3420 return (s->subcode & GF_CALL_TAILCALL) != 0;
3421}
3422
3423/* Mark (or clear) call statement S as requiring tail call optimization. */
3424
3425inline void
3426gimple_call_set_must_tail (gcall *s, bool must_tail_p)
3427{
3428 if (must_tail_p)
3429 s->subcode |= GF_CALL_MUST_TAIL_CALL;
3430 else
3431 s->subcode &= ~GF_CALL_MUST_TAIL_CALL;
3432}
3433
3434/* Return true if call statement has been marked as requiring
3435 tail call optimization. */
3436
3437inline bool
3439{
3440 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
3447inline void
3448gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
3449{
3450 if (return_slot_opt_p)
3451 s->subcode |= GF_CALL_RETURN_SLOT_OPT;
3452 else
3453 s->subcode &= ~GF_CALL_RETURN_SLOT_OPT;
3454}
3455
3456
3457/* Return true if S is marked for return slot optimization. */
3459inline bool
3461{
3462 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. */
3469inline void
3470gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
3471{
3472 if (from_thunk_p)
3473 s->subcode |= GF_CALL_FROM_THUNK;
3474 else
3475 s->subcode &= ~GF_CALL_FROM_THUNK;
3476}
3477
3478
3479/* Return true if GIMPLE_CALL S is a jump from a thunk. */
3480
3481inline bool
3483{
3484 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. */
3491inline void
3492gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
3493{
3494 if (from_new_or_delete_p)
3495 s->subcode |= GF_CALL_FROM_NEW_OR_DELETE;
3496 else
3497 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
3504inline bool
3505gimple_call_from_new_or_delete (const gcall *s)
3506{
3507 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
3514inline void
3515gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
3516{
3517 if (pass_arg_pack_p)
3518 s->subcode |= GF_CALL_VA_ARG_PACK;
3519 else
3520 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
3527inline bool
3529{
3530 return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
3531}
3532
3533
3534/* Return true if S is a noreturn call. */
3535
3536inline bool
3537gimple_call_noreturn_p (const gcall *s)
3538{
3539 return (gimple_call_flags (s) & ECF_NORETURN) != 0;
3541
3542inline bool
3543gimple_call_noreturn_p (const gimple *s)
3544{
3545 const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
3546 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
3553inline void
3554gimple_call_set_nothrow (gcall *s, bool nothrow_p)
3555{
3556 if (nothrow_p)
3557 s->subcode |= GF_CALL_NOTHROW;
3558 else
3559 s->subcode &= ~GF_CALL_NOTHROW;
3560}
3561
3562/* Return true if S is a nothrow call. */
3563
3564inline bool
3566{
3567 return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
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
3574static inline void
3575gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
3576{
3577 if (expected_throw_p)
3578 s->subcode |= GF_CALL_XTHROW;
3579 else
3580 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
3586static inline bool
3588{
3589 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
3597inline void
3598gimple_call_set_alloca_for_var (gcall *s, bool for_var)
3599{
3600 if (for_var)
3601 s->subcode |= GF_CALL_ALLOCA_FOR_VAR;
3602 else
3603 s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR;
3604}
3605
3606/* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3608inline bool
3610{
3611 return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3612}
3613
3614inline bool
3616{
3617 const gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3618 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
3624inline void
3625gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
3626{
3627 if (by_descriptor_p)
3628 s->subcode |= GF_CALL_BY_DESCRIPTOR;
3629 else
3630 s->subcode &= ~GF_CALL_BY_DESCRIPTOR;
3631}
3633/* Return true if S is a by-descriptor call. */
3634
3635inline bool
3637{
3638 return (s->subcode & GF_CALL_BY_DESCRIPTOR) != 0;
3639}
3640
3641/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3643inline void
3644gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
3645{
3646 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
3653inline struct pt_solution *
3654gimple_call_use_set (gcall *call_stmt)
3656 return &call_stmt->call_used;
3657}
3658
3659/* As above, but const. */
3660
3661inline const pt_solution *
3662gimple_call_use_set (const gcall *call_stmt)
3663{
3664 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
3670inline struct pt_solution *
3672{
3673 return &call_stmt->call_clobbered;
3674}
3675
3676/* As above, but const. */
3677
3678inline const pt_solution *
3679gimple_call_clobber_set (const gcall *call_stmt)
3680{
3681 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. */
3688inline bool
3689gimple_has_lhs (const gimple *stmt)
3690{
3691 if (is_gimple_assign (stmt))
3692 return true;
3693 if (const gcall *call = dyn_cast <const gcall *> (stmt))
3694 return gimple_call_lhs (call) != NULL_TREE;
3695 return false;
3696}
3698
3699/* Return the code of the predicate computed by conditional statement GS. */
3700
3701inline enum tree_code
3702gimple_cond_code (const gcond *gs)
3703{
3704 return (enum tree_code) gs->subcode;
3705}
3707inline enum tree_code
3708gimple_cond_code (const gimple *gs)
3709{
3710 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3711 return gimple_cond_code (gc);
3712}
3713
3714
3715/* Set CODE to be the predicate code for the conditional statement GS. */
3716
3717inline void
3718gimple_cond_set_code (gcond *gs, enum tree_code code)
3719{
3721 gs->subcode = code;
3722}
3723
3724
3725/* Return the LHS of the predicate computed by conditional statement GS. */
3726
3727inline tree
3728gimple_cond_lhs (const gcond *gs)
3729{
3730 return gs->op[0];
3732
3733inline tree
3734gimple_cond_lhs (const gimple *gs)
3735{
3736 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3737 return gimple_cond_lhs (gc);
3738}
3739
3740/* Return the pointer to the LHS of the predicate computed by conditional
3741 statement GS. */
3742
3743inline tree *
3745{
3746 return &gs->op[0];
3747}
3748
3749/* Set LHS to be the LHS operand of the predicate computed by
3750 conditional statement GS. */
3752inline void
3754{
3755 gs->op[0] = lhs;
3756}
3757
3758
3759/* Return the RHS operand of the predicate computed by conditional GS. */
3760
3761inline tree
3762gimple_cond_rhs (const gcond *gs)
3763{
3764 return gs->op[1];
3765}
3766
3767inline tree
3768gimple_cond_rhs (const gimple *gs)
3769{
3770 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3771 return gimple_cond_rhs (gc);
3772}
3773
3774/* Return the pointer to the RHS operand of the predicate computed by
3775 conditional GS. */
3776
3777inline tree *
3778gimple_cond_rhs_ptr (gcond *gs)
3779{
3780 return &gs->op[1];
3782
3783
3784/* Set RHS to be the RHS operand of the predicate computed by
3785 conditional statement GS. */
3786
3787inline void
3788gimple_cond_set_rhs (gcond *gs, tree rhs)
3789{
3790 gs->op[1] = rhs;
3791}
3792
3793
3794/* Return the label used by conditional statement GS when its
3795 predicate evaluates to true. */
3796
3797inline tree
3798gimple_cond_true_label (const gcond *gs)
3799{
3800 return gs->op[2];
3802
3803
3804/* Set LABEL to be the label used by conditional statement GS when its
3805 predicate evaluates to true. */
3806
3807inline void
3808gimple_cond_set_true_label (gcond *gs, tree label)
3809{
3810 gs->op[2] = label;
3811}
3813
3814/* Set LABEL to be the label used by conditional statement GS when its
3815 predicate evaluates to false. */
3816
3817inline void
3819{
3820 gs->op[3] = label;
3821}
3822
3823
3824/* Return the label used by conditional statement GS when its
3825 predicate evaluates to false. */
3826
3827inline tree
3828gimple_cond_false_label (const gcond *gs)
3829{
3830 return gs->op[3];
3831}
3832
3833
3834/* Set the conditional COND_STMT to be of the form 'if (0 != 0)'. */
3835
3836inline void
3838{
3841 gs->subcode = NE_EXPR;
3842}
3843
3844
3845/* Set the conditional COND_STMT to be of the form 'if (1 != 0)'. */
3846
3847inline void
3848gimple_cond_make_true (gcond *gs)
3849{
3852 gs->subcode = NE_EXPR;
3853}
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
3858inline bool
3859gimple_cond_true_p (const gcond *gs)
3860{
3861 tree lhs = gimple_cond_lhs (gs);
3862 tree rhs = gimple_cond_rhs (gs);
3863 enum tree_code code = gimple_cond_code (gs);
3864
3866 return false;
3867
3869 return false;
3870
3871 if (code == NE_EXPR && lhs != rhs)
3872 return true;
3873
3874 if (code == EQ_EXPR && lhs == rhs)
3875 return true;
3877 return false;
3878}
3879
3880/* Check if conditional statement GS is in the caonical form of 'if (1 != 0)'. */
3881
3882inline bool
3883gimple_cond_true_canonical_p (const gcond *gs)
3884{
3885 tree lhs = gimple_cond_lhs (gs);
3886 tree rhs = gimple_cond_rhs (gs);
3887 tree_code code = gimple_cond_code (gs);
3888 if (code == NE_EXPR
3890 && rhs == boolean_false_node)
3891 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
3898inline bool
3899gimple_cond_false_p (const gcond *gs)
3900{
3901 tree lhs = gimple_cond_lhs (gs);
3902 tree rhs = gimple_cond_rhs (gs);
3903 enum tree_code code = gimple_cond_code (gs);
3904
3906 return false;
3908 if (rhs != boolean_true_node && rhs != boolean_false_node)
3909 return false;
3910
3911 if (code == NE_EXPR && lhs == rhs)
3912 return true;
3913
3914 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
3922inline bool
3923gimple_cond_false_canonical_p (const gcond *gs)
3925 tree lhs = gimple_cond_lhs (gs);
3926 tree rhs = gimple_cond_rhs (gs);
3927 tree_code code = gimple_cond_code (gs);
3928 if (code == NE_EXPR
3929 && lhs == boolean_false_node
3930 && rhs == boolean_false_node)
3931 return true;
3932 return false;
3933}
3935/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3936
3937inline void
3938gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs,
3939 tree rhs)
3940{
3941 gimple_cond_set_code (stmt, code);
3942 gimple_cond_set_lhs (stmt, lhs);
3944}
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
3953inline enum tree_code
3954gimple_expr_code (const gimple *stmt)
3955{
3956 if (const gassign *ass = dyn_cast<const gassign *> (stmt))
3957 return gimple_assign_rhs_code (ass);
3958 if (const gcond *cond = dyn_cast<const gcond *> (stmt))
3959 return gimple_cond_code (cond);
3960 else
3961 {
3963 return CALL_EXPR;
3964 }
3965}
3966
3967
3968/* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3969
3970inline tree
3971gimple_label_label (const glabel *gs)
3973 return gs->op[0];
3974}
3975
3976
3977/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3978 GS. */
3979
3980inline void
3981gimple_label_set_label (glabel *gs, tree label)
3983 gs->op[0] = label;
3984}
3985
3986
3987/* Return the destination of the unconditional jump GS. */
3988
3989inline tree
3990gimple_goto_dest (const gimple *gs)
3991{
3992 GIMPLE_CHECK (gs, GIMPLE_GOTO);
3993 return gimple_op (gs, 0);
3994}
3995
3996
3997/* Set DEST to be the destination of the unconditonal jump GS. */
3998
3999inline void
4001{
4002 gs->op[0] = dest;
4003}
4004
4005
4006/* Return the variables declared in the GIMPLE_BIND statement GS. */
4008inline tree
4009gimple_bind_vars (const gbind *bind_stmt)
4010{
4011 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
4018inline void
4019gimple_bind_set_vars (gbind *bind_stmt, tree vars)
4020{
4021 bind_stmt->vars = vars;
4022}
4023
4024
4025/* Append VARS to the set of variables declared in the GIMPLE_BIND
4026 statement GS. */
4027
4028inline void
4029gimple_bind_append_vars (gbind *bind_stmt, tree vars)
4030{
4031 bind_stmt->vars = chainon (bind_stmt->vars, vars);
4032}
4033
4034
4036gimple_bind_body_ptr (gbind *bind_stmt)
4037{
4038 return &bind_stmt->body;
4039}
4040
4041/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
4042
4043inline gimple_seq
4044gimple_bind_body (const gbind *gs)
4046 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
4053inline void
4054gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
4055{
4056 bind_stmt->body = seq;
4057}
4058
4059
4060/* Append a statement to the end of a GIMPLE_BIND's body. */
4061
4062inline void
4063gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
4064{
4065 gimple_seq_add_stmt (&bind_stmt->body, stmt);
4066}
4067
4068
4069/* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
4070
4071inline void
4072gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
4073{
4074 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
4081inline tree
4082gimple_bind_block (const gbind *bind_stmt)
4083{
4084 return bind_stmt->block;
4085}
4086
4087
4088/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
4089 statement GS. */
4091inline void
4092gimple_bind_set_block (gbind *bind_stmt, tree block)
4093{
4095 || TREE_CODE (block) == BLOCK);
4096 bind_stmt->block = block;
4097}
4098
4100/* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
4101
4102inline unsigned
4103gimple_asm_ninputs (const gasm *asm_stmt)
4104{
4105 return asm_stmt->ni;
4106}
4107
4108
4109/* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
4111inline unsigned
4112gimple_asm_noutputs (const gasm *asm_stmt)
4113{
4114 return asm_stmt->no;
4115}
4116
4117
4118/* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
4120inline unsigned
4121gimple_asm_nclobbers (const gasm *asm_stmt)
4122{
4123 return asm_stmt->nc;
4124}
4125
4126/* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
4127
4128inline unsigned
4129gimple_asm_nlabels (const gasm *asm_stmt)
4131 return asm_stmt->nl;
4132}
4133
4134/* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
4135
4136inline tree
4137gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
4138{
4139 gcc_gimple_checking_assert (index < asm_stmt->ni);
4140 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
4145inline void
4146gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
4147{
4148 gcc_gimple_checking_assert (index < asm_stmt->ni
4149 && TREE_CODE (in_op) == TREE_LIST);
4150 asm_stmt->op[index + asm_stmt->no] = in_op;
4151}
4152
4153
4154/* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
4155
4156inline tree
4157gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
4158{
4159 gcc_gimple_checking_assert (index < asm_stmt->no);
4160 return asm_stmt->op[index];
4161}
4162
4163/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
4164
4165inline void
4166gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
4167{
4168 gcc_gimple_checking_assert (index < asm_stmt->no
4169 && TREE_CODE (out_op) == TREE_LIST);
4170 asm_stmt->op[index] = out_op;
4171}
4172
4173
4174/* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
4175
4176inline tree
4177gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
4178{
4179 gcc_gimple_checking_assert (index < asm_stmt->nc);
4180 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
4186inline void
4187gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
4189 gcc_gimple_checking_assert (index < asm_stmt->nc
4190 && TREE_CODE (clobber_op) == TREE_LIST);
4191 asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op;
4192}
4193
4194/* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
4195
4196inline tree
4197gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
4198{
4199 gcc_gimple_checking_assert (index < asm_stmt->nl);
4200 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
4205inline void
4206gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
4207{
4208 gcc_gimple_checking_assert (index < asm_stmt->nl
4209 && TREE_CODE (label_op) == TREE_LIST);
4210 asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc] = label_op;
4211}
4212
4213/* Return the string representing the assembly instruction in
4214 GIMPLE_ASM ASM_STMT. */
4215
4216inline const char *
4217gimple_asm_string (const gasm *asm_stmt)
4218{
4219 return asm_stmt->string;
4220}
4221
4223/* Return true if ASM_STMT is marked volatile. */
4224
4225inline bool
4226gimple_asm_volatile_p (const gasm *asm_stmt)
4227{
4228 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
4234inline void
4235gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
4236{
4237 if (volatile_p)
4238 asm_stmt->subcode |= GF_ASM_VOLATILE;
4239 else
4240 asm_stmt->subcode &= ~GF_ASM_VOLATILE;
4241}
4242
4244/* Return true if ASM_STMT is marked inline. */
4245
4246inline bool
4247gimple_asm_inline_p (const gasm *asm_stmt)
4248{
4249 return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
4250}
4251
4253/* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
4254
4255inline void
4256gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
4257{
4258 if (inline_p)
4259 asm_stmt->subcode |= GF_ASM_INLINE;
4260 else
4261 asm_stmt->subcode &= ~GF_ASM_INLINE;
4263
4264
4265/* Mark whether asm ASM_STMT is a basic asm or an extended asm, based on
4266 BASIC_P. */
4267
4268inline void
4269gimple_asm_set_basic (gasm *asm_stmt, bool basic_p)
4270{
4271 if (basic_p)
4272 asm_stmt->subcode |= GF_ASM_BASIC;
4273 else
4274 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
4280inline bool
4281gimple_asm_basic_p (const gasm *asm_stmt)
4282{
4283 return (asm_stmt->subcode & GF_ASM_BASIC) != 0;
4284}
4285
4286
4287/* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4288
4289inline tree
4290gimple_catch_types (const gcatch *catch_stmt)
4291{
4292 return catch_stmt->types;
4293}
4294
4295
4296/* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4297
4298inline tree *
4300{
4301 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
4308inline gimple_seq *
4309gimple_catch_handler_ptr (gcatch *catch_stmt)
4311 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
4318inline gimple_seq
4319gimple_catch_handler (const gcatch *catch_stmt)
4320{
4321 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
4327inline void
4328gimple_catch_set_types (gcatch *catch_stmt, tree t)
4329{
4330 catch_stmt->types = t;
4331}
4333
4334/* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4335
4336inline void
4337gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
4338{
4339 catch_stmt->handler = handler;
4340}
4341
4343/* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4344
4345inline tree
4347{
4348 const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
4349 return eh_filter_stmt->types;
4350}
4351
4353/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4354 GS. */
4355
4356inline tree *
4358{
4359 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4360 return &eh_filter_stmt->types;
4362
4363
4364/* Return a pointer to the sequence of statement to execute when
4365 GIMPLE_EH_FILTER statement fails. */
4366
4367inline gimple_seq *
4370 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4371 return &eh_filter_stmt->failure;
4372}
4373
4374
4375/* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4376 statement fails. */
4377
4380{
4381 return *gimple_eh_filter_failure_ptr (const_cast <gimple *> (gs));
4382}
4383
4385/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4386 EH_FILTER_STMT. */
4387
4388inline void
4389gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
4391 eh_filter_stmt->types = types;
4392}
4393
4394
4395/* Set FAILURE to be the sequence of statements to execute on failure
4396 for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4397
4398inline void
4401{
4402 eh_filter_stmt->failure = failure;
4403}
4404
4405/* Get the function decl to be called by the MUST_NOT_THROW region. */
4406
4407inline tree
4409{
4410 return eh_mnt_stmt->fndecl;
4411}
4412
4413/* Set the function decl to be called by GS to DECL. */
4414
4415inline void
4416gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt,
4417 tree decl)
4418{
4419 eh_mnt_stmt->fndecl = decl;
4420}
4421
4422/* GIMPLE_EH_ELSE accessors. */
4423
4424inline gimple_seq *
4425gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
4426{
4427 return &eh_else_stmt->n_body;
4428}
4430inline gimple_seq
4431gimple_eh_else_n_body (const geh_else *eh_else_stmt)
4432{
4433 return *gimple_eh_else_n_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4434}
4435
4436inline gimple_seq *
4437gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
4438{
4439 return &eh_else_stmt->e_body;
4440}
4442inline gimple_seq
4443gimple_eh_else_e_body (const geh_else *eh_else_stmt)
4444{
4445 return *gimple_eh_else_e_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4446}
4447
4448inline void
4449gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
4450{
4451 eh_else_stmt->n_body = seq;
4453
4454inline void
4455gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
4456{
4457 eh_else_stmt->e_body = seq;
4458}
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
4465inline enum gimple_try_flags
4466gimple_try_kind (const gimple *gs)
4467{
4468 GIMPLE_CHECK (gs, GIMPLE_TRY);
4469 return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
4470}
4471
4473/* Set the kind of try block represented by GIMPLE_TRY GS. */
4474
4475inline void
4477{
4479 || kind == GIMPLE_TRY_FINALLY);
4480 if (gimple_try_kind (gs) != kind)
4481 gs->subcode = (unsigned int) kind;
4482}
4484
4485/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4486
4487inline bool
4489{
4491 return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
4493
4494
4495/* Return a pointer to the sequence of statements used as the
4496 body for GIMPLE_TRY GS. */
4497
4498inline gimple_seq *
4499gimple_try_eval_ptr (gimple *gs)
4500{
4501 gtry *try_stmt = as_a <gtry *> (gs);
4502 return &try_stmt->eval;
4503}
4504
4505
4506/* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4507
4508inline gimple_seq
4509gimple_try_eval (const gimple *gs)
4510{
4511 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
4518inline gimple_seq *
4520{
4521 gtry *try_stmt = as_a <gtry *> (gs);
4522 return &try_stmt->cleanup;
4523}
4524
4526/* Return the sequence of statements used as the cleanup body for
4527 GIMPLE_TRY GS. */
4528
4529inline gimple_seq
4530gimple_try_cleanup (const gimple *gs)
4531{
4532 return *gimple_try_cleanup_ptr (const_cast <gimple *> (gs));
4533}
4534
4536/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4537
4538inline void
4539gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
4540{
4542 if (catch_is_cleanup)
4543 g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
4544 else
4545 g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
4546}
4547
4548
4549/* Set EVAL to be the sequence of statements to use as the body for
4550 GIMPLE_TRY TRY_STMT. */
4551
4552inline void
4553gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
4555 try_stmt->eval = eval;
4556}
4557
4558
4559/* Set CLEANUP to be the sequence of statements to use as the cleanup
4560 body for GIMPLE_TRY TRY_STMT. */
4561
4562inline void
4563gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
4565 try_stmt->cleanup = cleanup;
4566}
4567
4568
4569/* Return a pointer to the cleanup sequence for cleanup statement GS. */
4570
4571inline gimple_seq *
4572gimple_wce_cleanup_ptr (gimple *gs)
4573{
4575 return &wce_stmt->cleanup;
4576}
4577
4578
4579/* Return the cleanup sequence for cleanup statement GS. */
4580
4581inline gimple_seq
4582gimple_wce_cleanup (gimple *gs)
4583{
4584 return *gimple_wce_cleanup_ptr (gs);
4585}
4587
4588/* Set CLEANUP to be the cleanup sequence for GS. */
4589
4590inline void
4592{
4594 wce_stmt->cleanup = cleanup;
4595}
4597
4598/* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4599
4600inline bool
4603 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4604 return gs->subcode != 0;
4605}
4606
4607
4608/* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4609
4610inline void
4612{
4613 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4614 gs->subcode = (unsigned int) eh_only_p;
4615}
4616
4618/* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4619
4620inline unsigned
4621gimple_phi_capacity (const gimple *gs)
4622{
4623 const gphi *phi_stmt = as_a <const gphi *> (gs);
4624 return phi_stmt->capacity;
4625}
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
4632inline unsigned
4633gimple_phi_num_args (const gimple *gs)
4634{
4635 const gphi *phi_stmt = as_a <const gphi *> (gs);
4636 return phi_stmt->nargs;
4637}
4639
4640/* Return the SSA name created by GIMPLE_PHI GS. */
4641
4642inline tree
4643gimple_phi_result (const gphi *gs)
4644{
4645 return gs->result;
4646}
4647
4648inline tree
4649gimple_phi_result (const gimple *gs)
4650{
4651 const gphi *phi_stmt = as_a <const gphi *> (gs);
4652 return gimple_phi_result (phi_stmt);
4653}
4654
4655/* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4656
4657inline tree *
4658gimple_phi_result_ptr (gphi *gs)
4660 return &gs->result;
4661}
4662
4663inline tree *
4664gimple_phi_result_ptr (gimple *gs)
4665{
4666 gphi *phi_stmt = as_a <gphi *> (gs);
4667 return gimple_phi_result_ptr (phi_stmt);
4668}
4670/* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4671
4672inline void
4673gimple_phi_set_result (gphi *phi, tree result)
4674{
4675 phi->result = result;
4676 if (result && TREE_CODE (result) == SSA_NAME)
4677 SSA_NAME_DEF_STMT (result) = phi;
4678}
4680
4681/* Return the PHI argument corresponding to incoming edge INDEX for
4682 GIMPLE_PHI GS. */
4683
4684inline struct phi_arg_d *
4685gimple_phi_arg (gphi *gs, unsigned index)
4686{
4687 gcc_gimple_checking_assert (index < gs->nargs);
4688 return &(gs->args[index]);
4689}
4690
4691inline const phi_arg_d *
4692gimple_phi_arg (const gphi *gs, unsigned index)
4693{
4694 gcc_gimple_checking_assert (index < gs->nargs);
4695 return &(gs->args[index]);
4696}
4698inline const phi_arg_d *
4699gimple_phi_arg (const gimple *gs, unsigned index)
4700{
4701 const gphi *phi_stmt = as_a <const gphi *> (gs);
4702 return gimple_phi_arg (phi_stmt, index);
4704
4705inline struct phi_arg_d *
4706gimple_phi_arg (gimple *gs, unsigned index)
4707{
4708 gphi *phi_stmt = as_a <gphi *> (gs);
4709 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
4715inline void
4716gimple_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
4725inline gimple_seq
4727{
4728 gcc_checking_assert (!(bb->flags & BB_RTL));
4729 return bb->il.gimple.phi_nodes;
4730}
4731
4732/* Return a pointer to the PHI nodes for basic block BB. */
4733
4734inline gimple_seq *
4737 gcc_checking_assert (!(bb->flags & BB_RTL));
4738 return &bb->il.gimple.phi_nodes;
4739}
4740
4741/* Return the tree operand for argument I of PHI node GS. */
4742
4743inline tree
4744gimple_phi_arg_def (const gphi *gs, size_t index)
4745{
4746 return gimple_phi_arg (gs, index)->def;
4747}
4748
4749inline tree
4750gimple_phi_arg_def (const gimple *gs, size_t index)
4751{
4752 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
4758inline tree
4759gimple_phi_arg_def_from_edge (const gphi *gs, const_edge e)
4761 gcc_checking_assert (e->dest == gimple_bb (gs));
4762 return gimple_phi_arg (gs, e->dest_idx)->def;
4763}
4764
4765inline tree
4766gimple_phi_arg_def_from_edge (const gimple *gs, const_edge e)
4767{
4769 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
4774inline tree *
4775gimple_phi_arg_def_ptr (gphi *phi, size_t index)
4777 return &gimple_phi_arg (phi, index)->def;
4778}
4779
4780/* Return the edge associated with argument I of phi node PHI. */
4781
4782inline edge
4783gimple_phi_arg_edge (const gphi *phi, size_t i)
4785 return EDGE_PRED (gimple_bb (phi), i);
4786}
4787
4788/* Return the source location of gimple argument I of phi node PHI. */
4789
4790inline location_t
4791gimple_phi_arg_location (const gphi *phi, size_t i)
4792{
4793 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
4798inline location_t
4800{
4801 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
4806inline void
4807gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
4808{
4809 gimple_phi_arg (phi, i)->locus = loc;
4810}
4812/* Return address of source location of gimple argument I of phi node PHI. */
4813
4814inline location_t *
4815gimple_phi_arg_location_ptr (gphi *phi, size_t i)
4816{
4817 return &gimple_phi_arg (phi, i)->locus;
4818}
4819
4820/* Return TRUE if argument I of phi node PHI has a location record. */
4821
4822inline bool
4824{
4826}
4827
4828/* Return the number of arguments that can be accessed by gimple_arg. */
4829
4830inline unsigned
4832{
4833 if (auto phi = dyn_cast<const gphi *> (gs))
4834 return gimple_phi_num_args (phi);
4835 if (auto call = dyn_cast<const gcall *> (gs))
4836 return gimple_call_num_args (call);
4837 return gimple_num_ops (as_a <const gassign *> (gs)) - 1;
4838}
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
4845inline tree
4846gimple_arg (const gimple *gs, unsigned int i)
4847{
4848 if (auto phi = dyn_cast<const gphi *> (gs))
4849 return gimple_phi_arg_def (phi, i);
4850 if (auto call = dyn_cast<const gcall *> (gs))
4851 return gimple_call_arg (call, i);
4852 return gimple_op (as_a <const gassign *> (gs), i + 1);
4853}
4854
4855/* Return a pointer to gimple_arg (GS, I). */
4857inline tree *
4858gimple_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
4869inline int
4870gimple_resx_region (const gresx *resx_stmt)
4871{
4872 return resx_stmt->region;
4873}
4874
4875/* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4876
4877inline void
4878gimple_resx_set_region (gresx *resx_stmt, int region)
4880 resx_stmt->region = region;
4881}
4882
4883/* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4884
4885inline int
4886gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
4887{
4888 return eh_dispatch_stmt->region;
4889}
4890
4891/* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4892 EH_DISPATCH_STMT. */
4893
4894inline void
4895gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
4896{
4897 eh_dispatch_stmt->region = region;
4898}
4899
4900/* Return the number of labels associated with the switch statement GS. */
4901
4902inline unsigned
4903gimple_switch_num_labels (const gswitch *gs)
4904{
4905 unsigned num_ops;
4906 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
4907 num_ops = gimple_num_ops (gs);
4909 return num_ops - 1;
4910}
4911
4912
4913/* Set NLABELS to be the number of labels for the switch statement GS. */
4914
4915inline void
4916gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
4918 GIMPLE_CHECK (g, GIMPLE_SWITCH);
4919 gimple_set_num_ops (g, nlabels + 1);
4920}
4921
4922
4923/* Return the index variable used by the switch statement GS. */
4924
4925inline tree
4926gimple_switch_index (const gswitch *gs)
4927{
4928 return gs->op[0];
4929}
4930
4931
4932/* Return a pointer to the index variable for the switch statement GS. */
4933
4934inline tree *
4935gimple_switch_index_ptr (gswitch *gs)
4936{
4937 return &gs->op[0];
4939
4940
4941/* Set INDEX to be the index variable for switch statement GS. */
4942
4943inline void
4944gimple_switch_set_index (gswitch *gs, tree index)
4945{
4947 gs->op[0] = index;
4948}
4949
4950
4951/* Return the label numbered INDEX. The default label is 0, followed by any
4952 labels in a switch statement. */
4953
4954inline tree
4955gimple_switch_label (const gswitch *gs, unsigned index)
4957 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
4958 return gs->op[index + 1];
4959}
4960
4961/* Set the label number INDEX to LABEL. 0 is always the default label. */
4962
4963inline void
4964gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
4965{
4967 && (label == NULL_TREE
4968 || TREE_CODE (label) == CASE_LABEL_EXPR));
4969 gs->op[index + 1] = label;
4970}
4971
4972/* Return the default label for a switch statement. */
4973
4974inline tree
4975gimple_switch_default_label (const gswitch *gs)
4976{
4977 tree label = gimple_switch_label (gs, 0);
4978 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4979 return label;
4980}
4981
4982/* Set the default label for a switch statement. */
4984inline void
4986{
4987 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4988 gimple_switch_set_label (gs, 0, label);
4989}
4990
4991/* Return true if GS is a GIMPLE_DEBUG statement. */
4992
4993inline bool
4995{
4996 return gimple_code (gs) == GIMPLE_DEBUG;
4997}
4998
4999
5000/* Return the first nondebug statement in GIMPLE sequence S. */
5001
5002inline gimple *
5004{
5006 while (n && is_gimple_debug (n))
5007 n = n->next;
5008 return n;
5009}
5010
5011
5012/* Return the last nondebug statement in GIMPLE sequence S. */
5013
5014inline gimple *
5018 for (n = gimple_seq_last (s);
5019 n && is_gimple_debug (n);
5020 n = n->prev)
5021 if (n == s)
5022 return NULL;
5023 return n;
5024}
5025
5027/* Return true if S is a GIMPLE_DEBUG BIND statement. */
5028
5029inline bool
5030gimple_debug_bind_p (const gimple *s)
5031{
5032 if (is_gimple_debug (s))
5033 return s->subcode == GIMPLE_DEBUG_BIND;
5034
5035 return false;
5036}
5038/* Return the variable bound in a GIMPLE_DEBUG bind statement. */
5039
5040inline tree
5042{
5043 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5045 return gimple_op (dbg, 0);
5047
5048/* Return the value bound to the variable in a GIMPLE_DEBUG bind
5049 statement. */
5050
5051inline tree
5053{
5054 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5056 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
5062inline tree *
5064{
5065 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5067 return gimple_op_ptr (dbg, 1);
5068}
5069
5070/* Set the variable bound in a GIMPLE_DEBUG bind statement. */
5071
5072inline void
5073gimple_debug_bind_set_var (gimple *dbg, tree var)
5074{
5075 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5077 gimple_set_op (dbg, 0, var);
5078}
5079
5080/* Set the value bound to the variable in a GIMPLE_DEBUG bind
5081 statement. */
5082
5083inline void
5085{
5086 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5088 gimple_set_op (dbg, 1, value);
5089}
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. */
5098inline void
5100{
5101 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5104}
5105
5106/* Return true if the GIMPLE_DEBUG bind statement is bound to a
5107 value. */
5109inline bool
5111{
5112 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5114 return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
5115}
5116
5117#undef GIMPLE_DEBUG_BIND_NOVALUE
5119/* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
5120
5121inline bool
5123{
5124 if (is_gimple_debug (s))
5125 return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
5126
5127 return false;
5128}
5130/* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
5131
5132inline tree
5134{
5135 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5137 return gimple_op (dbg, 0);
5138}
5140/* Return the value bound to the variable in a GIMPLE_DEBUG source bind
5141 statement. */
5142
5143inline tree
5145{
5146 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5148 return gimple_op (dbg, 1);
5149}
5151/* Return a pointer to the value bound to the variable in a
5152 GIMPLE_DEBUG source bind statement. */
5153
5154inline tree *
5156{
5157 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5159 return gimple_op_ptr (dbg, 1);
5160}
5162/* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
5163
5164inline void
5166{
5167 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5169 gimple_set_op (dbg, 0, var);
5170}
5171
5172/* Set the value bound to the variable in a GIMPLE_DEBUG source bind
5173 statement. */
5174
5175inline void
5177{
5178 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5180 gimple_set_op (dbg, 1, value);
5181}
5182
5183/* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
5184
5185inline bool
5186gimple_debug_begin_stmt_p (const gimple *s)
5187{
5188 if (is_gimple_debug (s))
5189 return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
5191 return false;
5192}
5193
5194/* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
5195
5196inline bool
5197gimple_debug_inline_entry_p (const gimple *s)
5199 if (is_gimple_debug (s))
5200 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. */
5207inline bool
5209{
5210 if (is_gimple_debug (s))
5211 return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
5212 || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5213
5214 return false;
5216
5217/* Return the line number for EXPR, or return -1 if we have no line
5218 number information for it. */
5219inline int
5220get_lineno (const gimple *stmt)
5221{
5222 location_t loc;
5223
5224 if (!stmt)
5225 return -1;
5226
5227 loc = gimple_location (stmt);
5228 if (loc == UNKNOWN_LOCATION)
5229 return -1;
5230
5231 return LOCATION_LINE (loc);
5232}
5233
5234/* Return a pointer to the body for the OMP statement GS. */
5236inline gimple_seq *
5238{
5239 return &static_cast <gimple_statement_omp *> (gs)->body;
5240}
5241
5242/* Return the body for the OMP statement GS. */
5243
5245gimple_omp_body (const gimple *gs)
5246{
5247 return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
5248}
5249
5250/* Set BODY to be the body for the OMP statement GS. */
5251
5252inline void
5253gimple_omp_set_body (gimple *gs, gimple_seq body)
5255 static_cast <gimple_statement_omp *> (gs)->body = body;
5256}
5257
5258
5259/* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
5260
5261inline tree
5262gimple_omp_critical_name (const gomp_critical *crit_stmt)
5263{
5264 return crit_stmt->name;
5265}
5266
5267
5268/* Return a pointer to the name associated with OMP critical statement
5269 CRIT_STMT. */
5270
5271inline tree *
5272gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
5274 return &crit_stmt->name;
5275}
5276
5277
5278/* Set NAME to be the name associated with OMP critical statement
5279 CRIT_STMT. */
5280
5281inline void
5282gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
5284 crit_stmt->name = name;
5285}
5286
5287
5288/* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
5289
5290inline tree
5291gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
5292{
5293 return crit_stmt->clauses;
5294}
5295
5296
5297/* Return a pointer to the clauses associated with OMP critical statement
5298 CRIT_STMT. */
5299
5300inline tree *
5301gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
5303 return &crit_stmt->clauses;
5304}
5305
5306
5307/* Set CLAUSES to be the clauses associated with OMP critical statement
5308 CRIT_STMT. */
5309
5310inline void
5311gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
5313 crit_stmt->clauses = clauses;
5314}
5315
5316
5317/* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
5318
5319inline tree
5320gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
5321{
5322 return ord_stmt->clauses;
5323}
5324
5325
5326/* Return a pointer to the clauses associated with OMP ordered statement
5327 ORD_STMT. */
5328
5329inline tree *
5330gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
5332 return &ord_stmt->clauses;
5333}
5334
5335
5336/* Set CLAUSES to be the clauses associated with OMP ordered statement
5337 ORD_STMT. */
5338
5339inline void
5340gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
5341{
5342 ord_stmt->clauses = clauses;
5344
5345
5346/* Return the clauses associated with OMP_SCAN statement SCAN_STMT. */
5347
5348inline tree
5349gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
5350{
5351 return scan_stmt->clauses;
5352}
5353
5355/* Return a pointer to the clauses associated with OMP scan statement
5356 ORD_STMT. */
5357
5358inline tree *
5360{
5361 return &scan_stmt->clauses;
5362}
5363
5364
5365/* Set CLAUSES to be the clauses associated with OMP scan statement
5366 ORD_STMT. */
5367
5368inline void
5369gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
5370{
5371 scan_stmt->clauses = clauses;
5372}
5373
5374
5375/* Return the clauses associated with OMP_TASKGROUP statement GS. */
5376
5377inline tree
5379{
5380 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5381 return
5382 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. */
5389inline tree *
5391{
5392 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5393 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. */
5400inline void
5402{
5403 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5404 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5405 = clauses;
5406}
5407
5408
5409/* Return the clauses associated with OMP_MASKED statement GS. */
5410
5411inline tree
5413{
5414 GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5415 return
5416 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. */
5423inline tree *
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
5434inline void
5436{
5437 GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5438 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5439 = clauses;
5440}
5441
5443/* Return the clauses associated with OMP_SCOPE statement GS. */
5444
5445inline tree
5447{
5448 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5449 return
5450 static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5451}
5453
5454/* Return a pointer to the clauses associated with OMP scope statement
5455 GS. */
5456
5457inline tree *
5459{
5460 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5461 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
5468inline void
5469gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
5471 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5472 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5473 = clauses;
5474}
5475
5476/* Return the clauses associated with OMP_DISPATCH statement GS. */
5477
5478inline tree
5479gimple_omp_dispatch_clauses (const gimple *gs)
5481 GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5482 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
5488inline tree *
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
5498inline void
5500{
5501 GIMPLE_CHECK (gs, GIMPLE_OMP_DISPATCH);
5502 static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5503}
5504
5505/* Return the clauses associated with OMP_INTEROP statement GS. */
5506
5507inline tree
5508gimple_omp_interop_clauses (const gimple *gs)
5509{
5510 GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5511 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
5516inline tree *
5518{
5519 GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5520 return &static_cast<gimple_statement_omp_single_layout *> (gs)->clauses;
5522
5523/* Set CLAUSES to be the clauses associated with OMP interop statement
5524 GS. */
5525
5526inline void
5527gimple_omp_interop_set_clauses (gimple *gs, tree clauses)
5528{
5529 GIMPLE_CHECK (gs, GIMPLE_OMP_INTEROP);
5530 static_cast<gimple_statement_omp_single_layout *> (gs)->clauses = clauses;
5531}
5532
5533/* Return the kind of the OMP_FOR statemement G. */
5535inline int
5537{
5538 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5540}
5541
5542
5543/* Set the kind of the OMP_FOR statement G. */
5544
5545inline void
5547{
5548 g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
5549 | (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
5556inline bool
5558{
5559 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5560 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
5567inline void
5569{
5570 if (combined_p)
5571 g->subcode |= GF_OMP_FOR_COMBINED;
5572 else
5573 g->subcode &= ~GF_OMP_FOR_COMBINED;
5574}
5575
5576
5577/* Return true if the OMP_FOR statement G has the
5578 GF_OMP_FOR_COMBINED_INTO flag set. */
5580inline bool
5582{
5583 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
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
5591inline void
5593{
5594 if (combined_p)
5595 g->subcode |= GF_OMP_FOR_COMBINED_INTO;
5596 else
5597 g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
5598}
5600
5601/* Return the clauses associated with the OMP_FOR statement GS. */
5602
5603inline tree
5605{
5606 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5607 return omp_for_stmt->clauses;
5608}
5609
5611/* Return a pointer to the clauses associated with the OMP_FOR statement
5612 GS. */
5613
5614inline tree *
5616{
5617 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5618 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
5625inline void
5627{
5628 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5629 omp_for_stmt->clauses = clauses;
5630}
5631
5632
5633/* Get the collapse count of the OMP_FOR statement GS. */
5634
5635inline size_t
5637{
5638 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5639 return omp_for_stmt->collapse;
5640}
5641
5642
5643/* Return the condition code associated with the OMP_FOR statement GS. */
5645inline enum tree_code
5646gimple_omp_for_cond (const gimple *gs, size_t i)
5647{
5648 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5650 return omp_for_stmt->iter[i].cond;
5651}
5652
5653
5654/* Set COND to be the condition code for the OMP_FOR statement GS. */
5656inline void
5657gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
5658{
5659 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5661 && i < omp_for_stmt->collapse);
5662 omp_for_stmt->iter[i].cond = cond;
5663}
5664
5665
5666/* Return the index variable for the OMP_FOR statement GS. */
5667
5668inline tree
5669gimple_omp_for_index (const gimple *gs, size_t i)
5670{
5671 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5673 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
5679inline tree *
5680gimple_omp_for_index_ptr (gimple *gs, size_t i)
5681{
5682 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5684 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
5690inline void
5691gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
5692{
5693 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5695 omp_for_stmt->iter[i].index = index;
5696}
5697
5698
5699/* Return the initial value for the OMP_FOR statement GS. */
5700
5701inline tree
5702gimple_omp_for_initial (const gimple *gs, size_t i)
5703{
5704 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5706 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
5712inline tree *
5714{
5715 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5717 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
5723inline void
5724gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
5725{
5726 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5728 omp_for_stmt->iter[i].initial = initial;
5729}
5730
5731
5732/* Return the final value for the OMP_FOR statement GS. */
5733
5734inline tree
5735gimple_omp_for_final (const gimple *gs, size_t i)
5736{
5737 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5739 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
5745inline tree *
5746gimple_omp_for_final_ptr (gimple *gs, size_t i)
5747{
5748 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5750 return &omp_for_stmt->iter[i].final;
5751}
5752
5753
5754/* Set FINAL to be the final value for the OMP_FOR statement GS. */
5756inline void
5757gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
5758{
5759 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5761 omp_for_stmt->iter[i].final = final;
5762}
5763
5764
5765/* Return the increment value for the OMP_FOR statement GS. */
5767inline tree
5768gimple_omp_for_incr (const gimple *gs, size_t i)
5769{
5770 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5772 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
5778inline tree *
5779gimple_omp_for_incr_ptr (gimple *gs, size_t i)
5780{
5781 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5783 return &omp_for_stmt->iter[i].incr;
5784}
5786
5787/* Set INCR to be the increment value for the OMP_FOR statement GS. */
5788
5789inline void
5790gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
5791{
5792 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5794 omp_for_stmt->iter[i].incr = incr;
5796
5797
5798/* Return a pointer to the sequence of statements to execute before the OMP_FOR
5799 statement GS starts. */
5800
5801inline gimple_seq *
5802gimple_omp_for_pre_body_ptr (gimple *gs)
5803{
5804 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5805 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
5812inline gimple_seq
5813gimple_omp_for_pre_body (const gimple *gs)
5815 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
5822inline void
5824{
5825 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5826 omp_for_stmt->pre_body = pre_body;
5827}
5828
5829/* Return the clauses associated with OMP_PARALLEL GS. */
5830
5831inline tree
5833{
5834 const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
5835 return omp_parallel_stmt->clauses;
5836}
5837
5838
5839/* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5840
5841inline tree *
5842gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
5844 return &omp_parallel_stmt->clauses;
5845}
5846
5847
5848/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5849
5850inline void
5851gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
5852 tree clauses)
5853{
5854 omp_parallel_stmt->clauses = clauses;
5855}
5856
5857
5858/* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5859
5860inline tree
5862{
5863 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
5869inline tree *
5871{
5872 return &omp_parallel_stmt->child_fn;
5873}
5874
5875
5876/* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5877
5878inline void
5879gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
5880 tree child_fn)
5881{
5882 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
5889inline tree
5890gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
5892 return omp_parallel_stmt->data_arg;
5893}
5894
5895
5896/* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5897
5898inline tree *
5899gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
5900{
5901 return &omp_parallel_stmt->data_arg;
5903
5904
5905/* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5906
5907inline void
5908gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
5909 tree data_arg)
5910{
5911 omp_parallel_stmt->data_arg = data_arg;
5912}
5914/* Return the clauses associated with OMP_TASK GS. */
5915
5916inline tree
5918{
5919 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5920 return omp_task_stmt->clauses;
5921}
5922
5923
5924/* Return a pointer to the clauses associated with OMP_TASK GS. */
5925
5926inline tree *
5928{
5929 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5930 return &omp_task_stmt->clauses;
5931}
5932
5933
5934/* Set CLAUSES to be the list of clauses associated with OMP_TASK
5935 GS. */
5936
5937inline void
5939{
5940 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5941 omp_task_stmt->clauses = clauses;
5942}
5943
5944
5945/* Return true if OMP task statement G has the
5946 GF_OMP_TASK_TASKLOOP flag set. */
5947
5948inline bool
5949gimple_omp_task_taskloop_p (const gimple *g)
5950{
5951 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5952 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
5959inline void
5960gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
5962 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5963 if (taskloop_p)
5964 g->subcode |= GF_OMP_TASK_TASKLOOP;
5965 else
5966 g->subcode &= ~GF_OMP_TASK_TASKLOOP;
5967}
5968
5969
5970/* Return true if OMP task statement G has the
5971 GF_OMP_TASK_TASKWAIT flag set. */
5972
5973inline bool
5975{
5976 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5977 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
5984inline void
5985gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
5986{
5987 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5988 if (taskwait_p)
5989 g->subcode |= GF_OMP_TASK_TASKWAIT;
5990 else
5991 g->subcode &= ~GF_OMP_TASK_TASKWAIT;
5993
5994
5995/* Return the child function used to hold the body of OMP_TASK GS. */
5996
5997inline tree
5998gimple_omp_task_child_fn (const gimple *gs)
5999{
6000 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6001 return omp_task_stmt->child_fn;
6003
6004/* Return a pointer to the child function used to hold the body of
6005 OMP_TASK GS. */
6006
6007inline tree *
6009{
6010 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6011 return &omp_task_stmt->child_fn;
6013
6014
6015/* Set CHILD_FN to be the child function for OMP_TASK GS. */
6016
6017inline void
6018gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
6019{
6020 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6021 omp_task_stmt->child_fn = child_fn;
6022}
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
6028inline tree
6030{
6031 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6032 return omp_task_stmt->data_arg;
6033}
6034
6036/* Return a pointer to the data argument for OMP_TASK GS. */
6037
6038inline tree *
6040{
6041 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6042 return &omp_task_stmt->data_arg;
6043}
6044
6045
6046/* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6047
6048inline void
6050{
6051 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6052 omp_task_stmt->data_arg = data_arg;
6053}
6054
6055
6056/* Return the clauses associated with OMP_TASK GS. */
6058inline tree
6060{
6061 const gimple_statement_omp_taskreg *omp_taskreg_stmt
6063 return omp_taskreg_stmt->clauses;
6064}
6065
6066
6067/* Return a pointer to the clauses associated with OMP_TASK GS. */
6074 return &omp_taskreg_stmt->clauses;
6075}
6076
6077
6078/* Set CLAUSES to be the list of clauses associated with OMP_TASK
6079 GS. */
6081inline void
6083{
6084 gimple_statement_omp_taskreg *omp_taskreg_stmt
6086 omp_taskreg_stmt->clauses = clauses;
6087}
6088
6089
6090/* Return the child function used to hold the body of OMP_TASK GS. */
6092inline tree
6094{
6095 const gimple_statement_omp_taskreg *omp_taskreg_stmt
6097 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. */
6108 return &omp_taskreg_stmt->child_fn;
6109}
6110
6111
6112/* Set CHILD_FN to be the child function for OMP_TASK GS. */
6114inline void
6116{
6117 gimple_statement_omp_taskreg *omp_taskreg_stmt
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
6126inline tree
6128{
6129 const gimple_statement_omp_taskreg *omp_taskreg_stmt
6131 return omp_taskreg_stmt->data_arg;
6132}
6134
6135/* Return a pointer to the data argument for OMP_TASK GS. */
6136
6137inline tree *
6139{
6140 gimple_statement_omp_taskreg *omp_taskreg_stmt
6142 return &omp_taskreg_stmt->data_arg;
6144
6145
6146/* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6147
6148inline void
6149gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
6150{
6151 gimple_statement_omp_taskreg *omp_taskreg_stmt
6153 omp_taskreg_stmt->data_arg = data_arg;
6154}
6155
6156
6157/* Return the copy function used to hold the body of OMP_TASK GS. */
6158
6159inline tree
6160gimple_omp_task_copy_fn (const gimple *gs)
6161{
6162 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6163 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
6169inline tree *
6170gimple_omp_task_copy_fn_ptr (gimple *gs)
6171{
6172 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6173 return &omp_task_stmt->copy_fn;
6174}
6175
6176
6177/* Set CHILD_FN to be the copy function for OMP_TASK GS. */
6178
6179inline void
6181{
6182 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6183 omp_task_stmt->copy_fn = copy_fn;
6184}
6185
6186
6187/* Return size of the data block in bytes in OMP_TASK GS. */
6188
6189inline tree
6190gimple_omp_task_arg_size (const gimple *gs)
6191{
6192 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6193 return omp_task_stmt->arg_size;
6194}
6195
6196
6197/* Return a pointer to the data block size for OMP_TASK GS. */
6198
6199inline tree *
6201{
6202 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6203 return &omp_task_stmt->arg_size;
6204}
6205
6206
6207/* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
6208
6209inline void
6210gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
6211{
6212 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6213 omp_task_stmt->arg_size = arg_size;
6214}
6215
6216
6217/* Return align of the data block in bytes in OMP_TASK GS. */
6218
6219inline tree
6220gimple_omp_task_arg_align (const gimple *gs)
6221{
6222 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6223 return omp_task_stmt->arg_align;
6224}
6225
6226
6227/* Return a pointer to the data block align for OMP_TASK GS. */
6228
6229inline tree *
6231{
6232 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6233 return &omp_task_stmt->arg_align;
6234}
6235
6236
6237/* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
6238
6239inline void
6240gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
6241{
6242 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6243 omp_task_stmt->arg_align = arg_align;
6244}
6245
6246
6247/* Return the clauses associated with OMP_SINGLE GS. */
6248
6249inline tree
6250gimple_omp_single_clauses (const gimple *gs)
6251{
6252 const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
6253 return omp_single_stmt->clauses;
6254}
6255
6256
6257/* Return a pointer to the clauses associated with OMP_SINGLE GS. */
6258
6259inline tree *
6261{
6262 gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
6263 return &omp_single_stmt->clauses;
6264}
6265
6266
6267/* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
6268
6269inline void
6270gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
6271{
6272 omp_single_stmt->clauses = clauses;
6273}
6274
6275
6276/* Return the clauses associated with OMP_TARGET GS. */
6277
6278inline tree
6279gimple_omp_target_clauses (const gimple *gs)
6280{
6281 const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
6282 return omp_target_stmt->clauses;
6283}
6284
6285
6286/* Return a pointer to the clauses associated with OMP_TARGET GS. */
6287
6288inline tree *
6290{
6291 gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
6292 return &omp_target_stmt->clauses;
6293}
6294
6295
6296/* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
6297
6298inline void
6299gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
6300 tree clauses)
6301{
6302 omp_target_stmt->clauses = clauses;
6303}
6304
6305
6306/* Return the kind of the OMP_TARGET G. */
6307
6308inline int
6309gimple_omp_target_kind (const gimple *g)
6310{
6311 GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
6313}
6314
6315
6316/* Set the kind of the OMP_TARGET G. */
6317
6318inline void
6319gimple_omp_target_set_kind (gomp_target *g, int kind)
6321 g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
6322 | (kind & GF_OMP_TARGET_KIND_MASK);
6323}
6324
6325
6326/* Return the child function used to hold the body of OMP_TARGET_STMT. */
6327
6328inline tree
6330{
6331 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
6337inline tree *
6338gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
6340 return &omp_target_stmt->child_fn;
6341}
6342
6343
6344/* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
6345
6346inline void
6347gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
6348 tree child_fn)
6350 omp_target_stmt->child_fn = child_fn;
6351}
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
6357inline tree
6358gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
6360 return omp_target_stmt->data_arg;
6361}
6362
6363
6364/* Return a pointer to the data argument for OMP_TARGET GS. */
6365
6366inline tree *
6368{
6369 return &omp_target_stmt->data_arg;
6370}
6371
6372
6373/* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
6374
6375inline void
6377 tree data_arg)
6378{
6379 omp_target_stmt->data_arg = data_arg;
6380}
6381
6382
6383/* Return the clauses associated with OMP_TEAMS GS. */
6384
6385inline tree
6387{
6388 const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
6389 return omp_teams_stmt->clauses;
6390}
6391
6392
6393/* Return a pointer to the clauses associated with OMP_TEAMS GS. */
6394
6395inline tree *
6397{
6398 gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
6399 return &omp_teams_stmt->clauses;
6400}
6401
6402
6403/* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
6405inline void
6406gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
6407{
6408 omp_teams_stmt->clauses = clauses;
6409}
6410
6411/* Return the child function used to hold the body of OMP_TEAMS_STMT. */
6412
6413inline tree
6414gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
6415{
6416 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. */
6422inline tree *
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
6431inline void
6432gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
6433{
6434 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. */
6441inline tree
6442gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
6443{
6444 return omp_teams_stmt->data_arg;
6445}
6446
6447
6448/* Return a pointer to the data argument for OMP_TEAMS_STMT. */
6449
6450inline tree *
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
6459inline void
6460gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
6462 omp_teams_stmt->data_arg = data_arg;
6463}
6464
6465/* Return the host flag of an OMP_TEAMS_STMT. */
6466
6467inline bool
6468gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
6469{
6470 return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
6471}
6473/* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6474
6475inline void
6476gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
6477{
6478 if (value)
6479 omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
6480 else
6481 omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
6482}
6484/* Return the clauses associated with OMP_SECTIONS GS. */
6485
6486inline tree
6488{
6489 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6490 return omp_sections_stmt->clauses;
6491}
6492
6493
6494/* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6495
6496inline tree *
6498{
6499 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6500 return &omp_sections_stmt->clauses;
6501}
6502
6503
6504/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6505 GS. */
6506
6507inline void
6509{
6510 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6511 omp_sections_stmt->clauses = clauses;
6512}
6514
6515/* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6516 in GS. */
6517
6518inline tree
6520{
6521 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6522 return omp_sections_stmt->control;
6523}
6524
6525
6526/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6527 GS. */
6528
6529inline tree *
6532 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6533 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
6540inline void
6542{
6543 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6544 omp_sections_stmt->control = control;
6545}
6546
6547
6548/* Set the value being stored in an atomic store. */
6550inline void
6552{
6553 store_stmt->val = val;
6554}
6555
6556
6557/* Return the value being stored in an atomic store. */
6559inline tree
6561{
6562 return store_stmt->val;
6563}
6564
6565
6566/* Return a pointer to the value being stored in an atomic store. */
6568inline tree *
6570{
6571 return &store_stmt->val;
6572}
6573
6574
6575/* Set the LHS of an atomic load. */
6577inline void
6579{
6580 load_stmt->lhs = lhs;
6581}
6582
6583
6584/* Get the LHS of an atomic load. */
6586inline tree
6588{
6589 return load_stmt->lhs;
6590}
6591
6592
6593/* Return a pointer to the LHS of an atomic load. */
6594
6595inline tree *
6597{
6598 return &load_stmt->lhs;
6599}
6600
6602/* Set the RHS of an atomic load. */
6603
6604inline void
6606{
6607 load_stmt->rhs = rhs;
6608}
6609
6611/* Get the RHS of an atomic load. */
6612
6613inline tree
6615{
6616 return load_stmt->rhs;
6617}
6618
6620/* Return a pointer to the RHS of an atomic load. */
6621
6622inline tree *
6624{
6625 return &load_stmt->rhs;
6626}
6627
6629/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6630
6631inline tree
6633{
6634 return cont_stmt->control_def;
6635}
6637/* The same as above, but return the address. */
6638
6639inline tree *
6641{
6642 return &cont_stmt->control_def;
6643}
6644
6645/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6647inline void
6649{
6650 cont_stmt->control_def = def;
6651}
6652
6654/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6655
6656inline tree
6658{
6659 return cont_stmt->control_use;
6660}
6661
6662
6663/* The same as above, but return the address. */
6664
6665inline tree *
6667{
6668 return &cont_stmt->control_use;
6669}
6670
6671
6672/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6673
6674inline void
6676{
6677 cont_stmt->control_use = use;
6678}
6679
6680/* Return the guard associated with the GIMPLE_ASSUME statement GS. */
6681
6682inline tree
6687 return assume_stmt->guard;
6688}
6689
6690/* Set the guard associated with the GIMPLE_ASSUME statement GS. */
6692inline void
6694{
6696 assume_stmt->guard = guard;
6697}
6698
6703 return &assume_stmt->guard;
6704}
6706/* Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
6707 statement GS. */
6708
6709inline gimple_seq *
6713 return &assume_stmt->body;
6714}
6715
6716/* Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS. */
6718inline gimple_seq
6719gimple_assume_body (const gimple *gs)
6720{
6721 const gimple_statement_assume *assume_stmt
6723 return assume_stmt->body;
6724}
6725
6726/* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6727 TRANSACTION_STMT. */
6728
6730gimple_transaction_body_ptr (gtransaction *transaction_stmt)
6731{
6732 return &transaction_stmt->body;
6733}
6734
6735/* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6736
6738gimple_transaction_body (const gtransaction *transaction_stmt)
6739{
6740 return transaction_stmt->body;
6741}
6742
6743/* Return the label associated with a GIMPLE_TRANSACTION. */
6744
6745inline tree
6747{
6748 return transaction_stmt->label_norm;
6749}
6750
6751inline tree *
6752gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
6753{
6754 return &transaction_stmt->label_norm;
6756
6757inline tree
6758gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
6759{
6760 return transaction_stmt->label_uninst;
6762
6763inline tree *
6764gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
6765{
6766 return &transaction_stmt->label_uninst;
6768
6769inline tree
6770gimple_transaction_label_over (const gtransaction *transaction_stmt)
6771{
6772 return transaction_stmt->label_over;
6773}
6774
6775inline tree *
6777{
6778 return &transaction_stmt->label_over;
6779}
6780
6781/* Return the subcode associated with a GIMPLE_TRANSACTION. */
6782
6783inline unsigned int
6785{
6786 return transaction_stmt->subcode;
6787}
6788
6789/* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6790 TRANSACTION_STMT. */
6791
6792inline void
6793gimple_transaction_set_body (gtransaction *transaction_stmt,
6794 gimple_seq body)
6795{
6796 transaction_stmt->body = body;
6797}
6798
6799/* Set the label associated with a GIMPLE_TRANSACTION. */
6800
6801inline void
6802gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
6803{
6804 transaction_stmt->label_norm = label;
6805}
6806
6807inline void
6808gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
6810 transaction_stmt->label_uninst = label;
6811}
6812
6813inline void
6814gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
6815{
6816 transaction_stmt->label_over = label;
6817}
6818
6819/* Set the subcode associated with a GIMPLE_TRANSACTION. */
6820
6821inline void
6822gimple_transaction_set_subcode (gtransaction *transaction_stmt,
6823 unsigned int subcode)
6824{
6825 transaction_stmt->subcode = subcode;
6826}
6827
6828/* Return a pointer to the return value for GIMPLE_RETURN GS. */
6829
6830inline tree *
6831gimple_return_retval_ptr (greturn *gs)
6832{
6833 return &gs->op[0];
6834}
6836/* Return the return value for GIMPLE_RETURN GS. */
6837
6838inline tree
6839gimple_return_retval (const greturn *gs)
6840{
6841 return gs->op[0];
6842}
6843
6844
6845/* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6846
6847inline void
6848gimple_return_set_retval (greturn *gs, tree retval)
6849{
6850 gs->op[0] = retval;
6851}
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
6881inline bool
6882is_gimple_omp (const gimple *stmt)
6883{
6884 switch (gimple_code (stmt))
6885 {
6887 return true;
6888 default:
6889 return false;
6890 }
6891}
6892
6893/* Return true if the OMP gimple statement STMT is any of the OpenACC types
6894 specifically. */
6895
6896inline bool
6897is_gimple_omp_oacc (const gimple *stmt)
6898{
6900 switch (gimple_code (stmt))
6901 {
6902 case GIMPLE_OMP_ATOMIC_LOAD:
6903 case GIMPLE_OMP_ATOMIC_STORE:
6904 case GIMPLE_OMP_CONTINUE:
6905 case GIMPLE_OMP_RETURN:
6906 /* Codes shared between OpenACC and OpenMP cannot be used to disambiguate
6907 the two. */
6908 gcc_unreachable ();
6909
6910 case GIMPLE_OMP_FOR:
6911 switch (gimple_omp_for_kind (stmt))
6912 {
6914 return true;
6915 default:
6916 return false;
6917 }
6918 case GIMPLE_OMP_TARGET:
6919 switch (gimple_omp_target_kind (stmt))
6920 {
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
6945inline bool
6949 switch (gimple_code (stmt))
6950 {
6951 case GIMPLE_OMP_TARGET:
6952 switch (gimple_omp_target_kind (stmt))
6953 {
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
6972inline bool
6973gimple_nop_p (const gimple *g)
6974{
6975 return gimple_code (g) == GIMPLE_NOP;
6977
6978
6979/* Return true if GS is a GIMPLE_RESX. */
6980
6981inline bool
6982is_gimple_resx (const gimple *gs)
6983{
6984 return gimple_code (gs) == GIMPLE_RESX;
6986
6987
6988/* Enum and arrays used for allocation stats. Keep in sync with
6989 gimple.cc:gimple_alloc_kind_names. */
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. */
6997};
6998
6999extern uint64_t gimple_alloc_counts[];
7000extern uint64_t gimple_alloc_sizes[];
7001
7002/* Return the allocation kind for a given stmt CODE. */
7003inline enum gimple_alloc_kind
7005{
7006 switch (code)
7007 {
7008 case GIMPLE_ASSIGN:
7010 case GIMPLE_PHI:
7011 return gimple_alloc_kind_phi;
7012 case GIMPLE_COND:
7014 default:
7016 }
7017}
7018
7019/* Return true if a location should not be emitted for this statement
7020 by annotate_all_with_location. */
7021
7022inline bool
7024{
7025 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
7031inline void
7033{
7034 /* The PLF flags are initialized to 0 when a new tuple is created,
7035 so no need to initialize it anywhere. */
7036 gimple_set_plf (g, GF_PLF_1, true);
7037}
7038
7039#endif /* GCC_GIMPLE_H */
bool bb_in_transaction(basic_block bb)
Definition basic-block.h:505
#define EDGE_PRED(bb, i)
Definition basic-block.h:307
gimple * currently_expanding_gimple_stmt
Definition cfgexpand.cc:94
gcc::context * g
Definition context.cc:29
struct basic_block_def * basic_block
Definition coretypes.h:355
class edge_def * edge
Definition coretypes.h:352
gimple * gimple_seq
Definition coretypes.h:100
const class edge_def * const_edge
Definition coretypes.h:353
const struct basic_block_def * const_basic_block
Definition coretypes.h:356
const union tree_node * const_tree
Definition coretypes.h:98
#define GTY(x)
Definition coretypes.h:41
class bitmap_head * bitmap
Definition coretypes.h:51
union tree_node * tree
Definition coretypes.h:97
int alias_set_type
Definition coretypes.h:349
void copy_warning(location_t to, location_t from)
Definition diagnostic-spec.cc:206
volatile signed char sc
Definition fp-test.cc:68
static struct token T
Definition gengtype-parse.cc:45
built_in_function
Definition genmatch.cc:1009
combined_fn
Definition genmatch.cc:1020
internal_fn
Definition genmatch.cc:1015
tree_code
Definition genmatch.cc:1002
static struct filedep ** last
Definition genmddeps.cc:33
bool is_gimple_reg(tree t)
Definition gimple-expr.cc:790
tree gimple_call_addr_fndecl(const_tree fn)
Definition gimple-expr.h:164
bool gimple_assign_ssa_name_copy_p(gimple *gs)
Definition gimple.cc:1844
void annotate_all_with_location_after(gimple_seq seq, gimple_stmt_iterator gsi, location_t location)
Definition gimple.cc:1495
bool gimple_call_same_target_p(const gimple *c1, const gimple *c2)
Definition gimple.cc:1579
int gimple_call_retslot_flags(const gcall *stmt)
Definition gimple.cc:1707
gimple * gimple_alloc(enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
Definition gimple.cc:168
bool infer_nonnull_range_by_attribute(gimple *stmt, tree op, tree *op2, tree *op3)
Definition gimple.cc:3164
gbind * gimple_build_bind(tree vars, gimple_seq body, tree block)
Definition gimple.cc:635
bool gimple_call_builtin_p(const gimple *stmt)
Definition gimple.cc:2943
greturn * gimple_build_return(tree retval)
Definition gimple.cc:220
gdebug * gimple_build_debug_begin_stmt(tree block, location_t location MEM_STAT_DECL)
Definition gimple.cc:922
gimple * gimple_copy(gimple *stmt)
Definition gimple.cc:2041
gdebug * gimple_build_debug_bind(tree var, tree value, gimple *stmt MEM_STAT_DECL)
Definition gimple.cc:880
const unsigned char gimple_rhs_class_table[]
Definition gimple.cc:2527
size_t gimple_size(enum gimple_code code, unsigned num_ops)
Definition gimple.cc:142
gomp_for * gimple_build_omp_for(gimple_seq body, int kind, tree clauses, size_t collapse, gimple_seq pre_body)
Definition gimple.cc:988
const char *const gimple_code_name[]
Definition gimple.cc:96
bool gimple_assign_copy_p(gimple *gs)
Definition gimple.cc:1834
gswitch * gimple_build_switch(tree index, tree default_label, const vec< tree > &args)
Definition gimple.cc:850
gomp_single * gimple_build_omp_single(gimple_seq body, tree clauses)
Definition gimple.cc:1236
int gimple_call_flags(const gimple *stmt)
Definition gimple.cc:1596
gcall * gimple_build_call_from_tree(tree t, tree fnptrtype)
Definition gimple.cc:385
bool gimple_has_side_effects(const gimple *s)
Definition gimple.cc:2327
void gimple_set_lhs(gimple *stmt, tree lhs)
Definition gimple.cc:2022
bool gimple_inexpensive_call_p(gcall *stmt)
Definition gimple.cc:3526
gimple * gimple_build_omp_return(bool wait_p)
Definition gimple.cc:1172
uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all]
Definition gimple.cc:110
gomp_parallel * gimple_build_omp_parallel(gimple_seq body, tree clauses, tree child_fn, tree data_arg)
Definition gimple.cc:1014
gimple * gimple_build_omp_masked(gimple_seq body, tree clauses)
Definition gimple.cc:1106
gasm * gimple_build_asm_vec(const char *string, vec< tree, va_gc > *inputs, vec< tree, va_gc > *outputs, vec< tree, va_gc > *clobbers, vec< tree, va_gc > *labels)
Definition gimple.cc:689
EXPORTED_CONST size_t gimple_ops_offset_[]
Definition gimple.cc:84
bool gimple_builtin_call_types_compatible_p(const gimple *stmt, tree fndecl)
Definition gimple.cc:2896
bool gimple_compare_field_offset(tree f1, tree f2)
Definition gimple.cc:2578
geh_dispatch * gimple_build_eh_dispatch(int region)
Definition gimple.cc:866
void gimple_assign_set_rhs_with_ops(gimple_stmt_iterator *gsi, enum tree_code code, tree op1, tree op2, tree op3)
Definition gimple.cc:1965
gassign * gimple_build_assign(tree lhs, tree rhs MEM_STAT_DECL)
Definition gimple.cc:473
uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all]
Definition gimple.cc:109
gimple * gimple_build_omp_master(gimple_seq body)
Definition gimple.cc:1092
gcall * gimple_call_copy_skip_args(gcall *stmt, bitmap args_to_skip)
Definition gimple.cc:2538
gimple * gimple_build_assume(tree guard, gimple_seq body)
Definition gimple.cc:1361
gimple * gimple_build_omp_sections_switch(void)
Definition gimple.cc:1223
gcond * gimple_build_cond_from_tree(tree cond, tree t_label, tree f_label)
Definition gimple.cc:576
gcall * gimple_build_call_internal(enum internal_fn fn, unsigned nargs,...)
Definition gimple.cc:346
ggoto * gimple_build_goto(tree dest)
Definition gimple.cc:612
gomp_target * gimple_build_omp_target(gimple_seq body, int kind, tree clauses)
Definition gimple.cc:1301
gomp_sections * gimple_build_omp_sections(gimple_seq body, tree clauses)
Definition gimple.cc:1208
void gimple_assign_set_rhs_from_tree(gimple_stmt_iterator *gsi, tree expr)
Definition gimple.cc:1948
gtry * gimple_build_try(gimple_seq eval, gimple_seq cleanup, enum gimple_try_flags kind)
Definition gimple.cc:782
geh_else * gimple_build_eh_else(gimple_seq n_body, gimple_seq e_body)
Definition gimple.cc:766
gomp_task * gimple_build_omp_task(gimple_seq body, tree clauses, tree child_fn, tree data_arg, tree copy_fn, tree arg_size, tree arg_align)
Definition gimple.cc:1039
bool nonfreeing_call_p(gimple *call)
Definition gimple.cc:3049
geh_mnt * gimple_build_eh_must_not_throw(tree decl)
Definition gimple.cc:752
gimple * gimple_build_omp_scope(gimple_seq body, tree clauses)
Definition gimple.cc:1255
gcall * gimple_build_call_valist(tree fn, unsigned nargs, va_list ap)
Definition gimple.cc:309
bool empty_body_p(gimple_seq body)
Definition gimple.cc:1541
int gimple_call_arg_flags(const gcall *stmt, unsigned arg)
Definition gimple.cc:1676
gomp_atomic_load * gimple_build_omp_atomic_load(tree lhs, tree rhs, enum omp_memory_order mo)
Definition gimple.cc:1334
gomp_teams * gimple_build_omp_teams(gimple_seq body, tree clauses)
Definition gimple.cc:1320
location_t gimple_or_expr_nonartificial_location(gimple *stmt, tree expr)
Definition gimple.cc:3540
gcatch * gimple_build_catch(tree types, gimple_seq handler)
Definition gimple.cc:723
void gimple_seq_add_stmt(gimple_seq *seq_p, gimple *gs)
Definition gimple.cc:1408
geh_filter * gimple_build_eh_filter(tree types, gimple_seq failure)
Definition gimple.cc:739
void gimple_cond_set_condition_from_tree(gcond *stmt, tree cond)
Definition gimple.cc:589
gdebug * gimple_build_debug_source_bind(tree var, tree value, gimple *stmt MEM_STAT_DECL)
Definition gimple.cc:900
gomp_continue * gimple_build_omp_continue(tree control_def, tree control_use)
Definition gimple.cc:1140
gimple * gimple_build_omp_section(gimple_seq body)
Definition gimple.cc:1062
void dump_gimple_statistics(void)
Definition gimple.cc:2446
bool gimple_could_trap_p_1(const gimple *s, bool include_mem, bool include_stores)
Definition gimple.cc:2363
gomp_scan * gimple_build_omp_scan(gimple_seq body, tree clauses)
Definition gimple.cc:1189
void gimple_seq_set_location(gimple_seq seq, location_t loc)
Definition gimple.cc:3484
glabel * gimple_build_label(tree label)
Definition gimple.cc:601
void dump_decl_set(FILE *file, bitmap set)
Definition gimple.cc:3025
EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[]
Definition gimple.cc:102
bool gimple_assign_load_p(const gimple *gs)
Definition gimple.cc:1880
bool infer_nonnull_range(gimple *stmt, tree op)
Definition gimple.cc:3130
bool infer_nonnull_range_by_dereference(gimple *stmt, tree op)
Definition gimple.cc:3139
void gimple_seq_add_seq(gimple_seq *dst_p, gimple_seq src)
Definition gimple.cc:1440
gcall * gimple_build_call_vec(tree fn, const vec< tree > &args)
Definition gimple.cc:269
void gimple_init(gimple *g, enum gimple_code code, unsigned num_ops)
Definition gimple.cc:153
gimple * gimple_build_omp_structured_block(gimple_seq body)
Definition gimple.cc:1077
tree gimple_call_nonnull_arg(gcall *call)
Definition gimple.cc:1809
gcall * gimple_build_call_internal_vec(enum internal_fn fn, const vec< tree > &args)
Definition gimple.cc:366
tree gimple_get_lhs(const gimple *stmt)
Definition gimple.cc:2003
gcall * gimple_build_call(tree fn, unsigned nargs,...)
Definition gimple.cc:286
bool gimple_call_nonnull_result_p(gcall *call)
Definition gimple.cc:1783
void gimple_seq_discard(gimple_seq seq)
Definition gimple.cc:3493
bool gimple_asm_clobbers_memory_p(const gasm *stmt)
Definition gimple.cc:3004
gimple * gimple_build_wce(gimple_seq cleanup)
Definition gimple.cc:803
void gimple_set_bb(gimple *stmt, basic_block bb)
Definition gimple.cc:1900
bool gimple_could_trap_p(const gimple *s)
Definition gimple.cc:2428
void gimple_call_reset_alias_info(gcall *s)
Definition gimple.cc:233
gimple * gimple_build_omp_dispatch(gimple_seq body, tree clauses)
Definition gimple.cc:1271
gresx * gimple_build_resx(int region)
Definition gimple.cc:816
bool gimple_assign_rhs_could_trap_p(gimple *s)
Definition gimple.cc:2436
gimple * gimple_build_nop(void)
Definition gimple.cc:624
gdebug * gimple_build_debug_inline_entry(tree block, location_t location MEM_STAT_DECL)
Definition gimple.cc:943
gimple * gimple_build_omp_taskgroup(gimple_seq body, tree clauses)
Definition gimple.cc:1123
gomp_ordered * gimple_build_omp_ordered(gimple_seq body, tree clauses)
Definition gimple.cc:1156
int gimple_call_return_flags(const gcall *stmt)
Definition gimple.cc:1763
bool gimple_call_operator_delete_p(const gcall *stmt)
Definition gimple.cc:2931
int gimple_call_static_chain_flags(const gcall *stmt)
Definition gimple.cc:1735
gtransaction * gimple_build_transaction(gimple_seq body)
Definition gimple.cc:1373
void preprocess_case_label_vec_for_gimple(vec< tree > &labels, tree index_type, tree *default_casep)
Definition gimple.cc:3317
gcond * gimple_build_cond(enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
Definition gimple.cc:558
void annotate_all_with_location(gimple_seq stmt_p, location_t location)
Definition gimple.cc:1510
gimple_seq gimple_seq_copy(gimple_seq src)
Definition gimple.cc:1559
gomp_critical * gimple_build_omp_critical(gimple_seq body, tree name, tree clauses)
Definition gimple.cc:967
tree gimple_signed_type(tree type)
Definition gimple.cc:2815
void gimple_seq_add_stmt_without_update(gimple_seq *seq_p, gimple *gs)
Definition gimple.cc:1425
gcall * gimple_build_builtin_unreachable(location_t loc)
Definition gimple.cc:457
void sort_case_labels(vec< tree > &label_vec)
Definition gimple.cc:3292
gimple * gimple_build_omp_interop(tree clauses)
Definition gimple.cc:1286
gswitch * gimple_build_switch_nlabels(unsigned nlabels, tree index, tree default_label)
Definition gimple.cc:831
combined_fn gimple_call_combined_fn(const gimple *stmt)
Definition gimple.cc:2984
unsigned get_gimple_rhs_num_ops(enum tree_code code)
Definition gimple.cc:2480
bool gimple_assign_unary_nop_p(gimple *gs)
Definition gimple.cc:1867
void maybe_remove_unused_call_args(struct function *fn, gimple *stmt)
Definition gimple.cc:3511
bool nonbarrier_call_p(gimple *call)
Definition gimple.cc:3095
tree gimple_unsigned_type(tree type)
Definition gimple.cc:2806
void gimple_move_vops(gimple *new_stmt, gimple *old_stmt)
Definition gimple.cc:2311
bool gimple_ior_addresses_taken(bitmap addresses_taken, gimple *stmt)
Definition gimple.cc:2885
alias_set_type gimple_get_alias_set(tree t)
Definition gimple.cc:2825
gomp_atomic_store * gimple_build_omp_atomic_store(tree val, enum omp_memory_order mo)
Definition gimple.cc:1349
void gimple_seq_add_seq_without_update(gimple_seq *dst_p, gimple_seq src)
Definition gimple.cc:1455
gimple * gimple_build_omp_scope(gimple_seq, tree)
Definition gimple.cc:1255
void gimple_omp_target_set_clauses(gomp_target *omp_target_stmt, tree clauses)
Definition gimple.h:6252
gimple_alloc_kind
Definition gimple.h:6944
@ gimple_alloc_kind_assign
Definition gimple.h:6945
@ gimple_alloc_kind_phi
Definition gimple.h:6946
@ gimple_alloc_kind_rest
Definition gimple.h:6948
@ gimple_alloc_kind_all
Definition gimple.h:6949
@ gimple_alloc_kind_cond
Definition gimple.h:6947
gomp_for * gimple_build_omp_for(gimple_seq, int, tree, size_t, gimple_seq)
Definition gimple.cc:988
tree gimple_transaction_label_uninst(const gtransaction *transaction_stmt)
Definition gimple.h:6711
tree gimple_label_label(const glabel *gs)
Definition gimple.h:3924
tree * gimple_omp_task_arg_size_ptr(gimple *gs)
Definition gimple.h:6153
tree gimple_omp_task_arg_size(const gimple *gs)
Definition gimple.h:6143
tree * gimple_omp_scope_clauses_ptr(gimple *gs)
Definition gimple.h:5411
gimple * gimple_seq_node
Definition gimple.h:28
bool gimple_clobber_p(const gimple *s)
Definition gimple.h:2936
void gimple_omp_task_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5891
void gimple_cond_set_code(gcond *gs, enum tree_code code)
Definition gimple.h:3671
bool gimple_compare_field_offset(tree, tree)
Definition gimple.cc:2578
location_t gimple_location(const gimple *g)
Definition gimple.h:1892
tree gimple_omp_interop_clauses(const gimple *gs)
Definition gimple.h:5461
tree * gimple_catch_types_ptr(gcatch *catch_stmt)
Definition gimple.h:4252
tree gimple_omp_for_initial(const gimple *gs, size_t i)
Definition gimple.h:5655
gimple_seq gimple_eh_else_n_body(const geh_else *eh_else_stmt)
Definition gimple.h:4384
bool gimple_seq_singleton_p(gimple_seq seq)
Definition gimple.h:1970
gimple_seq * gimple_omp_for_pre_body_ptr(gimple *gs)
Definition gimple.h:5755
static void gimple_call_set_expected_throw(gcall *s, bool expected_throw_p)
Definition gimple.h:3528
tree * gimple_omp_task_child_fn_ptr(gimple *gs)
Definition gimple.h:5961
void gimple_omp_set_subcode(gimple *s, unsigned int subcode)
Definition gimple.h:2317
gimple_seq gimple_eh_filter_failure(const gimple *gs)
Definition gimple.h:4332
gimple_seq_node gimple_seq_last(gimple_seq s)
Definition gimple.h:1716
tree gimple_bind_block(const gbind *bind_stmt)
Definition gimple.h:4035
void gimple_omp_atomic_store_set_val(gomp_atomic_store *store_stmt, tree val)
Definition gimple.h:6504
tree * gimple_op_ptr(gimple *gs, unsigned i)
Definition gimple.h:2568
gimple * gimple_build_omp_taskgroup(gimple_seq, tree)
Definition gimple.cc:1123
void copy_warning(gimple *, const gimple *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
Definition warning-control.cc:253
tree gimple_cond_lhs(const gcond *gs)
Definition gimple.h:3681
void gimple_transaction_set_label_norm(gtransaction *transaction_stmt, tree label)
Definition gimple.h:6755
gcond * gimple_build_cond(enum tree_code, tree, tree, tree, tree)
Definition gimple.cc:558
tree gimple_omp_ordered_clauses(const gomp_ordered *ord_stmt)
Definition gimple.h:5273
tree gimple_block(const gimple *g)
Definition gimple.h:1873
bool gimple_cond_false_canonical_p(const gcond *gs)
Definition gimple.h:3876
void gimple_try_set_eval(gtry *try_stmt, gimple_seq eval)
Definition gimple.h:4506
tree * gimple_omp_taskreg_data_arg_ptr(gimple *gs)
Definition gimple.h:6091
gswitch * gimple_build_switch_nlabels(unsigned, tree, tree)
Definition gimple.cc:831
int gimple_call_static_chain_flags(const gcall *)
Definition gimple.cc:1735
tree * gimple_vdef_ptr(gimple *g)
Definition gimple.h:2215
void gimple_set_bb(gimple *, basic_block)
Definition gimple.cc:1900
bool gimple_omp_task_taskloop_p(const gimple *g)
Definition gimple.h:5902
void gimple_bind_append_vars(gbind *bind_stmt, tree vars)
Definition gimple.h:3982
void gimple_omp_task_set_taskwait_p(gimple *g, bool taskwait_p)
Definition gimple.h:5938
bool infer_nonnull_range_by_dereference(gimple *, tree)
Definition gimple.cc:3139
gresx * gimple_build_resx(int)
Definition gimple.cc:816
tree gimple_omp_task_child_fn(const gimple *gs)
Definition gimple.h:5951
gcall * gimple_build_call_internal(enum internal_fn, unsigned,...)
Definition gimple.cc:346
gimple_seq * gimple_eh_else_n_body_ptr(geh_else *eh_else_stmt)
Definition gimple.h:4378
void gimple_assign_set_rhs2(gassign *gs, tree rhs)
Definition gimple.h:2750
void gimple_assign_set_rhs_from_tree(gimple_stmt_iterator *, tree)
Definition gimple.cc:1948
void gimple_bind_add_seq(gbind *bind_stmt, gimple_seq seq)
Definition gimple.h:4025
tree * gimple_omp_teams_data_arg_ptr(gomp_teams *omp_teams_stmt)
Definition gimple.h:6404
tree gimple_omp_atomic_load_rhs(const gomp_atomic_load *load_stmt)
Definition gimple.h:6567
void gimple_omp_task_set_child_fn(gimple *gs, tree child_fn)
Definition gimple.h:5971
bool gimple_has_ops(const gimple *g)
Definition gimple.h:2107
int gimple_call_arg_flags(const gcall *, unsigned)
Definition gimple.cc:1676
tree gimple_op(const gimple *gs, unsigned i)
Definition gimple.h:2554
tree * gimple_ops(gimple *gs)
Definition gimple.h:2537
gimple * gimple_build_omp_return(bool)
Definition gimple.cc:1172
tree * gimple_omp_taskreg_child_fn_ptr(gimple *gs)
Definition gimple.h:6057
bool gimple_cond_true_p(const gcond *gs)
Definition gimple.h:3812
tree gimple_assume_guard(const gimple *gs)
Definition gimple.h:6636
void gimple_debug_bind_reset_value(gimple *dbg)
Definition gimple.h:5052
void gimple_omp_teams_set_data_arg(gomp_teams *omp_teams_stmt, tree data_arg)
Definition gimple.h:6413
bool gimple_debug_inline_entry_p(const gimple *s)
Definition gimple.h:5150
bool gimple_omp_atomic_need_value_p(const gimple *g)
Definition gimple.h:2450
void gimple_assign_set_rhs3(gassign *gs, tree rhs)
Definition gimple.h:2797
void gimple_cond_make_false(gcond *gs)
Definition gimple.h:3790
void gimple_omp_target_set_child_fn(gomp_target *omp_target_stmt, tree child_fn)
Definition gimple.h:6300
gimple * gimple_seq_first_stmt(gimple_seq s)
Definition gimple.h:1696
tree * gimple_omp_for_initial_ptr(gimple *gs, size_t i)
Definition gimple.h:5666
void gimple_omp_teams_set_host(gomp_teams *omp_teams_stmt, bool value)
Definition gimple.h:6429
tree * gimple_omp_sections_control_ptr(gimple *gs)
Definition gimple.h:6483
void gimple_omp_task_set_data_arg(gimple *gs, tree data_arg)
Definition gimple.h:6002
void gimple_bind_set_body(gbind *bind_stmt, gimple_seq seq)
Definition gimple.h:4007
tree gimple_eh_filter_types(const gimple *gs)
Definition gimple.h:4299
tree gimple_vdef(const gimple *g)
Definition gimple.h:2191
gimple * gimple_copy(gimple *)
Definition gimple.cc:2041
void gimple_asm_set_volatile(gasm *asm_stmt, bool volatile_p)
Definition gimple.h:4188
void gimple_omp_parallel_set_combined_p(gimple *g, bool combined_p)
Definition gimple.h:2436
bool gimple_store_p(const gimple *gs)
Definition gimple.h:2911
#define CASE_GIMPLE_OMP
Definition gimple.h:6809
bool gimple_has_lhs(const gimple *stmt)
Definition gimple.h:3642
bool gimple_assign_nontemporal_move_p(const gassign *gs)
Definition gimple.h:2834
void gimple_omp_for_set_pre_body(gimple *gs, gimple_seq pre_body)
Definition gimple.h:5776
void gimple_call_set_tail(gcall *s, bool tail_p)
Definition gimple.h:3359
tree * gimple_call_chain_ptr(gcall *call_stmt)
Definition gimple.h:3272
void gimple_phi_set_result(gphi *phi, tree result)
Definition gimple.h:4626
unsigned gimple_omp_subcode(const gimple *s)
Definition gimple.h:2307
gimple_code
Definition gimple.h:30
void gimple_debug_bind_set_value(gimple *dbg, tree value)
Definition gimple.h:5037
unsigned int gimple_stmt_max_uid(struct function *fn)
Definition gimple.h:1665
gcall * gimple_build_call(tree, unsigned,...)
Definition gimple.cc:286
void gimple_transaction_set_label_over(gtransaction *transaction_stmt, tree label)
Definition gimple.h:6767
int gimple_call_retslot_flags(const gcall *)
Definition gimple.cc:1707
location_t gimple_phi_arg_location(const gphi *phi, size_t i)
Definition gimple.h:4744
tree * gimple_omp_sections_clauses_ptr(gimple *gs)
Definition gimple.h:6450
tree gimple_debug_source_bind_get_value(const gimple *dbg)
Definition gimple.h:5097
bool gimple_has_substatements(gimple *g)
Definition gimple.h:1825
gomp_critical * gimple_build_omp_critical(gimple_seq, tree, tree)
Definition gimple.cc:967
void gimple_omp_ordered_set_clauses(gomp_ordered *ord_stmt, tree clauses)
Definition gimple.h:5293
bool gimple_call_va_arg_pack_p(const gcall *s)
Definition gimple.h:3481
void gimple_asm_set_basic(gasm *asm_stmt, bool basic_p)
Definition gimple.h:4222
gcatch * gimple_build_catch(tree, gimple_seq)
Definition gimple.cc:723
void gimple_omp_for_set_cond(gimple *gs, size_t i, enum tree_code cond)
Definition gimple.h:5610
tree gimple_debug_source_bind_get_var(const gimple *dbg)
Definition gimple.h:5086
bool gimple_debug_nonbind_marker_p(const gimple *s)
Definition gimple.h:5161
void gimple_cond_set_rhs(gcond *gs, tree rhs)
Definition gimple.h:3741
unsigned int inc_gimple_stmt_max_uid(struct function *fn)
Definition gimple.h:1679
tree gimple_transaction_label_norm(const gtransaction *transaction_stmt)
Definition gimple.h:6699
tree * gimple_omp_scan_clauses_ptr(gomp_scan *scan_stmt)
Definition gimple.h:5312
void gimple_omp_taskgroup_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5354
gdebug * gimple_build_debug_bind(tree, tree, gimple *CXX_MEM_STAT_INFO)
bool gimple_omp_for_combined_p(const gimple *g)
Definition gimple.h:5510
tree * gimple_omp_atomic_store_val_ptr(gomp_atomic_store *store_stmt)
Definition gimple.h:6522
gcall * gimple_build_call_from_tree(tree, tree)
Definition gimple.cc:385
gomp_target * gimple_build_omp_target(gimple_seq, int, tree)
Definition gimple.cc:1301
gimple_seq phi_nodes(const_basic_block bb)
Definition gimple.h:4679
void gimple_set_visited(gimple *stmt, bool visited_p)
Definition gimple.h:2005
tree * gimple_omp_task_arg_align_ptr(gimple *gs)
Definition gimple.h:6183
gomp_task * gimple_build_omp_task(gimple_seq, tree, tree, tree, tree, tree, tree)
Definition gimple.cc:1039
gimple * gimple_build_omp_interop(tree)
Definition gimple.cc:1286
void annotate_all_with_location(gimple_seq, location_t)
Definition gimple.cc:1510
tree gimple_unsigned_type(tree)
Definition gimple.cc:2806
bool gimple_assign_rhs_could_trap_p(gimple *)
Definition gimple.cc:2436
enum tree_code gimple_omp_for_cond(const gimple *gs, size_t i)
Definition gimple.h:5599
bool gimple_call_from_thunk_p(gcall *s)
Definition gimple.h:3435
bool gimple_call_internal_unique_p(const gcall *gs)
Definition gimple.h:3063
gbind * gimple_seq_first_stmt_as_a_bind(gimple_seq s)
Definition gimple.h:1706
void gimple_assign_set_rhs_with_ops(gimple_stmt_iterator *, enum tree_code, tree, tree, tree)
Definition gimple.cc:1965
void maybe_remove_unused_call_args(struct function *, gimple *)
Definition gimple.cc:3511
tree gimple_omp_teams_child_fn(const gomp_teams *omp_teams_stmt)
Definition gimple.h:6367
gimple_rhs_class
Definition gimple.h:113
@ GIMPLE_TERNARY_RHS
Definition gimple.h:115
@ GIMPLE_INVALID_RHS
Definition gimple.h:114
@ GIMPLE_SINGLE_RHS
Definition gimple.h:118
@ GIMPLE_UNARY_RHS
Definition gimple.h:117
@ GIMPLE_BINARY_RHS
Definition gimple.h:116
void gimple_bind_add_stmt(gbind *bind_stmt, gimple *stmt)
Definition gimple.h:4016
tree gimple_assign_rhs3(const gassign *gs)
Definition gimple.h:2767
void gimple_goto_set_dest(ggoto *gs, tree dest)
Definition gimple.h:3953
tree * gimple_arg_ptr(gimple *gs, unsigned int i)
Definition gimple.h:4811
bool gimple_asm_inline_p(const gasm *asm_stmt)
Definition gimple.h:4200
tree gimple_omp_target_clauses(const gimple *gs)
Definition gimple.h:6232
void gimple_omp_continue_set_control_use(gomp_continue *cont_stmt, tree use)
Definition gimple.h:6628
void gimple_transaction_set_body(gtransaction *transaction_stmt, gimple_seq body)
Definition gimple.h:6746
tree gimple_omp_scope_clauses(const gimple *gs)
Definition gimple.h:5399
tree gimple_omp_for_incr(const gimple *gs, size_t i)
Definition gimple.h:5721
size_t gimple_size(enum gimple_code code, unsigned num_ops=0)
Definition gimple.cc:142
combined_fn gimple_call_combined_fn(const gimple *)
Definition gimple.cc:2984
unsigned gimple_switch_num_labels(const gswitch *gs)
Definition gimple.h:4856
void gimple_wce_set_cleanup(gimple *gs, gimple_seq cleanup)
Definition gimple.h:4544
tree gimple_switch_index(const gswitch *gs)
Definition gimple.h:4879
gimple * gimple_build_omp_sections_switch(void)
Definition gimple.cc:1223
gimple * gimple_seq_last_stmt(gimple_seq s)
Definition gimple.h:1725
bool gimple_assign_cast_p(const gimple *s)
Definition gimple.h:2920
void dump_decl_set(FILE *, bitmap)
Definition gimple.cc:3025
void gimple_omp_target_set_kind(gomp_target *g, int kind)
Definition gimple.h:6272
void gimple_seq_add_seq_without_update(gimple_seq *, gimple_seq)
Definition gimple.cc:1455
unsigned gimple_asm_nlabels(const gasm *asm_stmt)
Definition gimple.h:4082
tree gimple_omp_parallel_data_arg(const gomp_parallel *omp_parallel_stmt)
Definition gimple.h:5843
int get_lineno(const gimple *stmt)
Definition gimple.h:5173
ggoto * gimple_build_goto(tree dest)
Definition gimple.cc:612
void gimple_call_set_fntype(gcall *call_stmt, tree fntype)
Definition gimple.h:3141
void gimple_omp_task_set_arg_align(gimple *gs, tree arg_align)
Definition gimple.h:6193
unsigned gimple_call_num_args(const gcall *gs)
Definition gimple.h:3289
unsigned gimple_num_ops(const gimple *gs)
Definition gimple.h:2519
tree gimple_omp_parallel_clauses(const gimple *gs)
Definition gimple.h:5785
void gimple_switch_set_index(gswitch *gs, tree index)
Definition gimple.h:4897
gdebug * gimple_build_debug_source_bind(tree, tree, gimple *CXX_MEM_STAT_INFO)
void suppress_warning(gimple *, opt_code=all_warnings, bool=true) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:173
unsigned gimple_asm_noutputs(const gasm *asm_stmt)
Definition gimple.h:4065
bool gimple_debug_bind_p(const gimple *s)
Definition gimple.h:4983
bool gimple_omp_task_taskwait_p(const gimple *g)
Definition gimple.h:5927
void gimple_seq_set_last(gimple_seq *ps, gimple_seq_node last)
Definition gimple.h:1735
tree * gimple_omp_parallel_clauses_ptr(gomp_parallel *omp_parallel_stmt)
Definition gimple.h:5795
gf_mask
Definition gimple.h:133
@ GF_OMP_ATOMIC_NEED_VALUE
Definition gimple.h:196
@ GF_OMP_TARGET_KIND_ENTER_DATA
Definition gimple.h:165
@ GF_CALL_MUST_TAIL_CALL
Definition gimple.h:145
@ GF_OMP_TARGET_KIND_OACC_SERIAL
Definition gimple.h:169
@ GF_CALL_INTERNAL
Definition gimple.h:143
@ GF_OMP_ATOMIC_MEMORY_ORDER
Definition gimple.h:195
@ GF_CALL_NOTHROW
Definition gimple.h:141
@ GF_OMP_RETURN_NOWAIT
Definition gimple.h:191
@ GF_OMP_TARGET_KIND_OACC_DATA_KERNELS
Definition gimple.h:184
@ GF_CALL_CTRL_ALTERING
Definition gimple.h:144
@ GF_OMP_TEAMS_HOST
Definition gimple.h:185
@ GF_CALL_VA_ARG_PACK
Definition gimple.h:140
@ GF_OMP_PARALLEL_COMBINED
Definition gimple.h:150
@ GF_OMP_SECTION_LAST
Definition gimple.h:193
@ GF_OMP_TARGET_KIND_OACC_DATA
Definition gimple.h:170
@ GF_CALL_RETURN_SLOT_OPT
Definition gimple.h:138
@ GF_OMP_TARGET_KIND_EXIT_DATA
Definition gimple.h:166
@ GF_OMP_TARGET_KIND_DATA
Definition gimple.h:163
@ GF_OMP_TARGET_KIND_OACC_EXIT_DATA
Definition gimple.h:173
@ GF_PREDICT_TAKEN
Definition gimple.h:198
@ GF_CALL_TAILCALL
Definition gimple.h:139
@ GF_OMP_FOR_KIND_SIMD
Definition gimple.h:158
@ GF_ASM_BASIC
Definition gimple.h:134
@ GF_OMP_TASK_TASKWAIT
Definition gimple.h:152
@ GF_OMP_TARGET_KIND_OACC_UPDATE
Definition gimple.h:171
@ GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED
Definition gimple.h:178
@ GF_OMP_TARGET_KIND_OACC_KERNELS
Definition gimple.h:168
@ GF_OMP_TARGET_KIND_MASK
Definition gimple.h:161
@ GF_OMP_FOR_KIND_TASKLOOP
Definition gimple.h:156
@ GF_CALL_BY_DESCRIPTOR
Definition gimple.h:146
@ GF_CALL_FROM_THUNK
Definition gimple.h:137
@ GF_OMP_ORDERED_STANDALONE
Definition gimple.h:194
@ GF_OMP_TASK_TASKLOOP
Definition gimple.h:151
@ GF_OMP_FOR_COMBINED_INTO
Definition gimple.h:160
@ GF_OMP_ATOMIC_WEAK
Definition gimple.h:197
@ GF_OMP_TARGET_KIND_UPDATE
Definition gimple.h:164
@ GF_OMP_TARGET_KIND_REGION
Definition gimple.h:162
@ GF_ASM_INLINE
Definition gimple.h:136
@ GF_CALL_XTHROW
Definition gimple.h:149
@ GF_OMP_TARGET_KIND_OACC_HOST_DATA
Definition gimple.h:175
@ GF_CALL_FROM_NEW_OR_DELETE
Definition gimple.h:148
@ GF_OMP_FOR_KIND_MASK
Definition gimple.h:153
@ GF_OMP_FOR_COMBINED
Definition gimple.h:159
@ GF_OMP_FOR_KIND_OACC_LOOP
Definition gimple.h:157
@ GF_OMP_TARGET_KIND_OACC_DECLARE
Definition gimple.h:174
@ GF_ASM_VOLATILE
Definition gimple.h:135
@ GF_CALL_ALLOCA_FOR_VAR
Definition gimple.h:142
@ GF_OMP_FOR_KIND_DISTRIBUTE
Definition gimple.h:155
@ GF_OMP_TARGET_KIND_OACC_PARALLEL
Definition gimple.h:167
@ GF_OMP_TARGET_KIND_OACC_ENTER_DATA
Definition gimple.h:172
@ GF_OMP_FOR_KIND_FOR
Definition gimple.h:154
@ GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE
Definition gimple.h:181
@ GF_CALL_NOCF_CHECK
Definition gimple.h:147
enum gimple_statement_structure_enum gss_for_code(enum gimple_code code)
Definition gimple.h:1805
bool gimple_could_trap_p(const gimple *)
Definition gimple.cc:2428
tree * gimple_omp_for_index_ptr(gimple *gs, size_t i)
Definition gimple.h:5633
void gimple_omp_return_set_nowait(gimple *s)
Definition gimple.h:2328
void gimple_call_set_from_new_or_delete(gcall *s, bool from_new_or_delete_p)
Definition gimple.h:3445
tree gimple_omp_for_final(const gimple *gs, size_t i)
Definition gimple.h:5688
tree * gimple_omp_task_copy_fn_ptr(gimple *gs)
Definition gimple.h:6123
tree * gimple_omp_teams_child_fn_ptr(gomp_teams *omp_teams_stmt)
Definition gimple.h:6376
tree * gimple_omp_for_clauses_ptr(gimple *gs)
Definition gimple.h:5568
void gimple_init_singleton(gimple *g)
Definition gimple.h:2097
gimple_seq gimple_eh_else_e_body(const geh_else *eh_else_stmt)
Definition gimple.h:4396
bool gimple_call_nonnull_result_p(gcall *)
Definition gimple.cc:1783
void gimple_omp_task_set_taskloop_p(gimple *g, bool taskloop_p)
Definition gimple.h:5913
bool gimple_call_nothrow_p(const gcall *s)
Definition gimple.h:3518
void gimple_omp_for_set_index(gimple *gs, size_t i, tree index)
Definition gimple.h:5644
void gimple_catch_set_types(gcatch *catch_stmt, tree t)
Definition gimple.h:4281
gimple_seq gimple_try_cleanup(const gimple *gs)
Definition gimple.h:4483
gimple_seq * gimple_catch_handler_ptr(gcatch *catch_stmt)
Definition gimple.h:4262
T GIMPLE_CHECK2(gimple *gs)
Definition gimple.h:98
void gimple_set_use_ops(gimple *g, struct use_optype_d *use)
Definition gimple.h:2168
gcall * gimple_build_builtin_unreachable(location_t)
Definition gimple.cc:457
tree * gimple_assign_rhs1_ptr(gassign *gs)
Definition gimple.h:2681
tree * gimple_debug_source_bind_get_value_ptr(gimple *dbg)
Definition gimple.h:5108
bool gimple_call_ctrl_altering_p(const gcall *gs)
Definition gimple.h:3108
void gimple_omp_sections_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:6461
tree * gimple_omp_return_lhs_ptr(gimple *g)
Definition gimple.h:2371
gcall * gimple_build_call_internal_vec(enum internal_fn, const vec< tree > &)
Definition gimple.cc:366
tree * gimple_omp_parallel_data_arg_ptr(gomp_parallel *omp_parallel_stmt)
Definition gimple.h:5852
void gimple_cond_set_condition_from_tree(gcond *, tree)
Definition gimple.cc:589
void gimple_eh_else_set_e_body(geh_else *eh_else_stmt, gimple_seq seq)
Definition gimple.h:4408
tree * gimple_omp_atomic_load_rhs_ptr(gomp_atomic_load *load_stmt)
Definition gimple.h:6576
gimple_seq * gimple_wce_cleanup_ptr(gimple *gs)
Definition gimple.h:4525
bool gimple_assign_unary_nop_p(gimple *)
Definition gimple.cc:1867
void gimple_eh_dispatch_set_region(geh_dispatch *eh_dispatch_stmt, int region)
Definition gimple.h:4848
tree gimple_phi_result(const gphi *gs)
Definition gimple.h:4596
void gimple_assign_set_lhs(gassign *gs, tree lhs)
Definition gimple.h:2645
void gimple_asm_set_output_op(gasm *asm_stmt, unsigned index, tree out_op)
Definition gimple.h:4119
bool gimple_ior_addresses_taken(bitmap, gimple *)
Definition gimple.cc:2885
bool nonbarrier_call_p(gimple *)
Definition gimple.cc:3095
location_t gimple_location_safe(const gimple *g)
Definition gimple.h:1901
tree gimple_debug_bind_get_value(const gimple *dbg)
Definition gimple.h:5005
#define GIMPLE_CHECK(GS, CODE)
Definition gimple.h:95
gimple_seq * gimple_assume_body_ptr(gimple *gs)
Definition gimple.h:6663
tree * gimple_assume_guard_ptr(gimple *gs)
Definition gimple.h:6653
enum gimple_rhs_class gimple_assign_rhs_class(const gimple *gs)
Definition gimple.h:2890
bool stmt_can_terminate_bb_p(gimple *)
Definition tree-cfg.cc:8863
tree gimple_omp_masked_clauses(const gimple *gs)
Definition gimple.h:5365
void gimple_omp_for_set_combined_into_p(gomp_for *g, bool combined_p)
Definition gimple.h:5545
unsigned gimple_asm_ninputs(const gasm *asm_stmt)
Definition gimple.h:4056
void gimple_omp_interop_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5480
void gimple_omp_critical_set_name(gomp_critical *crit_stmt, tree name)
Definition gimple.h:5235
void gimple_try_set_catch_is_cleanup(gtry *g, bool catch_is_cleanup)
Definition gimple.h:4492
void gimple_omp_taskreg_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:6035
gimple_seq * gimple_omp_body_ptr(gimple *gs)
Definition gimple.h:5190
bool gimple_seq_empty_p(gimple_seq s)
Definition gimple.h:1753
tree gimple_cond_false_label(const gcond *gs)
Definition gimple.h:3781
bool gimple_omp_teams_host(const gomp_teams *omp_teams_stmt)
Definition gimple.h:6421
struct use_optype_d * gimple_use_ops(const gimple *g)
Definition gimple.h:2155
location_t gimple_or_expr_nonartificial_location(gimple *, tree)
Definition gimple.cc:3540
bool gimple_call_alloca_for_var_p(gcall *s)
Definition gimple.h:3562
bool gimple_do_not_emit_location_p(gimple *g)
Definition gimple.h:6976
void set_gimple_stmt_max_uid(struct function *fn, unsigned int maxid)
Definition gimple.h:1672
tree * gimple_cond_lhs_ptr(gcond *gs)
Definition gimple.h:3697
tree gimple_omp_continue_control_use(const gomp_continue *cont_stmt)
Definition gimple.h:6610
tree gimple_omp_teams_clauses(const gimple *gs)
Definition gimple.h:6339
gimple_seq bb_seq(const_basic_block bb)
Definition gimple.h:1772
void gimple_omp_continue_set_control_def(gomp_continue *cont_stmt, tree def)
Definition gimple.h:6601
void annotate_all_with_location_after(gimple_seq, gimple_stmt_iterator, location_t)
Definition gimple.cc:1495
bool is_gimple_debug(const gimple *gs)
Definition gimple.h:4947
void gimple_omp_atomic_load_set_rhs(gomp_atomic_load *load_stmt, tree rhs)
Definition gimple.h:6558
void gimple_eh_else_set_n_body(geh_else *eh_else_stmt, gimple_seq seq)
Definition gimple.h:4402
tree * gimple_omp_target_child_fn_ptr(gomp_target *omp_target_stmt)
Definition gimple.h:6291
tree * gimple_omp_taskreg_clauses_ptr(gimple *gs)
Definition gimple.h:6023
gswitch * gimple_build_switch(tree, tree, const vec< tree > &)
Definition gimple.cc:850
bool gimple_call_same_target_p(const gimple *, const gimple *)
Definition gimple.cc:1579
void gimple_assume_set_guard(gimple *gs, tree guard)
Definition gimple.h:6646
void dump_gimple_statistics(void)
Definition gimple.cc:2446
bool gimple_asm_basic_p(const gasm *asm_stmt)
Definition gimple.h:4234
tree gimple_omp_atomic_store_val(const gomp_atomic_store *store_stmt)
Definition gimple.h:6513
bool gimple_call_return_slot_opt_p(const gcall *s)
Definition gimple.h:3413
void gimple_debug_source_bind_set_var(gimple *dbg, tree var)
Definition gimple.h:5118
tree * gimple_switch_index_ptr(gswitch *gs)
Definition gimple.h:4888
void gimple_omp_sections_set_control(gimple *gs, tree control)
Definition gimple.h:6494
gimple * gimple_build_omp_structured_block(gimple_seq)
Definition gimple.cc:1077
unsigned gimple_uid(const gimple *g)
Definition gimple.h:2088
bool gimple_omp_for_combined_into_p(const gimple *g)
Definition gimple.h:5534
bool gimple_references_memory_p(gimple *stmt)
Definition gimple.h:2298
tree gimple_omp_sections_clauses(const gimple *gs)
Definition gimple.h:6440
void gimple_call_set_chain(gcall *call_stmt, tree chain)
Definition gimple.h:3280
tree gimple_catch_types(const gcatch *catch_stmt)
Definition gimple.h:4243
tree * gimple_debug_bind_get_value_ptr(gimple *dbg)
Definition gimple.h:5016
tree * gimple_omp_target_clauses_ptr(gimple *gs)
Definition gimple.h:6242
geh_mnt * gimple_build_eh_must_not_throw(tree)
Definition gimple.cc:752
void gimple_set_block(gimple *g, tree block)
Definition gimple.h:1884
void gimple_omp_atomic_set_need_value(gimple *g)
Definition gimple.h:2461
void gimple_call_set_alloca_for_var(gcall *s, bool for_var)
Definition gimple.h:3551
void gimple_omp_for_set_combined_p(gomp_for *g, bool combined_p)
Definition gimple.h:5521
tree * gimple_assign_rhs3_ptr(gimple *gs)
Definition gimple.h:2786
gimple_debug_subcode
Definition gimple.h:203
@ GIMPLE_DEBUG_INLINE_ENTRY
Definition gimple.h:207
@ GIMPLE_DEBUG_BEGIN_STMT
Definition gimple.h:206
@ GIMPLE_DEBUG_BIND
Definition gimple.h:204
@ GIMPLE_DEBUG_SOURCE_BIND
Definition gimple.h:205
tree * gimple_omp_ordered_clauses_ptr(gomp_ordered *ord_stmt)
Definition gimple.h:5283
bool is_gimple_resx(const gimple *gs)
Definition gimple.h:6935
tree gimple_omp_continue_control_def(const gomp_continue *cont_stmt)
Definition gimple.h:6585
gomp_single * gimple_build_omp_single(gimple_seq, tree)
Definition gimple.cc:1236
tree gimple_omp_task_data_arg(const gimple *gs)
Definition gimple.h:5982
gimple_seq gimple_assume_body(const gimple *gs)
Definition gimple.h:6672
enum tree_code gimple_assign_rhs_code(const gassign *gs)
Definition gimple.h:2854
void gimple_catch_set_handler(gcatch *catch_stmt, gimple_seq handler)
Definition gimple.h:4290
tree gimple_call_fntype(const gcall *gs)
Definition gimple.h:3124
tree gimple_omp_task_arg_align(const gimple *gs)
Definition gimple.h:6173
bool gimple_debug_begin_stmt_p(const gimple *s)
Definition gimple.h:5139
bool warning_suppressed_p(const gimple *, opt_code=all_warnings) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:138
tree gimple_call_fn(const gcall *gs)
Definition gimple.h:3152
edge gimple_phi_arg_edge(const gphi *phi, size_t i)
Definition gimple.h:4736
void gimple_omp_masked_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5388
bool is_gimple_assign(const gimple *gs)
Definition gimple.h:2596
enum internal_fn gimple_call_internal_fn(const gcall *gs)
Definition gimple.h:3047
tree * gimple_return_retval_ptr(greturn *gs)
Definition gimple.h:6784
bool gimple_could_trap_p_1(const gimple *, bool, bool)
Definition gimple.cc:2363
gimple * gimple_seq_first_nondebug_stmt(gimple_seq s)
Definition gimple.h:4956
tree gimple_asm_label_op(const gasm *asm_stmt, unsigned index)
Definition gimple.h:4150
void gimple_call_copy_flags(gcall *dest_call, gcall *orig_call)
Definition gimple.h:3597
void gimple_set_vuse(gimple *g, tree vuse)
Definition gimple.h:2227
glabel * gimple_build_label(tree label)
Definition gimple.cc:601
bool gimple_has_location(const gimple *g)
Definition gimple.h:1929
tree gimple_asm_clobber_op(const gasm *asm_stmt, unsigned index)
Definition gimple.h:4130
tree gimple_signed_type(tree)
Definition gimple.cc:2815
gimple_seq gimple_seq_copy(gimple_seq)
Definition gimple.cc:1559
void gimple_omp_for_set_incr(gimple *gs, size_t i, tree incr)
Definition gimple.h:5743
gimple_seq * gimple_try_eval_ptr(gimple *gs)
Definition gimple.h:4452
gcall * gimple_build_call_valist(tree, unsigned, va_list)
Definition gimple.cc:309
void gimple_transaction_set_subcode(gtransaction *transaction_stmt, unsigned int subcode)
Definition gimple.h:6775
tree * gimple_omp_taskgroup_clauses_ptr(gimple *gs)
Definition gimple.h:5343
tree gimple_omp_return_lhs(const gimple *g)
Definition gimple.h:2360
tree gimple_debug_bind_get_var(const gimple *dbg)
Definition gimple.h:4994
int gimple_omp_for_kind(const gimple *g)
Definition gimple.h:5489
void gimple_call_set_nothrow(gcall *s, bool nothrow_p)
Definition gimple.h:3507
void gimple_call_set_lhs(gcall *gs, tree lhs)
Definition gimple.h:2994
gimple_seq * gimple_eh_else_e_body_ptr(geh_else *eh_else_stmt)
Definition gimple.h:4390
tree * gimple_assign_lhs_ptr(gassign *gs)
Definition gimple.h:2629
bool gimple_wce_cleanup_eh_only(const gimple *gs)
Definition gimple.h:4554
greturn * gimple_build_return(tree)
Definition gimple.cc:220
tree * gimple_omp_continue_control_def_ptr(gomp_continue *cont_stmt)
Definition gimple.h:6593
void gimple_bind_set_vars(gbind *bind_stmt, tree vars)
Definition gimple.h:3972
enum tree_code gimple_cond_code(const gcond *gs)
Definition gimple.h:3655
tree gimple_call_return_type(const gcall *gs)
Definition gimple.h:3240
bool gimple_call_by_descriptor_p(gcall *s)
Definition gimple.h:3589
bool gimple_call_operator_delete_p(const gcall *)
Definition gimple.cc:2931
gtry * gimple_build_try(gimple_seq, gimple_seq, enum gimple_try_flags)
Definition gimple.cc:782
void gimple_call_set_from_thunk(gcall *s, bool from_thunk_p)
Definition gimple.h:3423
int gimple_omp_target_kind(const gimple *g)
Definition gimple.h:6262
tree * gimple_cond_rhs_ptr(gcond *gs)
Definition gimple.h:3731
enum gimple_rhs_class get_gimple_rhs_class(enum tree_code code)
Definition gimple.h:2605
bool gimple_in_transaction(const gimple *stmt)
Definition gimple.h:2290
bool is_gimple_call(const gimple *gs)
Definition gimple.h:2954
void gimple_assign_set_rhs1(gassign *gs, tree rhs)
Definition gimple.h:2696
void gimple_asm_set_inline(gasm *asm_stmt, bool inline_p)
Definition gimple.h:4209
size_t gimple_omp_for_collapse(const gimple *gs)
Definition gimple.h:5589
tree * gimple_omp_task_data_arg_ptr(gimple *gs)
Definition gimple.h:5992
bool gimple_cond_false_p(const gcond *gs)
Definition gimple.h:3852
static bool gimple_call_expected_throw_p(gcall *s)
Definition gimple.h:3540
void gimple_init(gimple *g, enum gimple_code code, unsigned num_ops)
Definition gimple.cc:153
tree gimple_switch_default_label(const gswitch *gs)
Definition gimple.h:4928
void gimple_call_set_fn(gcall *gs, tree fn)
Definition gimple.h:3184
location_t gimple_nonartificial_location(const gimple *g)
Definition gimple.h:1938
bool gimple_assign_ssa_name_copy_p(gimple *)
Definition gimple.cc:1844
void gimple_resx_set_region(gresx *resx_stmt, int region)
Definition gimple.h:4831
void gimple_call_set_arg(gcall *gs, unsigned index, tree arg)
Definition gimple.h:3340
tree gimple_return_retval(const greturn *gs)
Definition gimple.h:6792
void gimple_omp_parallel_set_child_fn(gomp_parallel *omp_parallel_stmt, tree child_fn)
Definition gimple.h:5832
gdebug * gimple_build_debug_begin_stmt(tree, location_t CXX_MEM_STAT_INFO)
location_t gimple_phi_arg_location_from_edge(gphi *phi, edge e)
Definition gimple.h:4752
void gimple_phi_set_arg(gphi *phi, unsigned index, struct phi_arg_d *phiarg)
Definition gimple.h:4669
gcond * gimple_build_cond_from_tree(tree, tree, tree)
Definition gimple.cc:576
location_t * gimple_phi_arg_location_ptr(gphi *phi, size_t i)
Definition gimple.h:4768
void set_bb_seq(basic_block bb, gimple_seq seq)
Definition gimple.h:1786
bool gimple_call_noreturn_p(const gcall *s)
Definition gimple.h:3490
enum gimple_statement_structure_enum gimple_statement_structure(gimple *gs)
Definition gimple.h:1815
void gimple_omp_section_set_last(gimple *g)
Definition gimple.h:2393
bool gimple_call_from_new_or_delete(const gcall *s)
Definition gimple.h:3458
bool gimple_has_mem_ops(const gimple *g)
Definition gimple.h:2131
gimple_seq gimple_transaction_body(const gtransaction *transaction_stmt)
Definition gimple.h:6691
gimple * gimple_seq_last_nondebug_stmt(gimple_seq s)
Definition gimple.h:4968
bool gimple_omp_section_last_p(const gimple *g)
Definition gimple.h:2383
tree * gimple_transaction_label_uninst_ptr(gtransaction *transaction_stmt)
Definition gimple.h:6717
tree gimple_goto_dest(const gimple *gs)
Definition gimple.h:3943
void gimple_switch_set_default_label(gswitch *gs, tree label)
Definition gimple.h:4938
tree * gimple_vuse_ptr(gimple *g)
Definition gimple.h:2203
tree * gimple_phi_arg_def_ptr(gphi *phi, size_t index)
Definition gimple.h:4728
tree * gimple_eh_filter_types_ptr(gimple *gs)
Definition gimple.h:4310
tree gimple_assign_rhs1(const gassign *gs)
Definition gimple.h:2664
void gimple_call_reset_alias_info(gcall *)
Definition gimple.cc:233
#define GIMPLE_DEBUG_BIND_NOVALUE
Definition gimple.h:5046
bool gimple_modified_p(const gimple *g)
Definition gimple.h:2249
tree gimple_omp_sections_control(const gimple *gs)
Definition gimple.h:6472
tree gimple_omp_task_clauses(const gimple *gs)
Definition gimple.h:5870
void gimple_transaction_set_label_uninst(gtransaction *transaction_stmt, tree label)
Definition gimple.h:6761
bool gimple_omp_ordered_standalone_p(const gimple *g)
Definition gimple.h:2404
tree gimple_eh_must_not_throw_fndecl(const geh_mnt *eh_mnt_stmt)
Definition gimple.h:4361
location_t * gimple_location_ptr(gimple *g)
Definition gimple.h:1920
tree gimple_asm_output_op(const gasm *asm_stmt, unsigned index)
Definition gimple.h:4110
basic_block gimple_bb(const gimple *g)
Definition gimple.h:1864
bool nonfreeing_call_p(gimple *)
Definition gimple.cc:3049
int gimple_eh_dispatch_region(const geh_dispatch *eh_dispatch_stmt)
Definition gimple.h:4839
bool gimple_debug_bind_has_value_p(gimple *dbg)
Definition gimple.h:5063
bool gimple_assign_single_p(const gimple *gs)
Definition gimple.h:2902
gimple_statement_structure_enum
Definition gimple.h:847
@ LAST_GSS_ENUM
Definition gimple.h:905
tree gimple_get_lhs(const gimple *)
Definition gimple.cc:2003
tree gimple_omp_parallel_child_fn(const gomp_parallel *omp_parallel_stmt)
Definition gimple.h:5814
gimple_seq gimple_wce_cleanup(gimple *gs)
Definition gimple.h:4535
gtransaction * gimple_build_transaction(gimple_seq)
Definition gimple.cc:1373
tree * gimple_assign_rhs2_ptr(gassign *gs)
Definition gimple.h:2733
void gimple_switch_set_num_labels(gswitch *g, unsigned nlabels)
Definition gimple.h:4869
tree gimple_omp_taskreg_clauses(const gimple *gs)
Definition gimple.h:6012
void gimple_omp_task_set_copy_fn(gimple *gs, tree copy_fn)
Definition gimple.h:6133
void gimple_omp_atomic_load_set_lhs(gomp_atomic_load *load_stmt, tree lhs)
Definition gimple.h:6531
tree * gimple_omp_for_incr_ptr(gimple *gs, size_t i)
Definition gimple.h:5732
gdebug * gimple_build_debug_inline_entry(tree, location_t CXX_MEM_STAT_INFO)
void gimple_move_vops(gimple *, gimple *)
Definition gimple.cc:2311
void gimple_seq_set_first(gimple_seq *ps, gimple_seq_node first)
Definition gimple.h:1744
bool gimple_call_builtin_p(const gimple *)
Definition gimple.cc:2943
gimple_seq gimple_omp_for_pre_body(const gimple *gs)
Definition gimple.h:5766
void gimple_call_set_va_arg_pack(gcall *s, bool pass_arg_pack_p)
Definition gimple.h:3468
bool gimple_omp_atomic_weak_p(const gimple *g)
Definition gimple.h:2473
tree * gimple_omp_teams_clauses_ptr(gimple *gs)
Definition gimple.h:6349
bool gimple_cond_true_canonical_p(const gcond *gs)
Definition gimple.h:3836
bool gimple_asm_clobbers_memory_p(const gasm *)
Definition gimple.cc:3004
gomp_teams * gimple_build_omp_teams(gimple_seq, tree)
Definition gimple.cc:1320
tree gimple_cond_rhs(const gcond *gs)
Definition gimple.h:3715
plf_mask
Definition gimple.h:212
@ GF_PLF_2
Definition gimple.h:214
@ GF_PLF_1
Definition gimple.h:213
enum omp_memory_order gimple_omp_atomic_memory_order(const gimple *g)
Definition gimple.h:2495
tree gimple_omp_task_copy_fn(const gimple *gs)
Definition gimple.h:6113
void gimple_cond_make_true(gcond *gs)
Definition gimple.h:3801
tree gimple_switch_label(const gswitch *gs, unsigned index)
Definition gimple.h:4908
gimple * gimple_build_omp_masked(gimple_seq, tree)
Definition gimple.cc:1106
int gimple_call_flags(const gimple *)
Definition gimple.cc:1596
gimple_seq gimple_try_eval(const gimple *gs)
Definition gimple.h:4462
gomp_ordered * gimple_build_omp_ordered(gimple_seq, tree)
Definition gimple.cc:1156
gimple_seq * bb_seq_addr(basic_block bb)
Definition gimple.h:1778
void gimple_asm_set_label_op(gasm *asm_stmt, unsigned index, tree label_op)
Definition gimple.h:4159
void gimple_seq_add_stmt_without_update(gimple_seq *, gimple *)
Definition gimple.cc:1425
void gimple_set_lhs(gimple *, tree)
Definition gimple.cc:2022
struct pt_solution * gimple_call_clobber_set(gcall *call_stmt)
Definition gimple.h:3624
void gimple_omp_atomic_set_weak(gimple *g)
Definition gimple.h:2484
tree gimple_omp_target_child_fn(const gomp_target *omp_target_stmt)
Definition gimple.h:6282
gomp_sections * gimple_build_omp_sections(gimple_seq, tree)
Definition gimple.cc:1208
gimple * gimple_alloc(enum gimple_code, unsigned CXX_MEM_STAT_INFO)
gasm * gimple_build_asm_vec(const char *, vec< tree, va_gc > *, vec< tree, va_gc > *, vec< tree, va_gc > *, vec< tree, va_gc > *)
Definition gimple.cc:689
tree gimple_call_arg(const gcall *gs, unsigned index)
Definition gimple.h:3305
tree gimple_transaction_label_over(const gtransaction *transaction_stmt)
Definition gimple.h:6723
tree gimple_assign_lhs(const gassign *gs)
Definition gimple.h:2613
void gimple_try_set_cleanup(gtry *try_stmt, gimple_seq cleanup)
Definition gimple.h:4516
bool gimple_omp_parallel_combined_p(const gimple *g)
Definition gimple.h:2425
bool infer_nonnull_range_by_attribute(gimple *, tree, tree *=NULL, tree *=NULL)
Definition gimple.cc:3164
void gimple_debug_bind_set_var(gimple *dbg, tree var)
Definition gimple.h:5026
tree gimple_omp_single_clauses(const gimple *gs)
Definition gimple.h:6203
bool gimple_call_tail_p(const gcall *s)
Definition gimple.h:3371
void gimple_omp_single_set_clauses(gomp_single *omp_single_stmt, tree clauses)
Definition gimple.h:6223
bool gimple_nop_p(const gimple *g)
Definition gimple.h:6926
unsigned gimple_phi_capacity(const gimple *gs)
Definition gimple.h:4574
tree * gimple_omp_critical_name_ptr(gomp_critical *crit_stmt)
Definition gimple.h:5225
tree gimple_cond_true_label(const gcond *gs)
Definition gimple.h:3751
tree * gimple_omp_target_data_arg_ptr(gomp_target *omp_target_stmt)
Definition gimple.h:6320
bool gimple_asm_volatile_p(const gasm *asm_stmt)
Definition gimple.h:4179
tree * gimple_transaction_label_over_ptr(gtransaction *transaction_stmt)
Definition gimple.h:6729
struct gimple_temp_hash_elt elt_t
tree gimple_call_nonnull_arg(gcall *)
Definition gimple.cc:1809
void gimple_set_location(gimple *, location_t)
Definition gimple.h:1909
gimple * gimple_build_nop(void)
Definition gimple.cc:624
gimple_seq gimple_omp_body(const gimple *gs)
Definition gimple.h:5198
bool gimple_builtin_call_types_compatible_p(const gimple *, tree)
Definition gimple.cc:2896
int gimple_lineno(const gimple *stmt)
Definition gimple.h:1961
void gimple_seq_set_location(gimple_seq, location_t)
Definition gimple.cc:3484
void gimple_call_set_internal_fn(gcall *call_stmt, enum internal_fn fn)
Definition gimple.h:3212
bool gimple_call_nocf_check_p(const gcall *gs)
Definition gimple.h:3028
tree gimple_phi_arg_def(const gphi *gs, size_t index)
Definition gimple.h:4697
void gimple_phi_arg_set_location(gphi *phi, size_t i, location_t loc)
Definition gimple.h:4760
void gimple_omp_teams_set_clauses(gomp_teams *omp_teams_stmt, tree clauses)
Definition gimple.h:6359
void gimple_cond_set_true_label(gcond *gs, tree label)
Definition gimple.h:3761
gcall * gimple_call_copy_skip_args(gcall *, bitmap)
Definition gimple.cc:2538
tree gimple_omp_scan_clauses(const gomp_scan *scan_stmt)
Definition gimple.h:5302
void gimple_try_set_kind(gtry *gs, enum gimple_try_flags kind)
Definition gimple.h:4429
tree * gimple_omp_interop_clauses_ptr(gimple *gs)
Definition gimple.h:5470
void gimple_cond_set_lhs(gcond *gs, tree lhs)
Definition gimple.h:3706
void gimple_omp_for_set_initial(gimple *gs, size_t i, tree initial)
Definition gimple.h:5677
void gimple_debug_source_bind_set_value(gimple *dbg, tree value)
Definition gimple.h:5129
enum tree_code gimple_expr_code(const gimple *stmt)
Definition gimple.h:3907
bool gimple_call_must_tail_p(const gcall *s)
Definition gimple.h:3391
tree gimple_omp_critical_name(const gomp_critical *crit_stmt)
Definition gimple.h:5215
tree gimple_call_chain(const gcall *gs)
Definition gimple.h:3256
gimple * gimple_build_wce(gimple_seq)
Definition gimple.cc:803
gomp_scan * gimple_build_omp_scan(gimple_seq, tree)
Definition gimple.cc:1189
void gimple_seq_add_seq(gimple_seq *, gimple_seq)
Definition gimple.cc:1440
struct pt_solution * gimple_call_use_set(gcall *call_stmt)
Definition gimple.h:3607
void gimple_call_set_ctrl_altering(gcall *s, bool ctrl_altering_p)
Definition gimple.h:3089
void gimple_omp_for_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5579
void gimple_set_modified(gimple *s, bool modifiedp)
Definition gimple.h:2259
void gimple_label_set_label(glabel *gs, tree label)
Definition gimple.h:3934
tree gimple_omp_taskreg_child_fn(const gimple *gs)
Definition gimple.h:6046
bool is_gimple_omp(const gimple *stmt)
Definition gimple.h:6835
void gimple_cond_set_false_label(gcond *gs, tree label)
Definition gimple.h:3771
bool gimple_has_volatile_ops(const gimple *stmt)
Definition gimple.h:2269
bool gimple_assign_copy_p(gimple *)
Definition gimple.cc:1834
void gimple_set_has_volatile_ops(gimple *stmt, bool volatilep)
Definition gimple.h:2281
void gimple_call_set_nocf_check(gcall *gs, bool nocf_check)
Definition gimple.h:3036
tree gimple_omp_for_clauses(const gimple *gs)
Definition gimple.h:5557
#define gcc_gimple_checking_assert(EXPR)
Definition gimple.h:94
bool gimple_visited_p(gimple *stmt)
Definition gimple.h:2023
tree * gimple_call_arg_ptr(gcall *gs, unsigned index)
Definition gimple.h:3323
void gimple_seq_discard(gimple_seq)
Definition gimple.cc:3493
bool is_gimple_omp_offloaded(const gimple *stmt)
Definition gimple.h:6899
void gimple_omp_parallel_set_clauses(gomp_parallel *omp_parallel_stmt, tree clauses)
Definition gimple.h:5804
void gimple_omp_task_set_arg_size(gimple *gs, tree arg_size)
Definition gimple.h:6163
gimple_try_flags
Definition gimple.h:517
@ GIMPLE_TRY_FINALLY
Definition gimple.h:522
@ GIMPLE_TRY_CATCH_IS_CLEANUP
Definition gimple.h:526
@ GIMPLE_TRY_KIND
Definition gimple.h:523
@ GIMPLE_TRY_CATCH
Definition gimple.h:519
void gimple_set_num_ops(gimple *gs, unsigned num_ops)
Definition gimple.h:2528
void gimple_seq_add_stmt(gimple_seq *, gimple *)
Definition gimple.cc:1408
tree * gimple_omp_parallel_child_fn_ptr(gomp_parallel *omp_parallel_stmt)
Definition gimple.h:5823
void gimple_eh_filter_set_failure(geh_filter *eh_filter_stmt, gimple_seq failure)
Definition gimple.h:4352
const char * gimple_asm_string(const gasm *asm_stmt)
Definition gimple.h:4170
gimple_seq * gimple_eh_filter_failure_ptr(gimple *gs)
Definition gimple.h:4321
void gimple_omp_for_set_final(gimple *gs, size_t i, tree final)
Definition gimple.h:5710
void gimple_bind_set_block(gbind *bind_stmt, tree block)
Definition gimple.h:4045
tree * gimple_phi_result_ptr(gphi *gs)
Definition gimple.h:4611
tree gimple_omp_dispatch_clauses(const gimple *gs)
Definition gimple.h:5432
tree gimple_omp_taskreg_data_arg(const gimple *gs)
Definition gimple.h:6080
gimple * gimple_build_omp_section(gimple_seq)
Definition gimple.cc:1062
void gimple_set_uid(gimple *g, unsigned uid)
Definition gimple.h:2074
unsigned int gimple_transaction_subcode(const gtransaction *transaction_stmt)
Definition gimple.h:6737
tree gimple_omp_for_index(const gimple *gs, size_t i)
Definition gimple.h:5622
geh_dispatch * gimple_build_eh_dispatch(int)
Definition gimple.cc:866
gomp_continue * gimple_build_omp_continue(tree, tree)
Definition gimple.cc:1140
void gimple_call_set_return_slot_opt(gcall *s, bool return_slot_opt_p)
Definition gimple.h:3401
void gimple_asm_set_input_op(gasm *asm_stmt, unsigned index, tree in_op)
Definition gimple.h:4099
void preprocess_case_label_vec_for_gimple(vec< tree > &, tree, tree *)
Definition gimple.cc:3317
bool is_gimple_omp_oacc(const gimple *stmt)
Definition gimple.h:6850
gimple_seq * gimple_transaction_body_ptr(gtransaction *transaction_stmt)
Definition gimple.h:6683
gimple_seq gimple_bind_body(const gbind *gs)
Definition gimple.h:3997
void gimple_set_plf(gimple *stmt, enum plf_mask plf, bool val_p)
Definition gimple.h:2040
bool gimple_omp_return_nowait_p(const gimple *g)
Definition gimple.h:2339
void gimple_omp_dispatch_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5452
void gimple_omp_for_set_kind(gomp_for *g, int kind)
Definition gimple.h:5499
void gimple_omp_ordered_standalone(gimple *g)
Definition gimple.h:2414
tree gimple_omp_atomic_load_lhs(const gomp_atomic_load *load_stmt)
Definition gimple.h:6540
enum gimple_try_flags gimple_try_kind(const gimple *gs)
Definition gimple.h:4419
tree * gimple_omp_dispatch_clauses_ptr(gimple *gs)
Definition gimple.h:5442
tree * gimple_omp_task_clauses_ptr(gimple *gs)
Definition gimple.h:5880
void gimple_return_set_retval(greturn *gs, tree retval)
Definition gimple.h:6801
unsigned gimple_asm_nclobbers(const gasm *asm_stmt)
Definition gimple.h:4074
void gimple_omp_scan_set_clauses(gomp_scan *scan_stmt, tree clauses)
Definition gimple.h:5322
bool gimple_try_catch_is_cleanup(const gimple *gs)
Definition gimple.h:4441
gomp_parallel * gimple_build_omp_parallel(gimple_seq, tree, tree, tree)
Definition gimple.cc:1014
void gimple_omp_taskreg_set_data_arg(gimple *gs, tree data_arg)
Definition gimple.h:6102
void gimple_call_set_fndecl(gcall *gs, tree decl)
Definition gimple.h:3194
tree * gimple_call_fn_ptr(gcall *gs)
Definition gimple.h:3168
bool empty_body_p(gimple_seq)
Definition gimple.cc:1541
tree gimple_call_lhs(const gcall *gs)
Definition gimple.h:2962
unsigned get_gimple_rhs_num_ops(enum tree_code)
Definition gimple.cc:2480
void gimple_eh_filter_set_types(geh_filter *eh_filter_stmt, tree types)
Definition gimple.h:4342
void gimple_set_vdef(gimple *g, tree vdef)
Definition gimple.h:2237
void gimple_omp_atomic_set_memory_order(gimple *g, enum omp_memory_order mo)
Definition gimple.h:2507
void gimple_wce_set_cleanup_eh_only(gimple *gs, bool eh_only_p)
Definition gimple.h:4564
void gimple_asm_set_clobber_op(gasm *asm_stmt, unsigned index, tree clobber_op)
Definition gimple.h:4140
tree gimple_vuse(const gimple *g)
Definition gimple.h:2179
bool gimple_inexpensive_call_p(gcall *)
Definition gimple.cc:3526
tree * gimple_call_lhs_ptr(gcall *gs)
Definition gimple.h:2978
void gimple_omp_return_set_lhs(gimple *g, tree lhs)
Definition gimple.h:2349
tree * gimple_transaction_label_norm_ptr(gtransaction *transaction_stmt)
Definition gimple.h:6705
tree gimple_omp_target_data_arg(const gomp_target *omp_target_stmt)
Definition gimple.h:6311
void gimple_omp_scope_set_clauses(gimple *gs, tree clauses)
Definition gimple.h:5422
const char * gimple_filename(const gimple *stmt)
Definition gimple.h:1952
gomp_atomic_store * gimple_build_omp_atomic_store(tree, enum omp_memory_order)
Definition gimple.cc:1349
void gimple_call_set_by_descriptor(gcall *s, bool by_descriptor_p)
Definition gimple.h:3578
void gimple_cond_set_condition(gcond *stmt, enum tree_code code, tree lhs, tree rhs)
Definition gimple.h:3891
tree gimple_assign_rhs2(const gassign *gs)
Definition gimple.h:2713
tree gimple_omp_taskgroup_clauses(const gimple *gs)
Definition gimple.h:5331
void gimple_set_op(gimple *gs, unsigned i, tree op)
Definition gimple.h:2582
geh_filter * gimple_build_eh_filter(tree, gimple_seq)
Definition gimple.cc:739
void gimple_omp_set_body(gimple *gs, gimple_seq body)
Definition gimple.h:5206
void gimple_eh_must_not_throw_set_fndecl(geh_mnt *eh_mnt_stmt, tree decl)
Definition gimple.h:4369
void gimple_call_set_must_tail(gcall *s, bool must_tail_p)
Definition gimple.h:3379
gbind * gimple_build_bind(tree, gimple_seq, tree)
Definition gimple.cc:635
void gimple_set_no_warning(gimple *stmt, bool no_warning)
Definition gimple.h:1987
tree * gimple_omp_for_final_ptr(gimple *gs, size_t i)
Definition gimple.h:5699
gimple * gimple_build_assume(tree, gimple_seq)
Definition gimple.cc:1361
void gimple_omp_parallel_set_data_arg(gomp_parallel *omp_parallel_stmt, tree data_arg)
Definition gimple.h:5861
bool gimple_assign_load_p(const gimple *)
Definition gimple.cc:1880
tree gimple_omp_critical_clauses(const gomp_critical *crit_stmt)
Definition gimple.h:5244
gimple_seq * gimple_bind_body_ptr(gbind *bind_stmt)
Definition gimple.h:3989
int gimple_call_return_flags(const gcall *)
Definition gimple.cc:1763
tree * gimple_omp_masked_clauses_ptr(gimple *gs)
Definition gimple.h:5377
bool gimple_phi_arg_has_location(const gphi *phi, size_t i)
Definition gimple.h:4776
gimple_seq_node gimple_seq_first(gimple_seq s)
Definition gimple.h:1687
int gimple_resx_region(const gresx *resx_stmt)
Definition gimple.h:4823
void gimple_omp_critical_set_clauses(gomp_critical *crit_stmt, tree clauses)
Definition gimple.h:5264
void gimple_switch_set_label(gswitch *gs, unsigned index, tree label)
Definition gimple.h:4917
bool gimple_has_side_effects(const gimple *)
Definition gimple.cc:2327
gcall * gimple_build_call_vec(tree, const vec< tree > &)
Definition gimple.cc:269
tree * gimple_omp_continue_control_use_ptr(gomp_continue *cont_stmt)
Definition gimple.h:6619
void gimple_assign_set_nontemporal_move(gimple *gs, bool nontemporal)
Definition gimple.h:2842
bool infer_nonnull_range(gimple *, tree)
Definition gimple.cc:3130
gimple * gimple_build_omp_master(gimple_seq)
Definition gimple.cc:1092
unsigned gimple_num_args(const gimple *gs)
Definition gimple.h:4784
gimple * gimple_build_omp_dispatch(gimple_seq, tree)
Definition gimple.cc:1271
tree * gimple_omp_critical_clauses_ptr(gomp_critical *crit_stmt)
Definition gimple.h:5254
bool gimple_no_warning_p(const gimple *stmt)
Definition gimple.h:1979
unsigned gimple_phi_num_args(const gimple *gs)
Definition gimple.h:4586
void sort_case_labels(vec< tree > &)
Definition gimple.cc:3292
tree gimple_call_fndecl(const gcall *gs)
Definition gimple.h:3224
alias_set_type gimple_get_alias_set(tree)
Definition gimple.cc:2825
tree gimple_omp_teams_data_arg(const gomp_teams *omp_teams_stmt)
Definition gimple.h:6395
void gimple_omp_taskreg_set_child_fn(gimple *gs, tree child_fn)
Definition gimple.h:6068
void gimple_omp_target_set_data_arg(gomp_target *omp_target_stmt, tree data_arg)
Definition gimple.h:6329
tree gimple_bind_vars(const gbind *bind_stmt)
Definition gimple.h:3962
struct phi_arg_d * gimple_phi_arg(gphi *gs, unsigned index)
Definition gimple.h:4638
bool gimple_debug_source_bind_p(const gimple *s)
Definition gimple.h:5075
tree gimple_asm_input_op(const gasm *asm_stmt, unsigned index)
Definition gimple.h:4090
geh_else * gimple_build_eh_else(gimple_seq, gimple_seq)
Definition gimple.cc:766
gomp_atomic_load * gimple_build_omp_atomic_load(tree, tree, enum omp_memory_order)
Definition gimple.cc:1334
gimple_seq gimple_catch_handler(const gcatch *catch_stmt)
Definition gimple.h:4272
unsigned int gimple_plf(gimple *stmt, enum plf_mask plf)
Definition gimple.h:2060
tree * gimple_omp_atomic_load_lhs_ptr(gomp_atomic_load *load_stmt)
Definition gimple.h:6549
tree * gimple_omp_single_clauses_ptr(gimple *gs)
Definition gimple.h:6213
gimple_seq gimple_seq_alloc_with_stmt(gimple *stmt)
Definition gimple.h:1761
bool gimple_call_internal_p(const gcall *gs)
Definition gimple.h:3013
gimple_seq * gimple_try_cleanup_ptr(gimple *gs)
Definition gimple.h:4472
void gimple_omp_teams_set_child_fn(gomp_teams *omp_teams_stmt, tree child_fn)
Definition gimple.h:6385
gassign * gimple_build_assign(tree, tree CXX_MEM_STAT_INFO)
gimple_seq * phi_nodes_ptr(basic_block bb)
Definition gimple.h:4688
void gimple_assign_set_rhs_code(gimple *s, enum tree_code code)
Definition gimple.h:2878
tree gimple_arg(const gimple *gs, unsigned int i)
Definition gimple.h:4799
void gimple_set_do_not_emit_location(gimple *g)
Definition gimple.h:6985
tree gimple_phi_arg_def_from_edge(const gphi *gs, const_edge e)
Definition gimple.h:4712
#define LOCATION_LOCUS(LOC)
Definition input.h:193
#define LOCATION_BLOCK(LOC)
Definition input.h:196
#define LOCATION_FILE(LOC)
Definition input.h:190
#define LOCATION_LINE(LOC)
Definition input.h:191
#define UNKNOWN_LOCATION
Definition input.h:32
T as_a(U *p)
Definition is-a.h:253
T dyn_cast(U *p)
Definition is-a.h:280
@ value
Definition logical-location.h:59
@ function
Definition logical-location.h:37
@ stmt
Definition checker-event.h:37
@ s
Definition graphviz.h:249
const char *const lhs
Definition pretty-print.cc:3219
const char *const rhs
Definition pretty-print.cc:3220
i
Definition poly-int.h:776
static int failure
Definition reload1.cc:671
#define CXX_MEM_STAT_INFO
Definition statistics.h:58
tree variable_size(tree size)
Definition stor-layout.cc:67
union basic_block_def::basic_block_il_dependent il
int flags
Definition basic-block.h:144
Definition tree-predcom.cc:300
Definition genautomata.cc:499
Definition loop-invariant.cc:88
Definition function.h:249
int last_stmt_uid
Definition function.h:317
Definition gimple.h:549
unsigned char nl
Definition gimple.h:561
unsigned char nc
Definition gimple.h:560
unsigned char no
Definition gimple.h:559
unsigned char ni
Definition gimple.h:558
const char * string
Definition gimple.h:554
tree op[1]
Definition gimple.h:567
Definition gimple.h:904
static enum gimple_code code_
Definition gimple.h:905
Definition gimple.h:389
tree block
Definition gimple.h:402
tree vars
Definition gimple.h:394
gimple_seq body
Definition gimple.h:405
Definition gimple.h:352
struct pt_solution call_used
Definition gimple.h:356
tree op[1]
Definition gimple.h:369
struct pt_solution call_clobbered
Definition gimple.h:357
static enum gimple_code code_
Definition gimple.h:371
enum internal_fn internal_fn
Definition gimple.h:362
tree fntype
Definition gimple.h:361
union gcall::@103242352322264346325113136141165045026143300141 u
Definition gimple.h:412
gimple_seq handler
Definition gimple.h:419
tree types
Definition gimple.h:416
Definition gimple.h:858
static enum gimple_code code_
Definition gimple.h:860
Definition gimple.h:868
Definition gimple.h:494
Definition gimple.h:441
gimple_seq e_body
Definition gimple.h:445
gimple_seq n_body
Definition gimple.h:445
Definition gimple.h:426
gimple_seq failure
Definition gimple.h:435
tree types
Definition gimple.h:431
Definition gimple.h:451
tree fndecl
Definition gimple.h:455
Definition gimple.h:877
gimple_seq phi_nodes
Definition basic-block.h:88
gimple_seq seq
Definition basic-block.h:85
Definition gimple.h:585
enum tree_code cond
Definition gimple.h:587
tree final
Definition gimple.h:596
tree index
Definition gimple.h:590
tree initial
Definition gimple.h:593
tree incr
Definition gimple.h:599
Definition gimple.h:795
tree guard
Definition gimple.h:799
gimple_seq body
Definition gimple.h:802
Definition gimple.h:479
int region
Definition gimple.h:484
tree val
Definition gimple.h:775
tree data_arg
Definition gimple.h:640
tree child_fn
Definition gimple.h:636
tree clauses
Definition gimple.h:632
Definition gimple.h:787
Definition gimple.h:723
tree clauses
Definition gimple.h:727
Definition gimple.h:645
Definition gimple.h:378
gimple_seq body
Definition gimple.h:382
Definition gimple.h:532
gimple_seq cleanup
Definition gimple.h:542
tree vdef
Definition gimple.h:329
tree vuse
Definition gimple.h:330
Definition gimple.h:338
tree op[1]
Definition gimple.h:345
Definition gimple.h:294
struct use_optype_d * use_ops
Definition gimple.h:302
Definition gimple.h:309
tree op[1]
Definition gimple.h:316
Definition gimple-iterator.h:26
Definition gimple.h:1658
tree temp
Definition gimple.h:1660
tree val
Definition gimple.h:1659
Definition gimple.h:221
unsigned int visited
Definition gimple.h:231
unsigned pad
Definition gimple.h:252
unsigned int plf
Definition gimple.h:242
unsigned int subcode
Definition gimple.h:258
basic_block bb
Definition gimple.h:277
gimple * next
Definition gimple.h:285
enum gimple_code code
Definition gimple.h:224
unsigned int no_warning
Definition gimple.h:227
unsigned int nontemporal_move
Definition gimple.h:235
unsigned uid
Definition gimple.h:263
unsigned modified
Definition gimple.h:246
gimple * prev
Definition gimple.h:286
location_t location
Definition gimple.h:273
unsigned has_volatile_ops
Definition gimple.h:249
unsigned num_ops
Definition gimple.h:267
Definition gimple.h:886
Definition gimple.h:760
tree rhs
Definition gimple.h:764
tree lhs
Definition gimple.h:764
Definition gimple.h:780
Definition gimple.h:708
tree control_def
Definition gimple.h:712
tree control_use
Definition gimple.h:715
Definition gimple.h:573
tree name
Definition gimple.h:581
tree clauses
Definition gimple.h:577
Definition gimple.h:605
gimple_seq pre_body
Definition gimple.h:620
size_t collapse
Definition gimple.h:613
struct gimple_omp_for_iter * iter
Definition gimple.h:616
tree clauses
Definition gimple.h:609
Definition gimple.h:743
Definition gimple.h:654
Definition gimple.h:749
Definition gimple.h:690
tree clauses
Definition gimple.h:694
tree control
Definition gimple.h:699
Definition gimple.h:731
Definition gimple.h:661
Definition gimple.h:669
tree copy_fn
Definition gimple.h:674
tree arg_size
Definition gimple.h:678
tree arg_align
Definition gimple.h:679
Definition gimple.h:737
Definition gimple.h:461
unsigned nargs
Definition gimple.h:466
unsigned capacity
Definition gimple.h:465
struct phi_arg_d args[1]
Definition gimple.h:472
tree result
Definition gimple.h:469
Definition gimple.h:488
Definition gimple.h:914
Definition gimple.h:895
Definition gimple.h:834
tree label_uninst
Definition gimple.h:842
gimple_seq body
Definition gimple.h:838
tree label_over
Definition gimple.h:843
tree label_norm
Definition gimple.h:841
Definition gimple.h:503
gimple_seq cleanup
Definition gimple.h:512
gimple_seq eval
Definition gimple.h:508
static bool test(U *p)
Definition tree-ssa-alias.h:29
bitmap vars
Definition tree-ssa-alias.h:69
Definition gengtype.h:252
Definition tree-ssa-operands.h:38
Definition loop-invariant.cc:78
Definition vec.h:450
#define NULL
Definition system.h:50
#define gcc_assert(EXPR)
Definition system.h:814
#define CONST_CAST_GIMPLE(X)
Definition system.h:1198
#define gcc_unreachable()
Definition system.h:841
#define false
Definition system.h:888
#define bool
Definition system.h:886
#define gcc_checking_assert(EXPR)
Definition system.h:821
#define ECF_NORETURN
Definition tree-core.h:59
built_in_class
Definition tree-core.h:165
@ tcc_comparison
Definition tree-core.h:233
#define ECF_NOTHROW
Definition tree-core.h:68
#define ECF_XTHROW
Definition tree-core.h:99
omp_memory_order
Definition tree-core.h:655
clobber_kind
Definition tree-core.h:1058
tree copy_fn(tree fn, tree &parms, tree &result)
Definition tree-inline.cc:6723
tree chainon(tree op1, tree op2)
Definition tree.cc:3595
tree build_pointer_type(tree to_type)
Definition tree.cc:7199
location_t set_block(location_t loc, tree block)
Definition tree.cc:14819
location_t * block_nonartificial_location(tree block)
Definition tree.cc:12023
#define boolean_false_node
Definition tree.h:4606
#define SSA_NAME_DEF_STMT(NODE)
Definition tree.h:2182
#define boolean_true_node
Definition tree.h:4607
#define TREE_CODE_CLASS(CODE)
Definition tree.h:202
#define CASE_LOW(NODE)
Definition tree.h:1411
constexpr opt_code all_warnings
Definition tree.h:6972
#define TREE_CODE(NODE)
Definition tree.h:324
constexpr opt_code no_warning
Definition tree.h:6970
#define CONVERT_EXPR_CODE_P(CODE)
Definition tree.h:553
#define TREE_TYPE(NODE)
Definition tree.h:512
#define CONSTANT_CLASS_P(NODE)
Definition tree.h:215
#define TREE_CLOBBER_P(NODE)
Definition tree.h:1289
#define SSA_VAR_P(DECL)
Definition tree.h:2757
#define CLOBBER_KIND(NODE)
Definition tree.h:1293
tree build1_loc(location_t loc, enum tree_code code, tree type, tree arg1 CXX_MEM_STAT_INFO)
Definition tree.h:4843
#define CASE_HIGH(NODE)
Definition tree.h:1412
#define NULL_TREE
Definition tree.h:317
struct gimple_bb_info gimple
Definition basic-block.h:136