OSDN Git Service

2010-05-13 Martin Jambor <mjambor@suse.cz>
[pf3gnuchains/gcc-fork.git] / gcc / gimple.h
1 /* Gimple IR definitions.
2
3    Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4    Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #ifndef GCC_GIMPLE_H
23 #define GCC_GIMPLE_H
24
25 #include "pointer-set.h"
26 #include "vec.h"
27 #include "ggc.h"
28 #include "tm.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
31 #include "tree-ssa-operands.h"
32 #include "tree-ssa-alias.h"
33
34 DEF_VEC_P(gimple);
35 DEF_VEC_ALLOC_P(gimple,heap);
36 DEF_VEC_ALLOC_P(gimple,gc);
37
38 typedef gimple *gimple_p;
39 DEF_VEC_P(gimple_p);
40 DEF_VEC_ALLOC_P(gimple_p,heap);
41
42 DEF_VEC_P(gimple_seq);
43 DEF_VEC_ALLOC_P(gimple_seq,gc);
44 DEF_VEC_ALLOC_P(gimple_seq,heap);
45
46 /* For each block, the PHI nodes that need to be rewritten are stored into
47    these vectors.  */
48 typedef VEC(gimple, heap) *gimple_vec;
49 DEF_VEC_P (gimple_vec);
50 DEF_VEC_ALLOC_P (gimple_vec, heap);
51
52 enum gimple_code {
53 #define DEFGSCODE(SYM, STRING, STRUCT)  SYM,
54 #include "gimple.def"
55 #undef DEFGSCODE
56     LAST_AND_UNUSED_GIMPLE_CODE
57 };
58
59 extern const char *const gimple_code_name[];
60 extern const unsigned char gimple_rhs_class_table[];
61
62 /* Error out if a gimple tuple is addressed incorrectly.  */
63 #if defined ENABLE_GIMPLE_CHECKING
64 extern void gimple_check_failed (const_gimple, const char *, int,          \
65                                  const char *, enum gimple_code,           \
66                                  enum tree_code) ATTRIBUTE_NORETURN;
67
68 #define GIMPLE_CHECK(GS, CODE)                                          \
69   do {                                                                  \
70     const_gimple __gs = (GS);                                           \
71     if (gimple_code (__gs) != (CODE))                                   \
72       gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,      \
73                            (CODE), ERROR_MARK);                         \
74   } while (0)
75 #else  /* not ENABLE_GIMPLE_CHECKING  */
76 #define GIMPLE_CHECK(GS, CODE)                  (void)0
77 #endif
78
79 /* Class of GIMPLE expressions suitable for the RHS of assignments.  See
80    get_gimple_rhs_class.  */
81 enum gimple_rhs_class
82 {
83   GIMPLE_INVALID_RHS,   /* The expression cannot be used on the RHS.  */
84   GIMPLE_BINARY_RHS,    /* The expression is a binary operation.  */
85   GIMPLE_UNARY_RHS,     /* The expression is a unary operation.  */
86   GIMPLE_SINGLE_RHS     /* The expression is a single object (an SSA
87                            name, a _DECL, a _REF, etc.  */
88 };
89
90 /* Specific flags for individual GIMPLE statements.  These flags are
91    always stored in gimple_statement_base.subcode and they may only be
92    defined for statement codes that do not use sub-codes.
93
94    Values for the masks can overlap as long as the overlapping values
95    are never used in the same statement class.
96
97    The maximum mask value that can be defined is 1 << 15 (i.e., each
98    statement code can hold up to 16 bitflags).
99
100    Keep this list sorted.  */
101 enum gf_mask {
102     GF_ASM_INPUT                = 1 << 0,
103     GF_ASM_VOLATILE             = 1 << 1,
104     GF_CALL_CANNOT_INLINE       = 1 << 0,
105     GF_CALL_FROM_THUNK          = 1 << 1,
106     GF_CALL_RETURN_SLOT_OPT     = 1 << 2,
107     GF_CALL_TAILCALL            = 1 << 3,
108     GF_CALL_VA_ARG_PACK         = 1 << 4,
109     GF_OMP_PARALLEL_COMBINED    = 1 << 0,
110
111     /* True on an GIMPLE_OMP_RETURN statement if the return does not require
112        a thread synchronization via some sort of barrier.  The exact barrier
113        that would otherwise be emitted is dependent on the OMP statement with
114        which this return is associated.  */
115     GF_OMP_RETURN_NOWAIT        = 1 << 0,
116
117     GF_OMP_SECTION_LAST         = 1 << 0,
118     GF_PREDICT_TAKEN            = 1 << 15
119 };
120
121 /* Currently, there's only one type of gimple debug stmt.  Others are
122    envisioned, for example, to enable the generation of is_stmt notes
123    in line number information, to mark sequence points, etc.  This
124    subcode is to be used to tell them apart.  */
125 enum gimple_debug_subcode {
126   GIMPLE_DEBUG_BIND = 0
127 };
128
129 /* Masks for selecting a pass local flag (PLF) to work on.  These
130    masks are used by gimple_set_plf and gimple_plf.  */
131 enum plf_mask {
132     GF_PLF_1    = 1 << 0,
133     GF_PLF_2    = 1 << 1
134 };
135
136 /* A node in a gimple_seq_d.  */
137 struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) gimple_seq_node_d {
138   gimple stmt;
139   struct gimple_seq_node_d *prev;
140   struct gimple_seq_node_d *next;
141 };
142
143 /* A double-linked sequence of gimple statements.  */
144 struct GTY ((chain_next ("%h.next_free"))) gimple_seq_d {
145   /* First and last statements in the sequence.  */
146   gimple_seq_node first;
147   gimple_seq_node last;
148
149   /* Sequences are created/destroyed frequently.  To minimize
150      allocation activity, deallocated sequences are kept in a pool of
151      available sequences.  This is the pointer to the next free
152      sequence in the pool.  */
153   gimple_seq next_free;
154 };
155
156
157 /* Return the first node in GIMPLE sequence S.  */
158
159 static inline gimple_seq_node
160 gimple_seq_first (const_gimple_seq s)
161 {
162   return s ? s->first : NULL;
163 }
164
165
166 /* Return the first statement in GIMPLE sequence S.  */
167
168 static inline gimple
169 gimple_seq_first_stmt (const_gimple_seq s)
170 {
171   gimple_seq_node n = gimple_seq_first (s);
172   return (n) ? n->stmt : NULL;
173 }
174
175
176 /* Return the last node in GIMPLE sequence S.  */
177
178 static inline gimple_seq_node
179 gimple_seq_last (const_gimple_seq s)
180 {
181   return s ? s->last : NULL;
182 }
183
184
185 /* Return the last statement in GIMPLE sequence S.  */
186
187 static inline gimple
188 gimple_seq_last_stmt (const_gimple_seq s)
189 {
190   gimple_seq_node n = gimple_seq_last (s);
191   return (n) ? n->stmt : NULL;
192 }
193
194
195 /* Set the last node in GIMPLE sequence S to LAST.  */
196
197 static inline void
198 gimple_seq_set_last (gimple_seq s, gimple_seq_node last)
199 {
200   s->last = last;
201 }
202
203
204 /* Set the first node in GIMPLE sequence S to FIRST.  */
205
206 static inline void
207 gimple_seq_set_first (gimple_seq s, gimple_seq_node first)
208 {
209   s->first = first;
210 }
211
212
213 /* Return true if GIMPLE sequence S is empty.  */
214
215 static inline bool
216 gimple_seq_empty_p (const_gimple_seq s)
217 {
218   return s == NULL || s->first == NULL;
219 }
220
221
222 void gimple_seq_add_stmt (gimple_seq *, gimple);
223
224 /* Allocate a new sequence and initialize its first element with STMT.  */
225
226 static inline gimple_seq
227 gimple_seq_alloc_with_stmt (gimple stmt)
228 {
229   gimple_seq seq = NULL;
230   gimple_seq_add_stmt (&seq, stmt);
231   return seq;
232 }
233
234
235 /* Returns the sequence of statements in BB.  */
236
237 static inline gimple_seq
238 bb_seq (const_basic_block bb)
239 {
240   return (!(bb->flags & BB_RTL) && bb->il.gimple) ? bb->il.gimple->seq : NULL;
241 }
242
243
244 /* Sets the sequence of statements in BB to SEQ.  */
245
246 static inline void
247 set_bb_seq (basic_block bb, gimple_seq seq)
248 {
249   gcc_assert (!(bb->flags & BB_RTL));
250   bb->il.gimple->seq = seq;
251 }
252
253 /* Iterator object for GIMPLE statement sequences.  */
254
255 typedef struct
256 {
257   /* Sequence node holding the current statement.  */
258   gimple_seq_node ptr;
259
260   /* Sequence and basic block holding the statement.  These fields
261      are necessary to handle edge cases such as when statement is
262      added to an empty basic block or when the last statement of a
263      block/sequence is removed.  */
264   gimple_seq seq;
265   basic_block bb;
266 } gimple_stmt_iterator;
267
268
269 /* Data structure definitions for GIMPLE tuples.  NOTE: word markers
270    are for 64 bit hosts.  */
271
272 struct GTY(()) gimple_statement_base {
273   /* [ WORD 1 ]
274      Main identifying code for a tuple.  */
275   ENUM_BITFIELD(gimple_code) code : 8;
276
277   /* Nonzero if a warning should not be emitted on this tuple.  */
278   unsigned int no_warning       : 1;
279
280   /* Nonzero if this tuple has been visited.  Passes are responsible
281      for clearing this bit before using it.  */
282   unsigned int visited          : 1;
283
284   /* Nonzero if this tuple represents a non-temporal move.  */
285   unsigned int nontemporal_move : 1;
286
287   /* Pass local flags.  These flags are free for any pass to use as
288      they see fit.  Passes should not assume that these flags contain
289      any useful value when the pass starts.  Any initial state that
290      the pass requires should be set on entry to the pass.  See
291      gimple_set_plf and gimple_plf for usage.  */
292   unsigned int plf              : 2;
293
294   /* Nonzero if this statement has been modified and needs to have its
295      operands rescanned.  */
296   unsigned modified             : 1;
297
298   /* Nonzero if this statement contains volatile operands.  */
299   unsigned has_volatile_ops     : 1;
300
301   /* Padding to get subcode to 16 bit alignment.  */
302   unsigned pad                  : 1;
303
304   /* The SUBCODE field can be used for tuple-specific flags for tuples
305      that do not require subcodes.  Note that SUBCODE should be at
306      least as wide as tree codes, as several tuples store tree codes
307      in there.  */
308   unsigned int subcode          : 16;
309
310   /* UID of this statement.  This is used by passes that want to
311      assign IDs to statements.  It must be assigned and used by each
312      pass.  By default it should be assumed to contain garbage.  */
313   unsigned uid;
314
315   /* [ WORD 2 ]
316      Locus information for debug info.  */
317   location_t location;
318
319   /* Number of operands in this tuple.  */
320   unsigned num_ops;
321
322   /* [ WORD 3 ]
323      Basic block holding this statement.  */
324   struct basic_block_def *bb;
325
326   /* [ WORD 4 ]
327      Lexical block holding this statement.  */
328   tree block;
329 };
330
331
332 /* Base structure for tuples with operands.  */
333
334 struct GTY(()) gimple_statement_with_ops_base
335 {
336   /* [ WORD 1-4 ]  */
337   struct gimple_statement_base gsbase;
338
339   /* [ WORD 5-6 ]
340      SSA operand vectors.  NOTE: It should be possible to
341      amalgamate these vectors with the operand vector OP.  However,
342      the SSA operand vectors are organized differently and contain
343      more information (like immediate use chaining).  */
344   struct def_optype_d GTY((skip (""))) *def_ops;
345   struct use_optype_d GTY((skip (""))) *use_ops;
346 };
347
348
349 /* Statements that take register operands.  */
350
351 struct GTY(()) gimple_statement_with_ops
352 {
353   /* [ WORD 1-6 ]  */
354   struct gimple_statement_with_ops_base opbase;
355
356   /* [ WORD 7 ]
357      Operand vector.  NOTE!  This must always be the last field
358      of this structure.  In particular, this means that this
359      structure cannot be embedded inside another one.  */
360   tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1];
361 };
362
363
364 /* Base for statements that take both memory and register operands.  */
365
366 struct GTY(()) gimple_statement_with_memory_ops_base
367 {
368   /* [ WORD 1-6 ]  */
369   struct gimple_statement_with_ops_base opbase;
370
371   /* [ WORD 7-8 ]
372      Virtual operands for this statement.  The GC will pick them
373      up via the ssa_names array.  */
374   tree GTY((skip (""))) vdef;
375   tree GTY((skip (""))) vuse;
376 };
377
378
379 /* Statements that take both memory and register operands.  */
380
381 struct GTY(()) gimple_statement_with_memory_ops
382 {
383   /* [ WORD 1-8 ]  */
384   struct gimple_statement_with_memory_ops_base membase;
385
386   /* [ WORD 9 ]
387      Operand vector.  NOTE!  This must always be the last field
388      of this structure.  In particular, this means that this
389      structure cannot be embedded inside another one.  */
390   tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
391 };
392
393
394 /* Call statements that take both memory and register operands.  */
395
396 struct GTY(()) gimple_statement_call
397 {
398   /* [ WORD 1-8 ]  */
399   struct gimple_statement_with_memory_ops_base membase;
400
401   /* [ WORD 9-12 ]  */
402   struct pt_solution call_used;
403   struct pt_solution call_clobbered;
404
405   /* [ WORD 13 ]
406      Operand vector.  NOTE!  This must always be the last field
407      of this structure.  In particular, this means that this
408      structure cannot be embedded inside another one.  */
409   tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
410 };
411
412
413 /* OpenMP statements (#pragma omp).  */
414
415 struct GTY(()) gimple_statement_omp {
416   /* [ WORD 1-4 ]  */
417   struct gimple_statement_base gsbase;
418
419   /* [ WORD 5 ]  */
420   gimple_seq body;
421 };
422
423
424 /* GIMPLE_BIND */
425
426 struct GTY(()) gimple_statement_bind {
427   /* [ WORD 1-4 ]  */
428   struct gimple_statement_base gsbase;
429
430   /* [ WORD 5 ]
431      Variables declared in this scope.  */
432   tree vars;
433
434   /* [ WORD 6 ]
435      This is different than the BLOCK field in gimple_statement_base,
436      which is analogous to TREE_BLOCK (i.e., the lexical block holding
437      this statement).  This field is the equivalent of BIND_EXPR_BLOCK
438      in tree land (i.e., the lexical scope defined by this bind).  See
439      gimple-low.c.  */
440   tree block;
441
442   /* [ WORD 7 ]  */
443   gimple_seq body;
444 };
445
446
447 /* GIMPLE_CATCH */
448
449 struct GTY(()) gimple_statement_catch {
450   /* [ WORD 1-4 ]  */
451   struct gimple_statement_base gsbase;
452
453   /* [ WORD 5 ]  */
454   tree types;
455
456   /* [ WORD 6 ]  */
457   gimple_seq handler;
458 };
459
460
461 /* GIMPLE_EH_FILTER */
462
463 struct GTY(()) gimple_statement_eh_filter {
464   /* [ WORD 1-4 ]  */
465   struct gimple_statement_base gsbase;
466
467   /* [ WORD 5 ]
468      Filter types.  */
469   tree types;
470
471   /* [ WORD 6 ]
472      Failure actions.  */
473   gimple_seq failure;
474 };
475
476
477 /* GIMPLE_EH_MUST_NOT_THROW */
478
479 struct GTY(()) gimple_statement_eh_mnt {
480   /* [ WORD 1-4 ]  */
481   struct gimple_statement_base gsbase;
482
483   /* [ WORD 5 ] Abort function decl.  */
484   tree fndecl;
485 };
486
487 /* GIMPLE_PHI */
488
489 struct GTY(()) gimple_statement_phi {
490   /* [ WORD 1-4 ]  */
491   struct gimple_statement_base gsbase;
492
493   /* [ WORD 5 ]  */
494   unsigned capacity;
495   unsigned nargs;
496
497   /* [ WORD 6 ]  */
498   tree result;
499
500   /* [ WORD 7 ]  */
501   struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
502 };
503
504
505 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
506
507 struct GTY(()) gimple_statement_eh_ctrl
508 {
509   /* [ WORD 1-4 ]  */
510   struct gimple_statement_base gsbase;
511
512   /* [ WORD 5 ]
513      Exception region number.  */
514   int region;
515 };
516
517
518 /* GIMPLE_TRY */
519
520 struct GTY(()) gimple_statement_try {
521   /* [ WORD 1-4 ]  */
522   struct gimple_statement_base gsbase;
523
524   /* [ WORD 5 ]
525      Expression to evaluate.  */
526   gimple_seq eval;
527
528   /* [ WORD 6 ]
529      Cleanup expression.  */
530   gimple_seq cleanup;
531 };
532
533 /* Kind of GIMPLE_TRY statements.  */
534 enum gimple_try_flags
535 {
536   /* A try/catch.  */
537   GIMPLE_TRY_CATCH = 1 << 0,
538
539   /* A try/finally.  */
540   GIMPLE_TRY_FINALLY = 1 << 1,
541   GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
542
543   /* Analogous to TRY_CATCH_IS_CLEANUP.  */
544   GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
545 };
546
547 /* GIMPLE_WITH_CLEANUP_EXPR */
548
549 struct GTY(()) gimple_statement_wce {
550   /* [ WORD 1-4 ]  */
551   struct gimple_statement_base gsbase;
552
553   /* Subcode: CLEANUP_EH_ONLY.  True if the cleanup should only be
554               executed if an exception is thrown, not on normal exit of its
555               scope.  This flag is analogous to the CLEANUP_EH_ONLY flag
556               in TARGET_EXPRs.  */
557
558   /* [ WORD 5 ]
559      Cleanup expression.  */
560   gimple_seq cleanup;
561 };
562
563
564 /* GIMPLE_ASM  */
565
566 struct GTY(()) gimple_statement_asm
567 {
568   /* [ WORD 1-8 ]  */
569   struct gimple_statement_with_memory_ops_base membase;
570
571   /* [ WORD 9 ]
572      __asm__ statement.  */
573   const char *string;
574
575   /* [ WORD 10 ]
576        Number of inputs, outputs, clobbers, labels.  */
577   unsigned char ni;
578   unsigned char no;
579   unsigned char nc;
580   unsigned char nl;
581
582   /* [ WORD 11 ]
583      Operand vector.  NOTE!  This must always be the last field
584      of this structure.  In particular, this means that this
585      structure cannot be embedded inside another one.  */
586   tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
587 };
588
589 /* GIMPLE_OMP_CRITICAL */
590
591 struct GTY(()) gimple_statement_omp_critical {
592   /* [ WORD 1-5 ]  */
593   struct gimple_statement_omp omp;
594
595   /* [ WORD 6 ]
596      Critical section name.  */
597   tree name;
598 };
599
600
601 struct GTY(()) gimple_omp_for_iter {
602   /* Condition code.  */
603   enum tree_code cond;
604
605   /* Index variable.  */
606   tree index;
607
608   /* Initial value.  */
609   tree initial;
610
611   /* Final value.  */
612   tree final;
613
614   /* Increment.  */
615   tree incr;
616 };
617
618 /* GIMPLE_OMP_FOR */
619
620 struct GTY(()) gimple_statement_omp_for {
621   /* [ WORD 1-5 ]  */
622   struct gimple_statement_omp omp;
623
624   /* [ WORD 6 ]  */
625   tree clauses;
626
627   /* [ WORD 7 ]
628      Number of elements in iter array.  */
629   size_t collapse;
630
631   /* [ WORD 8 ]  */
632   struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
633
634   /* [ WORD 9 ]
635      Pre-body evaluated before the loop body begins.  */
636   gimple_seq pre_body;
637 };
638
639
640 /* GIMPLE_OMP_PARALLEL */
641
642 struct GTY(()) gimple_statement_omp_parallel {
643   /* [ WORD 1-5 ]  */
644   struct gimple_statement_omp omp;
645
646   /* [ WORD 6 ]
647      Clauses.  */
648   tree clauses;
649
650   /* [ WORD 7 ]
651      Child function holding the body of the parallel region.  */
652   tree child_fn;
653
654   /* [ WORD 8 ]
655      Shared data argument.  */
656   tree data_arg;
657 };
658
659
660 /* GIMPLE_OMP_TASK */
661
662 struct GTY(()) gimple_statement_omp_task {
663   /* [ WORD 1-8 ]  */
664   struct gimple_statement_omp_parallel par;
665
666   /* [ WORD 9 ]
667      Child function holding firstprivate initialization if needed.  */
668   tree copy_fn;
669
670   /* [ WORD 10-11 ]
671      Size and alignment in bytes of the argument data block.  */
672   tree arg_size;
673   tree arg_align;
674 };
675
676
677 /* GIMPLE_OMP_SECTION */
678 /* Uses struct gimple_statement_omp.  */
679
680
681 /* GIMPLE_OMP_SECTIONS */
682
683 struct GTY(()) gimple_statement_omp_sections {
684   /* [ WORD 1-5 ]  */
685   struct gimple_statement_omp omp;
686
687   /* [ WORD 6 ]  */
688   tree clauses;
689
690   /* [ WORD 7 ]
691      The control variable used for deciding which of the sections to
692      execute.  */
693   tree control;
694 };
695
696 /* GIMPLE_OMP_CONTINUE.
697
698    Note: This does not inherit from gimple_statement_omp, because we
699          do not need the body field.  */
700
701 struct GTY(()) gimple_statement_omp_continue {
702   /* [ WORD 1-4 ]  */
703   struct gimple_statement_base gsbase;
704
705   /* [ WORD 5 ]  */
706   tree control_def;
707
708   /* [ WORD 6 ]  */
709   tree control_use;
710 };
711
712 /* GIMPLE_OMP_SINGLE */
713
714 struct GTY(()) gimple_statement_omp_single {
715   /* [ WORD 1-5 ]  */
716   struct gimple_statement_omp omp;
717
718   /* [ WORD 6 ]  */
719   tree clauses;
720 };
721
722
723 /* GIMPLE_OMP_ATOMIC_LOAD.
724    Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
725    contains a sequence, which we don't need here.  */
726
727 struct GTY(()) gimple_statement_omp_atomic_load {
728   /* [ WORD 1-4 ]  */
729   struct gimple_statement_base gsbase;
730
731   /* [ WORD 5-6 ]  */
732   tree rhs, lhs;
733 };
734
735 /* GIMPLE_OMP_ATOMIC_STORE.
736    See note on GIMPLE_OMP_ATOMIC_LOAD.  */
737
738 struct GTY(()) gimple_statement_omp_atomic_store {
739   /* [ WORD 1-4 ]  */
740   struct gimple_statement_base gsbase;
741
742   /* [ WORD 5 ]  */
743   tree val;
744 };
745
746 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)   SYM,
747 enum gimple_statement_structure_enum {
748 #include "gsstruct.def"
749     LAST_GSS_ENUM
750 };
751 #undef DEFGSSTRUCT
752
753
754 /* Define the overall contents of a gimple tuple.  It may be any of the
755    structures declared above for various types of tuples.  */
756
757 union GTY ((desc ("gimple_statement_structure (&%h)"))) gimple_statement_d {
758   struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase;
759   struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops;
760   struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase;
761   struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem;
762   struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call;
763   struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
764   struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
765   struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
766   struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter;
767   struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt;
768   struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
769   struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl;
770   struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
771   struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce;
772   struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm;
773   struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical;
774   struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for;
775   struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel;
776   struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task;
777   struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections;
778   struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single;
779   struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue;
780   struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
781   struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
782 };
783
784 /* In gimple.c.  */
785
786 /* Offset in bytes to the location of the operand vector.
787    Zero if there is no operand vector for this tuple structure.  */
788 extern size_t const gimple_ops_offset_[];
789
790 /* Map GIMPLE codes to GSS codes.  */
791 extern enum gimple_statement_structure_enum const gss_for_code_[];
792
793 /* This variable holds the currently expanded gimple statement for purposes
794    of comminucating the profile info to the builtin expanders.  */
795 extern gimple currently_expanding_gimple_stmt;
796
797 gimple gimple_build_return (tree);
798
799 gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
800 #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
801
802 void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *);
803
804 gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree,
805                                           tree MEM_STAT_DECL);
806 #define gimple_build_assign_with_ops(c,o1,o2,o3) \
807   gimple_build_assign_with_ops_stat (c, o1, o2, o3 MEM_STAT_INFO)
808
809 gimple gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL);
810 #define gimple_build_debug_bind(var,val,stmt)                   \
811   gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
812
813 gimple gimple_build_call_vec (tree, VEC(tree, heap) *);
814 gimple gimple_build_call (tree, unsigned, ...);
815 gimple gimple_build_call_from_tree (tree);
816 gimple gimplify_assign (tree, tree, gimple_seq *);
817 gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree);
818 gimple gimple_build_label (tree label);
819 gimple gimple_build_goto (tree dest);
820 gimple gimple_build_nop (void);
821 gimple gimple_build_bind (tree, gimple_seq, tree);
822 gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *,
823                              VEC(tree,gc) *, VEC(tree,gc) *);
824 gimple gimple_build_catch (tree, gimple_seq);
825 gimple gimple_build_eh_filter (tree, gimple_seq);
826 gimple gimple_build_eh_must_not_throw (tree);
827 gimple gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags);
828 gimple gimple_build_wce (gimple_seq);
829 gimple gimple_build_resx (int);
830 gimple gimple_build_eh_dispatch (int);
831 gimple gimple_build_switch_nlabels (unsigned, tree, tree);
832 gimple gimple_build_switch (unsigned, tree, tree, ...);
833 gimple gimple_build_switch_vec (tree, tree, VEC(tree,heap) *);
834 gimple gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
835 gimple gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree);
836 gimple gimple_build_omp_for (gimple_seq, tree, size_t, gimple_seq);
837 gimple gimple_build_omp_critical (gimple_seq, tree);
838 gimple gimple_build_omp_section (gimple_seq);
839 gimple gimple_build_omp_continue (tree, tree);
840 gimple gimple_build_omp_master (gimple_seq);
841 gimple gimple_build_omp_return (bool);
842 gimple gimple_build_omp_ordered (gimple_seq);
843 gimple gimple_build_omp_sections (gimple_seq, tree);
844 gimple gimple_build_omp_sections_switch (void);
845 gimple gimple_build_omp_single (gimple_seq, tree);
846 gimple gimple_build_cdt (tree, tree);
847 gimple gimple_build_omp_atomic_load (tree, tree);
848 gimple gimple_build_omp_atomic_store (tree);
849 gimple gimple_build_predict (enum br_predictor, enum prediction);
850 enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
851 void sort_case_labels (VEC(tree,heap) *);
852 void gimple_set_body (tree, gimple_seq);
853 gimple_seq gimple_body (tree);
854 bool gimple_has_body_p (tree);
855 gimple_seq gimple_seq_alloc (void);
856 void gimple_seq_free (gimple_seq);
857 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
858 gimple_seq gimple_seq_copy (gimple_seq);
859 int gimple_call_flags (const_gimple);
860 int gimple_call_return_flags (const_gimple);
861 int gimple_call_arg_flags (const_gimple, unsigned);
862 void gimple_call_reset_alias_info (gimple);
863 bool gimple_assign_copy_p (gimple);
864 bool gimple_assign_ssa_name_copy_p (gimple);
865 bool gimple_assign_single_p (gimple);
866 bool gimple_assign_unary_nop_p (gimple);
867 void gimple_set_bb (gimple, struct basic_block_def *);
868 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
869 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
870                                      tree, tree);
871 tree gimple_get_lhs (const_gimple);
872 void gimple_set_lhs (gimple, tree);
873 void gimple_replace_lhs (gimple, tree);
874 gimple gimple_copy (gimple);
875 bool is_gimple_operand (const_tree);
876 void gimple_set_modified (gimple, bool);
877 void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *);
878 gimple gimple_build_cond_from_tree (tree, tree, tree);
879 void gimple_cond_set_condition_from_tree (gimple, tree);
880 bool gimple_has_side_effects (const_gimple);
881 bool gimple_rhs_has_side_effects (const_gimple);
882 bool gimple_could_trap_p (gimple);
883 bool gimple_assign_rhs_could_trap_p (gimple);
884 void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
885 bool empty_body_p (gimple_seq);
886 unsigned get_gimple_rhs_num_ops (enum tree_code);
887 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
888 gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL);
889 const char *gimple_decl_printable_name (tree, int);
890 tree gimple_fold_obj_type_ref (tree, tree);
891 tree gimple_get_relevant_ref_binfo (tree ref, tree known_binfo);
892 tree gimple_fold_obj_type_ref_known_binfo (HOST_WIDE_INT, tree);
893
894 /* Returns true iff T is a valid GIMPLE statement.  */
895 extern bool is_gimple_stmt (tree);
896
897 /* Returns true iff TYPE is a valid type for a scalar register variable.  */
898 extern bool is_gimple_reg_type (tree);
899 /* Returns true iff T is a scalar register variable.  */
900 extern bool is_gimple_reg (tree);
901 /* Returns true iff T is any sort of variable.  */
902 extern bool is_gimple_variable (tree);
903 /* Returns true iff T is any sort of symbol.  */
904 extern bool is_gimple_id (tree);
905 /* Returns true iff T is a variable or an INDIRECT_REF (of a variable).  */
906 extern bool is_gimple_min_lval (tree);
907 /* Returns true iff T is something whose address can be taken.  */
908 extern bool is_gimple_addressable (tree);
909 /* Returns true iff T is any valid GIMPLE lvalue.  */
910 extern bool is_gimple_lvalue (tree);
911
912 /* Returns true iff T is a GIMPLE address.  */
913 bool is_gimple_address (const_tree);
914 /* Returns true iff T is a GIMPLE invariant address.  */
915 bool is_gimple_invariant_address (const_tree);
916 /* Returns true iff T is a GIMPLE invariant address at interprocedural
917    level.  */
918 bool is_gimple_ip_invariant_address (const_tree);
919 /* Returns true iff T is a valid GIMPLE constant.  */
920 bool is_gimple_constant (const_tree);
921 /* Returns true iff T is a GIMPLE restricted function invariant.  */
922 extern bool is_gimple_min_invariant (const_tree);
923 /* Returns true iff T is a GIMPLE restricted interprecodural invariant.  */
924 extern bool is_gimple_ip_invariant (const_tree);
925 /* Returns true iff T is a GIMPLE rvalue.  */
926 extern bool is_gimple_val (tree);
927 /* Returns true iff T is a GIMPLE asm statement input.  */
928 extern bool is_gimple_asm_val (tree);
929 /* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a
930    GIMPLE temporary, a renamed user variable, or something else,
931    respectively.  */
932 extern bool is_gimple_reg_rhs (tree);
933 extern bool is_gimple_mem_rhs (tree);
934
935 /* Returns true iff T is a valid if-statement condition.  */
936 extern bool is_gimple_condexpr (tree);
937
938 /* Returns true iff T is a type conversion.  */
939 extern bool is_gimple_cast (tree);
940 /* Returns true iff T is a variable that does not need to live in memory.  */
941 extern bool is_gimple_non_addressable (tree t);
942
943 /* Returns true iff T is a valid call address expression.  */
944 extern bool is_gimple_call_addr (tree);
945 /* If T makes a function call, returns the CALL_EXPR operand.  */
946 extern tree get_call_expr_in (tree t);
947
948 extern void recalculate_side_effects (tree);
949 extern bool compare_field_offset (tree, tree);
950 extern tree gimple_register_type (tree);
951 extern void print_gimple_types_stats (void);
952 extern void free_gimple_type_tables (void);
953 extern tree gimple_unsigned_type (tree);
954 extern tree gimple_signed_type (tree);
955 extern alias_set_type gimple_get_alias_set (tree);
956 extern void count_uses_and_derefs (tree, gimple, unsigned *, unsigned *,
957                                    unsigned *);
958 extern bool walk_stmt_load_store_addr_ops (gimple, void *,
959                                            bool (*)(gimple, tree, void *),
960                                            bool (*)(gimple, tree, void *),
961                                            bool (*)(gimple, tree, void *));
962 extern bool walk_stmt_load_store_ops (gimple, void *,
963                                       bool (*)(gimple, tree, void *),
964                                       bool (*)(gimple, tree, void *));
965 extern bool gimple_ior_addresses_taken (bitmap, gimple);
966
967 /* In gimplify.c  */
968 extern tree create_tmp_var_raw (tree, const char *);
969 extern tree create_tmp_var_name (const char *);
970 extern tree create_tmp_var (tree, const char *);
971 extern tree create_tmp_reg (tree, const char *);
972 extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *);
973 extern tree get_formal_tmp_var (tree, gimple_seq *);
974 extern void declare_vars (tree, gimple, bool);
975 extern void annotate_all_with_location (gimple_seq, location_t);
976
977 /* Validation of GIMPLE expressions.  Note that these predicates only check
978    the basic form of the expression, they don't recurse to make sure that
979    underlying nodes are also of the right form.  */
980 typedef bool (*gimple_predicate)(tree);
981
982
983 /* FIXME we should deduce this from the predicate.  */
984 enum fallback {
985   fb_none = 0,          /* Do not generate a temporary.  */
986
987   fb_rvalue = 1,        /* Generate an rvalue to hold the result of a
988                            gimplified expression.  */
989
990   fb_lvalue = 2,        /* Generate an lvalue to hold the result of a
991                            gimplified expression.  */
992
993   fb_mayfail = 4,       /* Gimplification may fail.  Error issued
994                            afterwards.  */
995   fb_either= fb_rvalue | fb_lvalue
996 };
997
998 typedef int fallback_t;
999
1000 enum gimplify_status {
1001   GS_ERROR      = -2,   /* Something Bad Seen.  */
1002   GS_UNHANDLED  = -1,   /* A langhook result for "I dunno".  */
1003   GS_OK         = 0,    /* We did something, maybe more to do.  */
1004   GS_ALL_DONE   = 1     /* The expression is fully gimplified.  */
1005 };
1006
1007 struct gimplify_ctx
1008 {
1009   struct gimplify_ctx *prev_context;
1010
1011   VEC(gimple,heap) *bind_expr_stack;
1012   tree temps;
1013   gimple_seq conditional_cleanups;
1014   tree exit_label;
1015   tree return_temp;
1016
1017   VEC(tree,heap) *case_labels;
1018   /* The formal temporary table.  Should this be persistent?  */
1019   htab_t temp_htab;
1020
1021   int conditions;
1022   bool save_stack;
1023   bool into_ssa;
1024   bool allow_rhs_cond_expr;
1025 };
1026
1027 extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
1028                                            bool (*) (tree), fallback_t);
1029 extern void gimplify_type_sizes (tree, gimple_seq *);
1030 extern void gimplify_one_sizepos (tree *, gimple_seq *);
1031 extern bool gimplify_stmt (tree *, gimple_seq *);
1032 extern gimple gimplify_body (tree *, tree, bool);
1033 extern void push_gimplify_context (struct gimplify_ctx *);
1034 extern void pop_gimplify_context (gimple);
1035 extern void gimplify_and_add (tree, gimple_seq *);
1036
1037 /* Miscellaneous helpers.  */
1038 extern void gimple_add_tmp_var (tree);
1039 extern gimple gimple_current_bind_expr (void);
1040 extern VEC(gimple, heap) *gimple_bind_expr_stack (void);
1041 extern tree voidify_wrapper_expr (tree, tree);
1042 extern tree build_and_jump (tree *);
1043 extern tree alloc_stmt_list (void);
1044 extern void free_stmt_list (tree);
1045 extern tree force_labels_r (tree *, int *, void *);
1046 extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *,
1047                                                   gimple_seq *);
1048 struct gimplify_omp_ctx;
1049 extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree);
1050 extern tree gimple_boolify (tree);
1051 extern gimple_predicate rhs_predicate_for (tree);
1052 extern tree canonicalize_cond_expr_cond (tree);
1053
1054 /* In omp-low.c.  */
1055 extern tree omp_reduction_init (tree, tree);
1056
1057 /* In tree-nested.c.  */
1058 extern void lower_nested_functions (tree);
1059 extern void insert_field_into_struct (tree, tree);
1060
1061 /* In gimplify.c.  */
1062 extern void gimplify_function_tree (tree);
1063
1064 /* In cfgexpand.c.  */
1065 extern tree gimple_assign_rhs_to_tree (gimple);
1066
1067 /* In builtins.c  */
1068 extern bool validate_gimple_arglist (const_gimple, ...);
1069
1070 /* In tree-ssa.c  */
1071 extern bool tree_ssa_useless_type_conversion (tree);
1072 extern tree tree_ssa_strip_useless_type_conversions (tree);
1073 extern bool useless_type_conversion_p (tree, tree);
1074 extern bool types_compatible_p (tree, tree);
1075
1076 /* Return the code for GIMPLE statement G.  */
1077
1078 static inline enum gimple_code
1079 gimple_code (const_gimple g)
1080 {
1081   return g->gsbase.code;
1082 }
1083
1084
1085 /* Return the GSS code used by a GIMPLE code.  */
1086
1087 static inline enum gimple_statement_structure_enum
1088 gss_for_code (enum gimple_code code)
1089 {
1090 #ifdef ENABLE_CHECKING
1091   gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
1092 #endif
1093   return gss_for_code_[code];
1094 }
1095
1096
1097 /* Return which GSS code is used by GS.  */
1098
1099 static inline enum gimple_statement_structure_enum
1100 gimple_statement_structure (gimple gs)
1101 {
1102   return gss_for_code (gimple_code (gs));
1103 }
1104
1105
1106 /* Return true if statement G has sub-statements.  This is only true for
1107    High GIMPLE statements.  */
1108
1109 static inline bool
1110 gimple_has_substatements (gimple g)
1111 {
1112   switch (gimple_code (g))
1113     {
1114     case GIMPLE_BIND:
1115     case GIMPLE_CATCH:
1116     case GIMPLE_EH_FILTER:
1117     case GIMPLE_TRY:
1118     case GIMPLE_OMP_FOR:
1119     case GIMPLE_OMP_MASTER:
1120     case GIMPLE_OMP_ORDERED:
1121     case GIMPLE_OMP_SECTION:
1122     case GIMPLE_OMP_PARALLEL:
1123     case GIMPLE_OMP_TASK:
1124     case GIMPLE_OMP_SECTIONS:
1125     case GIMPLE_OMP_SINGLE:
1126     case GIMPLE_OMP_CRITICAL:
1127     case GIMPLE_WITH_CLEANUP_EXPR:
1128       return true;
1129
1130     default:
1131       return false;
1132     }
1133 }
1134
1135
1136 /* Return the basic block holding statement G.  */
1137
1138 static inline struct basic_block_def *
1139 gimple_bb (const_gimple g)
1140 {
1141   return g->gsbase.bb;
1142 }
1143
1144
1145 /* Return the lexical scope block holding statement G.  */
1146
1147 static inline tree
1148 gimple_block (const_gimple g)
1149 {
1150   return g->gsbase.block;
1151 }
1152
1153
1154 /* Set BLOCK to be the lexical scope block holding statement G.  */
1155
1156 static inline void
1157 gimple_set_block (gimple g, tree block)
1158 {
1159   g->gsbase.block = block;
1160 }
1161
1162
1163 /* Return location information for statement G.  */
1164
1165 static inline location_t
1166 gimple_location (const_gimple g)
1167 {
1168   return g->gsbase.location;
1169 }
1170
1171 /* Return pointer to location information for statement G.  */
1172
1173 static inline const location_t *
1174 gimple_location_ptr (const_gimple g)
1175 {
1176   return &g->gsbase.location;
1177 }
1178
1179
1180 /* Set location information for statement G.  */
1181
1182 static inline void
1183 gimple_set_location (gimple g, location_t location)
1184 {
1185   g->gsbase.location = location;
1186 }
1187
1188
1189 /* Return true if G contains location information.  */
1190
1191 static inline bool
1192 gimple_has_location (const_gimple g)
1193 {
1194   return gimple_location (g) != UNKNOWN_LOCATION;
1195 }
1196
1197
1198 /* Return the file name of the location of STMT.  */
1199
1200 static inline const char *
1201 gimple_filename (const_gimple stmt)
1202 {
1203   return LOCATION_FILE (gimple_location (stmt));
1204 }
1205
1206
1207 /* Return the line number of the location of STMT.  */
1208
1209 static inline int
1210 gimple_lineno (const_gimple stmt)
1211 {
1212   return LOCATION_LINE (gimple_location (stmt));
1213 }
1214
1215
1216 /* Determine whether SEQ is a singleton. */
1217
1218 static inline bool
1219 gimple_seq_singleton_p (gimple_seq seq)
1220 {
1221   return ((gimple_seq_first (seq) != NULL)
1222           && (gimple_seq_first (seq) == gimple_seq_last (seq)));
1223 }
1224
1225 /* Return true if no warnings should be emitted for statement STMT.  */
1226
1227 static inline bool
1228 gimple_no_warning_p (const_gimple stmt)
1229 {
1230   return stmt->gsbase.no_warning;
1231 }
1232
1233 /* Set the no_warning flag of STMT to NO_WARNING.  */
1234
1235 static inline void
1236 gimple_set_no_warning (gimple stmt, bool no_warning)
1237 {
1238   stmt->gsbase.no_warning = (unsigned) no_warning;
1239 }
1240
1241 /* Set the visited status on statement STMT to VISITED_P.  */
1242
1243 static inline void
1244 gimple_set_visited (gimple stmt, bool visited_p)
1245 {
1246   stmt->gsbase.visited = (unsigned) visited_p;
1247 }
1248
1249
1250 /* Return the visited status for statement STMT.  */
1251
1252 static inline bool
1253 gimple_visited_p (gimple stmt)
1254 {
1255   return stmt->gsbase.visited;
1256 }
1257
1258
1259 /* Set pass local flag PLF on statement STMT to VAL_P.  */
1260
1261 static inline void
1262 gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
1263 {
1264   if (val_p)
1265     stmt->gsbase.plf |= (unsigned int) plf;
1266   else
1267     stmt->gsbase.plf &= ~((unsigned int) plf);
1268 }
1269
1270
1271 /* Return the value of pass local flag PLF on statement STMT.  */
1272
1273 static inline unsigned int
1274 gimple_plf (gimple stmt, enum plf_mask plf)
1275 {
1276   return stmt->gsbase.plf & ((unsigned int) plf);
1277 }
1278
1279
1280 /* Set the UID of statement.  */
1281
1282 static inline void
1283 gimple_set_uid (gimple g, unsigned uid)
1284 {
1285   g->gsbase.uid = uid;
1286 }
1287
1288
1289 /* Return the UID of statement.  */
1290
1291 static inline unsigned
1292 gimple_uid (const_gimple g)
1293 {
1294   return g->gsbase.uid;
1295 }
1296
1297
1298 /* Return true if GIMPLE statement G has register or memory operands.  */
1299
1300 static inline bool
1301 gimple_has_ops (const_gimple g)
1302 {
1303   return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
1304 }
1305
1306
1307 /* Return true if GIMPLE statement G has memory operands.  */
1308
1309 static inline bool
1310 gimple_has_mem_ops (const_gimple g)
1311 {
1312   return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
1313 }
1314
1315
1316 /* Return the set of DEF operands for statement G.  */
1317
1318 static inline struct def_optype_d *
1319 gimple_def_ops (const_gimple g)
1320 {
1321   if (!gimple_has_ops (g))
1322     return NULL;
1323   return g->gsops.opbase.def_ops;
1324 }
1325
1326
1327 /* Set DEF to be the set of DEF operands for statement G.  */
1328
1329 static inline void
1330 gimple_set_def_ops (gimple g, struct def_optype_d *def)
1331 {
1332   gcc_assert (gimple_has_ops (g));
1333   g->gsops.opbase.def_ops = def;
1334 }
1335
1336
1337 /* Return the set of USE operands for statement G.  */
1338
1339 static inline struct use_optype_d *
1340 gimple_use_ops (const_gimple g)
1341 {
1342   if (!gimple_has_ops (g))
1343     return NULL;
1344   return g->gsops.opbase.use_ops;
1345 }
1346
1347
1348 /* Set USE to be the set of USE operands for statement G.  */
1349
1350 static inline void
1351 gimple_set_use_ops (gimple g, struct use_optype_d *use)
1352 {
1353   gcc_assert (gimple_has_ops (g));
1354   g->gsops.opbase.use_ops = use;
1355 }
1356
1357
1358 /* Return the set of VUSE operand for statement G.  */
1359
1360 static inline use_operand_p
1361 gimple_vuse_op (const_gimple g)
1362 {
1363   struct use_optype_d *ops;
1364   if (!gimple_has_mem_ops (g))
1365     return NULL_USE_OPERAND_P;
1366   ops = g->gsops.opbase.use_ops;
1367   if (ops
1368       && USE_OP_PTR (ops)->use == &g->gsmembase.vuse)
1369     return USE_OP_PTR (ops);
1370   return NULL_USE_OPERAND_P;
1371 }
1372
1373 /* Return the set of VDEF operand for statement G.  */
1374
1375 static inline def_operand_p
1376 gimple_vdef_op (const_gimple g)
1377 {
1378   struct def_optype_d *ops;
1379   if (!gimple_has_mem_ops (g))
1380     return NULL_DEF_OPERAND_P;
1381   ops = g->gsops.opbase.def_ops;
1382   if (ops
1383       && DEF_OP_PTR (ops) == &g->gsmembase.vdef)
1384     return DEF_OP_PTR (ops);
1385   return NULL_DEF_OPERAND_P;
1386 }
1387
1388
1389 /* Return the single VUSE operand of the statement G.  */
1390
1391 static inline tree
1392 gimple_vuse (const_gimple g)
1393 {
1394   if (!gimple_has_mem_ops (g))
1395     return NULL_TREE;
1396   return g->gsmembase.vuse;
1397 }
1398
1399 /* Return the single VDEF operand of the statement G.  */
1400
1401 static inline tree
1402 gimple_vdef (const_gimple g)
1403 {
1404   if (!gimple_has_mem_ops (g))
1405     return NULL_TREE;
1406   return g->gsmembase.vdef;
1407 }
1408
1409 /* Return the single VUSE operand of the statement G.  */
1410
1411 static inline tree *
1412 gimple_vuse_ptr (gimple g)
1413 {
1414   if (!gimple_has_mem_ops (g))
1415     return NULL;
1416   return &g->gsmembase.vuse;
1417 }
1418
1419 /* Return the single VDEF operand of the statement G.  */
1420
1421 static inline tree *
1422 gimple_vdef_ptr (gimple g)
1423 {
1424   if (!gimple_has_mem_ops (g))
1425     return NULL;
1426   return &g->gsmembase.vdef;
1427 }
1428
1429 /* Set the single VUSE operand of the statement G.  */
1430
1431 static inline void
1432 gimple_set_vuse (gimple g, tree vuse)
1433 {
1434   gcc_assert (gimple_has_mem_ops (g));
1435   g->gsmembase.vuse = vuse;
1436 }
1437
1438 /* Set the single VDEF operand of the statement G.  */
1439
1440 static inline void
1441 gimple_set_vdef (gimple g, tree vdef)
1442 {
1443   gcc_assert (gimple_has_mem_ops (g));
1444   g->gsmembase.vdef = vdef;
1445 }
1446
1447
1448 /* Return true if statement G has operands and the modified field has
1449    been set.  */
1450
1451 static inline bool
1452 gimple_modified_p (const_gimple g)
1453 {
1454   return (gimple_has_ops (g)) ? (bool) g->gsbase.modified : false;
1455 }
1456
1457
1458 /* Return the tree code for the expression computed by STMT.  This is
1459    only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN.  For
1460    GIMPLE_CALL, return CALL_EXPR as the expression code for
1461    consistency.  This is useful when the caller needs to deal with the
1462    three kinds of computation that GIMPLE supports.  */
1463
1464 static inline enum tree_code
1465 gimple_expr_code (const_gimple stmt)
1466 {
1467   enum gimple_code code = gimple_code (stmt);
1468   if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
1469     return (enum tree_code) stmt->gsbase.subcode;
1470   else if (code == GIMPLE_CALL)
1471     return CALL_EXPR;
1472   else
1473     gcc_unreachable ();
1474 }
1475
1476
1477 /* Mark statement S as modified, and update it.  */
1478
1479 static inline void
1480 update_stmt (gimple s)
1481 {
1482   if (gimple_has_ops (s))
1483     {
1484       gimple_set_modified (s, true);
1485       update_stmt_operands (s);
1486     }
1487 }
1488
1489 /* Update statement S if it has been optimized.  */
1490
1491 static inline void
1492 update_stmt_if_modified (gimple s)
1493 {
1494   if (gimple_modified_p (s))
1495     update_stmt_operands (s);
1496 }
1497
1498 /* Return true if statement STMT contains volatile operands.  */
1499
1500 static inline bool
1501 gimple_has_volatile_ops (const_gimple stmt)
1502 {
1503   if (gimple_has_mem_ops (stmt))
1504     return stmt->gsbase.has_volatile_ops;
1505   else
1506     return false;
1507 }
1508
1509
1510 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP.  */
1511
1512 static inline void
1513 gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
1514 {
1515   if (gimple_has_mem_ops (stmt))
1516     stmt->gsbase.has_volatile_ops = (unsigned) volatilep;
1517 }
1518
1519
1520 /* Return true if statement STMT may access memory.  */
1521
1522 static inline bool
1523 gimple_references_memory_p (gimple stmt)
1524 {
1525   return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
1526 }
1527
1528
1529 /* Return the subcode for OMP statement S.  */
1530
1531 static inline unsigned
1532 gimple_omp_subcode (const_gimple s)
1533 {
1534   gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
1535               && gimple_code (s) <= GIMPLE_OMP_SINGLE);
1536   return s->gsbase.subcode;
1537 }
1538
1539 /* Set the subcode for OMP statement S to SUBCODE.  */
1540
1541 static inline void
1542 gimple_omp_set_subcode (gimple s, unsigned int subcode)
1543 {
1544   /* We only have 16 bits for the subcode.  Assert that we are not
1545      overflowing it.  */
1546   gcc_assert (subcode < (1 << 16));
1547   s->gsbase.subcode = subcode;
1548 }
1549
1550 /* Set the nowait flag on OMP_RETURN statement S.  */
1551
1552 static inline void
1553 gimple_omp_return_set_nowait (gimple s)
1554 {
1555   GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
1556   s->gsbase.subcode |= GF_OMP_RETURN_NOWAIT;
1557 }
1558
1559
1560 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
1561    flag set.  */
1562
1563 static inline bool
1564 gimple_omp_return_nowait_p (const_gimple g)
1565 {
1566   GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
1567   return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
1568 }
1569
1570
1571 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
1572    flag set.  */
1573
1574 static inline bool
1575 gimple_omp_section_last_p (const_gimple g)
1576 {
1577   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
1578   return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
1579 }
1580
1581
1582 /* Set the GF_OMP_SECTION_LAST flag on G.  */
1583
1584 static inline void
1585 gimple_omp_section_set_last (gimple g)
1586 {
1587   GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
1588   g->gsbase.subcode |= GF_OMP_SECTION_LAST;
1589 }
1590
1591
1592 /* Return true if OMP parallel statement G has the
1593    GF_OMP_PARALLEL_COMBINED flag set.  */
1594
1595 static inline bool
1596 gimple_omp_parallel_combined_p (const_gimple g)
1597 {
1598   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
1599   return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
1600 }
1601
1602
1603 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
1604    value of COMBINED_P.  */
1605
1606 static inline void
1607 gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
1608 {
1609   GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
1610   if (combined_p)
1611     g->gsbase.subcode |= GF_OMP_PARALLEL_COMBINED;
1612   else
1613     g->gsbase.subcode &= ~GF_OMP_PARALLEL_COMBINED;
1614 }
1615
1616
1617 /* Return the number of operands for statement GS.  */
1618
1619 static inline unsigned
1620 gimple_num_ops (const_gimple gs)
1621 {
1622   return gs->gsbase.num_ops;
1623 }
1624
1625
1626 /* Set the number of operands for statement GS.  */
1627
1628 static inline void
1629 gimple_set_num_ops (gimple gs, unsigned num_ops)
1630 {
1631   gs->gsbase.num_ops = num_ops;
1632 }
1633
1634
1635 /* Return the array of operands for statement GS.  */
1636
1637 static inline tree *
1638 gimple_ops (gimple gs)
1639 {
1640   size_t off;
1641
1642   /* All the tuples have their operand vector at the very bottom
1643      of the structure.  Note that those structures that do not
1644      have an operand vector have a zero offset.  */
1645   off = gimple_ops_offset_[gimple_statement_structure (gs)];
1646   gcc_assert (off != 0);
1647
1648   return (tree *) ((char *) gs + off);
1649 }
1650
1651
1652 /* Return operand I for statement GS.  */
1653
1654 static inline tree
1655 gimple_op (const_gimple gs, unsigned i)
1656 {
1657   if (gimple_has_ops (gs))
1658     {
1659 #ifdef ENABLE_CHECKING
1660       gcc_assert (i < gimple_num_ops (gs));
1661 #endif
1662       return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
1663     }
1664   else
1665     return NULL_TREE;
1666 }
1667
1668 /* Return a pointer to operand I for statement GS.  */
1669
1670 static inline tree *
1671 gimple_op_ptr (const_gimple gs, unsigned i)
1672 {
1673   if (gimple_has_ops (gs))
1674     {
1675 #ifdef ENABLE_CHECKING
1676       gcc_assert (i < gimple_num_ops (gs));
1677 #endif
1678       return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
1679     }
1680   else
1681     return NULL;
1682 }
1683
1684 /* Set operand I of statement GS to OP.  */
1685
1686 static inline void
1687 gimple_set_op (gimple gs, unsigned i, tree op)
1688 {
1689   gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
1690
1691   /* Note.  It may be tempting to assert that OP matches
1692      is_gimple_operand, but that would be wrong.  Different tuples
1693      accept slightly different sets of tree operands.  Each caller
1694      should perform its own validation.  */
1695   gimple_ops (gs)[i] = op;
1696 }
1697
1698 /* Return true if GS is a GIMPLE_ASSIGN.  */
1699
1700 static inline bool
1701 is_gimple_assign (const_gimple gs)
1702 {
1703   return gimple_code (gs) == GIMPLE_ASSIGN;
1704 }
1705
1706 /* Determine if expression CODE is one of the valid expressions that can
1707    be used on the RHS of GIMPLE assignments.  */
1708
1709 static inline enum gimple_rhs_class
1710 get_gimple_rhs_class (enum tree_code code)
1711 {
1712   return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
1713 }
1714
1715 /* Return the LHS of assignment statement GS.  */
1716
1717 static inline tree
1718 gimple_assign_lhs (const_gimple gs)
1719 {
1720   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1721   return gimple_op (gs, 0);
1722 }
1723
1724
1725 /* Return a pointer to the LHS of assignment statement GS.  */
1726
1727 static inline tree *
1728 gimple_assign_lhs_ptr (const_gimple gs)
1729 {
1730   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1731   return gimple_op_ptr (gs, 0);
1732 }
1733
1734
1735 /* Set LHS to be the LHS operand of assignment statement GS.  */
1736
1737 static inline void
1738 gimple_assign_set_lhs (gimple gs, tree lhs)
1739 {
1740   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1741   gimple_set_op (gs, 0, lhs);
1742
1743   if (lhs && TREE_CODE (lhs) == SSA_NAME)
1744     SSA_NAME_DEF_STMT (lhs) = gs;
1745 }
1746
1747
1748 /* Return the first operand on the RHS of assignment statement GS.  */
1749
1750 static inline tree
1751 gimple_assign_rhs1 (const_gimple gs)
1752 {
1753   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1754   return gimple_op (gs, 1);
1755 }
1756
1757
1758 /* Return a pointer to the first operand on the RHS of assignment
1759    statement GS.  */
1760
1761 static inline tree *
1762 gimple_assign_rhs1_ptr (const_gimple gs)
1763 {
1764   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1765   return gimple_op_ptr (gs, 1);
1766 }
1767
1768 /* Set RHS to be the first operand on the RHS of assignment statement GS.  */
1769
1770 static inline void
1771 gimple_assign_set_rhs1 (gimple gs, tree rhs)
1772 {
1773   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1774
1775   gimple_set_op (gs, 1, rhs);
1776 }
1777
1778
1779 /* Return the second operand on the RHS of assignment statement GS.
1780    If GS does not have two operands, NULL is returned instead.  */
1781
1782 static inline tree
1783 gimple_assign_rhs2 (const_gimple gs)
1784 {
1785   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1786
1787   if (gimple_num_ops (gs) >= 3)
1788     return gimple_op (gs, 2);
1789   else
1790     return NULL_TREE;
1791 }
1792
1793
1794 /* Return a pointer to the second operand on the RHS of assignment
1795    statement GS.  */
1796
1797 static inline tree *
1798 gimple_assign_rhs2_ptr (const_gimple gs)
1799 {
1800   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1801   return gimple_op_ptr (gs, 2);
1802 }
1803
1804
1805 /* Set RHS to be the second operand on the RHS of assignment statement GS.  */
1806
1807 static inline void
1808 gimple_assign_set_rhs2 (gimple gs, tree rhs)
1809 {
1810   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1811
1812   gimple_set_op (gs, 2, rhs);
1813 }
1814
1815 /* Returns true if GS is a nontemporal move.  */
1816
1817 static inline bool
1818 gimple_assign_nontemporal_move_p (const_gimple gs)
1819 {
1820   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1821   return gs->gsbase.nontemporal_move;
1822 }
1823
1824 /* Sets nontemporal move flag of GS to NONTEMPORAL.  */
1825
1826 static inline void
1827 gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
1828 {
1829   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1830   gs->gsbase.nontemporal_move = nontemporal;
1831 }
1832
1833
1834 /* Return the code of the expression computed on the rhs of assignment
1835    statement GS.  In case that the RHS is a single object, returns the
1836    tree code of the object.  */
1837
1838 static inline enum tree_code
1839 gimple_assign_rhs_code (const_gimple gs)
1840 {
1841   enum tree_code code;
1842   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1843
1844   code = gimple_expr_code (gs);
1845   if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
1846     code = TREE_CODE (gimple_assign_rhs1 (gs));
1847
1848   return code;
1849 }
1850
1851
1852 /* Set CODE to be the code for the expression computed on the RHS of
1853    assignment S.  */
1854
1855 static inline void
1856 gimple_assign_set_rhs_code (gimple s, enum tree_code code)
1857 {
1858   GIMPLE_CHECK (s, GIMPLE_ASSIGN);
1859   s->gsbase.subcode = code;
1860 }
1861
1862
1863 /* Return the gimple rhs class of the code of the expression computed on
1864    the rhs of assignment statement GS.
1865    This will never return GIMPLE_INVALID_RHS.  */
1866
1867 static inline enum gimple_rhs_class
1868 gimple_assign_rhs_class (const_gimple gs)
1869 {
1870   return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
1871 }
1872
1873
1874 /* Return true if S is a type-cast assignment.  */
1875
1876 static inline bool
1877 gimple_assign_cast_p (gimple s)
1878 {
1879   if (is_gimple_assign (s))
1880     {
1881       enum tree_code sc = gimple_assign_rhs_code (s);
1882       return CONVERT_EXPR_CODE_P (sc)
1883              || sc == VIEW_CONVERT_EXPR
1884              || sc == FIX_TRUNC_EXPR;
1885     }
1886
1887   return false;
1888 }
1889
1890
1891 /* Return true if GS is a GIMPLE_CALL.  */
1892
1893 static inline bool
1894 is_gimple_call (const_gimple gs)
1895 {
1896   return gimple_code (gs) == GIMPLE_CALL;
1897 }
1898
1899 /* Return the LHS of call statement GS.  */
1900
1901 static inline tree
1902 gimple_call_lhs (const_gimple gs)
1903 {
1904   GIMPLE_CHECK (gs, GIMPLE_CALL);
1905   return gimple_op (gs, 0);
1906 }
1907
1908
1909 /* Return a pointer to the LHS of call statement GS.  */
1910
1911 static inline tree *
1912 gimple_call_lhs_ptr (const_gimple gs)
1913 {
1914   GIMPLE_CHECK (gs, GIMPLE_CALL);
1915   return gimple_op_ptr (gs, 0);
1916 }
1917
1918
1919 /* Set LHS to be the LHS operand of call statement GS.  */
1920
1921 static inline void
1922 gimple_call_set_lhs (gimple gs, tree lhs)
1923 {
1924   GIMPLE_CHECK (gs, GIMPLE_CALL);
1925   gimple_set_op (gs, 0, lhs);
1926   if (lhs && TREE_CODE (lhs) == SSA_NAME)
1927     SSA_NAME_DEF_STMT (lhs) = gs;
1928 }
1929
1930
1931 /* Return the tree node representing the function called by call
1932    statement GS.  */
1933
1934 static inline tree
1935 gimple_call_fn (const_gimple gs)
1936 {
1937   GIMPLE_CHECK (gs, GIMPLE_CALL);
1938   return gimple_op (gs, 1);
1939 }
1940
1941
1942 /* Return a pointer to the tree node representing the function called by call
1943    statement GS.  */
1944
1945 static inline tree *
1946 gimple_call_fn_ptr (const_gimple gs)
1947 {
1948   GIMPLE_CHECK (gs, GIMPLE_CALL);
1949   return gimple_op_ptr (gs, 1);
1950 }
1951
1952
1953 /* Set FN to be the function called by call statement GS.  */
1954
1955 static inline void
1956 gimple_call_set_fn (gimple gs, tree fn)
1957 {
1958   GIMPLE_CHECK (gs, GIMPLE_CALL);
1959   gimple_set_op (gs, 1, fn);
1960 }
1961
1962
1963 /* Set FNDECL to be the function called by call statement GS.  */
1964
1965 static inline void
1966 gimple_call_set_fndecl (gimple gs, tree decl)
1967 {
1968   GIMPLE_CHECK (gs, GIMPLE_CALL);
1969   gimple_set_op (gs, 1, build_fold_addr_expr_loc (gimple_location (gs), decl));
1970 }
1971
1972
1973 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
1974    Otherwise return NULL.  This function is analogous to
1975    get_callee_fndecl in tree land.  */
1976
1977 static inline tree
1978 gimple_call_fndecl (const_gimple gs)
1979 {
1980   tree addr = gimple_call_fn (gs);
1981   if (TREE_CODE (addr) == ADDR_EXPR)
1982     return TREE_OPERAND (addr, 0);
1983   return NULL_TREE;
1984 }
1985
1986
1987 /* Return the type returned by call statement GS.  */
1988
1989 static inline tree
1990 gimple_call_return_type (const_gimple gs)
1991 {
1992   tree fn = gimple_call_fn (gs);
1993   tree type = TREE_TYPE (fn);
1994
1995   /* See through the pointer.  */
1996   type = TREE_TYPE (type);
1997
1998   /* The type returned by a FUNCTION_DECL is the type of its
1999      function type.  */
2000   return TREE_TYPE (type);
2001 }
2002
2003
2004 /* Return the static chain for call statement GS.  */
2005
2006 static inline tree
2007 gimple_call_chain (const_gimple gs)
2008 {
2009   GIMPLE_CHECK (gs, GIMPLE_CALL);
2010   return gimple_op (gs, 2);
2011 }
2012
2013
2014 /* Return a pointer to the static chain for call statement GS.  */
2015
2016 static inline tree *
2017 gimple_call_chain_ptr (const_gimple gs)
2018 {
2019   GIMPLE_CHECK (gs, GIMPLE_CALL);
2020   return gimple_op_ptr (gs, 2);
2021 }
2022
2023 /* Set CHAIN to be the static chain for call statement GS.  */
2024
2025 static inline void
2026 gimple_call_set_chain (gimple gs, tree chain)
2027 {
2028   GIMPLE_CHECK (gs, GIMPLE_CALL);
2029
2030   gimple_set_op (gs, 2, chain);
2031 }
2032
2033
2034 /* Return the number of arguments used by call statement GS.  */
2035
2036 static inline unsigned
2037 gimple_call_num_args (const_gimple gs)
2038 {
2039   unsigned num_ops;
2040   GIMPLE_CHECK (gs, GIMPLE_CALL);
2041   num_ops = gimple_num_ops (gs);
2042   return num_ops - 3;
2043 }
2044
2045
2046 /* Return the argument at position INDEX for call statement GS.  */
2047
2048 static inline tree
2049 gimple_call_arg (const_gimple gs, unsigned index)
2050 {
2051   GIMPLE_CHECK (gs, GIMPLE_CALL);
2052   return gimple_op (gs, index + 3);
2053 }
2054
2055
2056 /* Return a pointer to the argument at position INDEX for call
2057    statement GS.  */
2058
2059 static inline tree *
2060 gimple_call_arg_ptr (const_gimple gs, unsigned index)
2061 {
2062   GIMPLE_CHECK (gs, GIMPLE_CALL);
2063   return gimple_op_ptr (gs, index + 3);
2064 }
2065
2066
2067 /* Set ARG to be the argument at position INDEX for call statement GS.  */
2068
2069 static inline void
2070 gimple_call_set_arg (gimple gs, unsigned index, tree arg)
2071 {
2072   GIMPLE_CHECK (gs, GIMPLE_CALL);
2073   gimple_set_op (gs, index + 3, arg);
2074 }
2075
2076
2077 /* If TAIL_P is true, mark call statement S as being a tail call
2078    (i.e., a call just before the exit of a function).  These calls are
2079    candidate for tail call optimization.  */
2080
2081 static inline void
2082 gimple_call_set_tail (gimple s, bool tail_p)
2083 {
2084   GIMPLE_CHECK (s, GIMPLE_CALL);
2085   if (tail_p)
2086     s->gsbase.subcode |= GF_CALL_TAILCALL;
2087   else
2088     s->gsbase.subcode &= ~GF_CALL_TAILCALL;
2089 }
2090
2091
2092 /* Return true if GIMPLE_CALL S is marked as a tail call.  */
2093
2094 static inline bool
2095 gimple_call_tail_p (gimple s)
2096 {
2097   GIMPLE_CHECK (s, GIMPLE_CALL);
2098   return (s->gsbase.subcode & GF_CALL_TAILCALL) != 0;
2099 }
2100
2101
2102 /* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P.  */
2103
2104 static inline void
2105 gimple_call_set_cannot_inline (gimple s, bool inlinable_p)
2106 {
2107   GIMPLE_CHECK (s, GIMPLE_CALL);
2108   if (inlinable_p)
2109     s->gsbase.subcode |= GF_CALL_CANNOT_INLINE;
2110   else
2111     s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE;
2112 }
2113
2114
2115 /* Return true if GIMPLE_CALL S cannot be inlined.  */
2116
2117 static inline bool
2118 gimple_call_cannot_inline_p (gimple s)
2119 {
2120   GIMPLE_CHECK (s, GIMPLE_CALL);
2121   return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 0;
2122 }
2123
2124
2125 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
2126    slot optimization.  This transformation uses the target of the call
2127    expansion as the return slot for calls that return in memory.  */
2128
2129 static inline void
2130 gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
2131 {
2132   GIMPLE_CHECK (s, GIMPLE_CALL);
2133   if (return_slot_opt_p)
2134     s->gsbase.subcode |= GF_CALL_RETURN_SLOT_OPT;
2135   else
2136     s->gsbase.subcode &= ~GF_CALL_RETURN_SLOT_OPT;
2137 }
2138
2139
2140 /* Return true if S is marked for return slot optimization.  */
2141
2142 static inline bool
2143 gimple_call_return_slot_opt_p (gimple s)
2144 {
2145   GIMPLE_CHECK (s, GIMPLE_CALL);
2146   return (s->gsbase.subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
2147 }
2148
2149
2150 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
2151    thunk to the thunked-to function.  */
2152
2153 static inline void
2154 gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
2155 {
2156   GIMPLE_CHECK (s, GIMPLE_CALL);
2157   if (from_thunk_p)
2158     s->gsbase.subcode |= GF_CALL_FROM_THUNK;
2159   else
2160     s->gsbase.subcode &= ~GF_CALL_FROM_THUNK;
2161 }
2162
2163
2164 /* Return true if GIMPLE_CALL S is a jump from a thunk.  */
2165
2166 static inline bool
2167 gimple_call_from_thunk_p (gimple s)
2168 {
2169   GIMPLE_CHECK (s, GIMPLE_CALL);
2170   return (s->gsbase.subcode & GF_CALL_FROM_THUNK) != 0;
2171 }
2172
2173
2174 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
2175    argument pack in its argument list.  */
2176
2177 static inline void
2178 gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
2179 {
2180   GIMPLE_CHECK (s, GIMPLE_CALL);
2181   if (pass_arg_pack_p)
2182     s->gsbase.subcode |= GF_CALL_VA_ARG_PACK;
2183   else
2184     s->gsbase.subcode &= ~GF_CALL_VA_ARG_PACK;
2185 }
2186
2187
2188 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
2189    argument pack in its argument list.  */
2190
2191 static inline bool
2192 gimple_call_va_arg_pack_p (gimple s)
2193 {
2194   GIMPLE_CHECK (s, GIMPLE_CALL);
2195   return (s->gsbase.subcode & GF_CALL_VA_ARG_PACK) != 0;
2196 }
2197
2198
2199 /* Return true if S is a noreturn call.  */
2200
2201 static inline bool
2202 gimple_call_noreturn_p (gimple s)
2203 {
2204   GIMPLE_CHECK (s, GIMPLE_CALL);
2205   return (gimple_call_flags (s) & ECF_NORETURN) != 0;
2206 }
2207
2208
2209 /* Return true if S is a nothrow call.  */
2210
2211 static inline bool
2212 gimple_call_nothrow_p (gimple s)
2213 {
2214   GIMPLE_CHECK (s, GIMPLE_CALL);
2215   return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
2216 }
2217
2218
2219 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.  */
2220
2221 static inline void
2222 gimple_call_copy_flags (gimple dest_call, gimple orig_call)
2223 {
2224   GIMPLE_CHECK (dest_call, GIMPLE_CALL);
2225   GIMPLE_CHECK (orig_call, GIMPLE_CALL);
2226   dest_call->gsbase.subcode = orig_call->gsbase.subcode;
2227 }
2228
2229
2230 /* Return a pointer to the points-to solution for the set of call-used
2231    variables of the call CALL.  */
2232
2233 static inline struct pt_solution *
2234 gimple_call_use_set (gimple call)
2235 {
2236   GIMPLE_CHECK (call, GIMPLE_CALL);
2237   return &call->gimple_call.call_used;
2238 }
2239
2240
2241 /* Return a pointer to the points-to solution for the set of call-used
2242    variables of the call CALL.  */
2243
2244 static inline struct pt_solution *
2245 gimple_call_clobber_set (gimple call)
2246 {
2247   GIMPLE_CHECK (call, GIMPLE_CALL);
2248   return &call->gimple_call.call_clobbered;
2249 }
2250
2251
2252 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
2253    non-NULL lhs.  */
2254
2255 static inline bool
2256 gimple_has_lhs (gimple stmt)
2257 {
2258   return (is_gimple_assign (stmt)
2259           || (is_gimple_call (stmt)
2260               && gimple_call_lhs (stmt) != NULL_TREE));
2261 }
2262
2263
2264 /* Return the code of the predicate computed by conditional statement GS.  */
2265
2266 static inline enum tree_code
2267 gimple_cond_code (const_gimple gs)
2268 {
2269   GIMPLE_CHECK (gs, GIMPLE_COND);
2270   return (enum tree_code) gs->gsbase.subcode;
2271 }
2272
2273
2274 /* Set CODE to be the predicate code for the conditional statement GS.  */
2275
2276 static inline void
2277 gimple_cond_set_code (gimple gs, enum tree_code code)
2278 {
2279   GIMPLE_CHECK (gs, GIMPLE_COND);
2280   gs->gsbase.subcode = code;
2281 }
2282
2283
2284 /* Return the LHS of the predicate computed by conditional statement GS.  */
2285
2286 static inline tree
2287 gimple_cond_lhs (const_gimple gs)
2288 {
2289   GIMPLE_CHECK (gs, GIMPLE_COND);
2290   return gimple_op (gs, 0);
2291 }
2292
2293 /* Return the pointer to the LHS of the predicate computed by conditional
2294    statement GS.  */
2295
2296 static inline tree *
2297 gimple_cond_lhs_ptr (const_gimple gs)
2298 {
2299   GIMPLE_CHECK (gs, GIMPLE_COND);
2300   return gimple_op_ptr (gs, 0);
2301 }
2302
2303 /* Set LHS to be the LHS operand of the predicate computed by
2304    conditional statement GS.  */
2305
2306 static inline void
2307 gimple_cond_set_lhs (gimple gs, tree lhs)
2308 {
2309   GIMPLE_CHECK (gs, GIMPLE_COND);
2310   gimple_set_op (gs, 0, lhs);
2311 }
2312
2313
2314 /* Return the RHS operand of the predicate computed by conditional GS.  */
2315
2316 static inline tree
2317 gimple_cond_rhs (const_gimple gs)
2318 {
2319   GIMPLE_CHECK (gs, GIMPLE_COND);
2320   return gimple_op (gs, 1);
2321 }
2322
2323 /* Return the pointer to the RHS operand of the predicate computed by
2324    conditional GS.  */
2325
2326 static inline tree *
2327 gimple_cond_rhs_ptr (const_gimple gs)
2328 {
2329   GIMPLE_CHECK (gs, GIMPLE_COND);
2330   return gimple_op_ptr (gs, 1);
2331 }
2332
2333
2334 /* Set RHS to be the RHS operand of the predicate computed by
2335    conditional statement GS.  */
2336
2337 static inline void
2338 gimple_cond_set_rhs (gimple gs, tree rhs)
2339 {
2340   GIMPLE_CHECK (gs, GIMPLE_COND);
2341   gimple_set_op (gs, 1, rhs);
2342 }
2343
2344
2345 /* Return the label used by conditional statement GS when its
2346    predicate evaluates to true.  */
2347
2348 static inline tree
2349 gimple_cond_true_label (const_gimple gs)
2350 {
2351   GIMPLE_CHECK (gs, GIMPLE_COND);
2352   return gimple_op (gs, 2);
2353 }
2354
2355
2356 /* Set LABEL to be the label used by conditional statement GS when its
2357    predicate evaluates to true.  */
2358
2359 static inline void
2360 gimple_cond_set_true_label (gimple gs, tree label)
2361 {
2362   GIMPLE_CHECK (gs, GIMPLE_COND);
2363   gimple_set_op (gs, 2, label);
2364 }
2365
2366
2367 /* Set LABEL to be the label used by conditional statement GS when its
2368    predicate evaluates to false.  */
2369
2370 static inline void
2371 gimple_cond_set_false_label (gimple gs, tree label)
2372 {
2373   GIMPLE_CHECK (gs, GIMPLE_COND);
2374   gimple_set_op (gs, 3, label);
2375 }
2376
2377
2378 /* Return the label used by conditional statement GS when its
2379    predicate evaluates to false.  */
2380
2381 static inline tree
2382 gimple_cond_false_label (const_gimple gs)
2383 {
2384   GIMPLE_CHECK (gs, GIMPLE_COND);
2385   return gimple_op (gs, 3);
2386 }
2387
2388
2389 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'.  */
2390
2391 static inline void
2392 gimple_cond_make_false (gimple gs)
2393 {
2394   gimple_cond_set_lhs (gs, boolean_true_node);
2395   gimple_cond_set_rhs (gs, boolean_false_node);
2396   gs->gsbase.subcode = EQ_EXPR;
2397 }
2398
2399
2400 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'.  */
2401
2402 static inline void
2403 gimple_cond_make_true (gimple gs)
2404 {
2405   gimple_cond_set_lhs (gs, boolean_true_node);
2406   gimple_cond_set_rhs (gs, boolean_true_node);
2407   gs->gsbase.subcode = EQ_EXPR;
2408 }
2409
2410 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
2411   'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
2412
2413 static inline bool
2414 gimple_cond_true_p (const_gimple gs)
2415 {
2416   tree lhs = gimple_cond_lhs (gs);
2417   tree rhs = gimple_cond_rhs (gs);
2418   enum tree_code code = gimple_cond_code (gs);
2419
2420   if (lhs != boolean_true_node && lhs != boolean_false_node)
2421     return false;
2422
2423   if (rhs != boolean_true_node && rhs != boolean_false_node)
2424     return false;
2425
2426   if (code == NE_EXPR && lhs != rhs)
2427     return true;
2428
2429   if (code == EQ_EXPR && lhs == rhs)
2430       return true;
2431
2432   return false;
2433 }
2434
2435 /* Check if conditional statement GS is of the form 'if (1 != 1)',
2436    'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
2437
2438 static inline bool
2439 gimple_cond_false_p (const_gimple gs)
2440 {
2441   tree lhs = gimple_cond_lhs (gs);
2442   tree rhs = gimple_cond_rhs (gs);
2443   enum tree_code code = gimple_cond_code (gs);
2444
2445   if (lhs != boolean_true_node && lhs != boolean_false_node)
2446     return false;
2447
2448   if (rhs != boolean_true_node && rhs != boolean_false_node)
2449     return false;
2450
2451   if (code == NE_EXPR && lhs == rhs)
2452     return true;
2453
2454   if (code == EQ_EXPR && lhs != rhs)
2455       return true;
2456
2457   return false;
2458 }
2459
2460 /* Check if conditional statement GS is of the form 'if (var != 0)' or
2461    'if (var == 1)' */
2462
2463 static inline bool
2464 gimple_cond_single_var_p (gimple gs)
2465 {
2466   if (gimple_cond_code (gs) == NE_EXPR
2467       && gimple_cond_rhs (gs) == boolean_false_node)
2468     return true;
2469
2470   if (gimple_cond_code (gs) == EQ_EXPR
2471       && gimple_cond_rhs (gs) == boolean_true_node)
2472     return true;
2473
2474   return false;
2475 }
2476
2477 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.  */
2478
2479 static inline void
2480 gimple_cond_set_condition (gimple stmt, enum tree_code code, tree lhs, tree rhs)
2481 {
2482   gimple_cond_set_code (stmt, code);
2483   gimple_cond_set_lhs (stmt, lhs);
2484   gimple_cond_set_rhs (stmt, rhs);
2485 }
2486
2487 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS.  */
2488
2489 static inline tree
2490 gimple_label_label (const_gimple gs)
2491 {
2492   GIMPLE_CHECK (gs, GIMPLE_LABEL);
2493   return gimple_op (gs, 0);
2494 }
2495
2496
2497 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
2498    GS.  */
2499
2500 static inline void
2501 gimple_label_set_label (gimple gs, tree label)
2502 {
2503   GIMPLE_CHECK (gs, GIMPLE_LABEL);
2504   gimple_set_op (gs, 0, label);
2505 }
2506
2507
2508 /* Return the destination of the unconditional jump GS.  */
2509
2510 static inline tree
2511 gimple_goto_dest (const_gimple gs)
2512 {
2513   GIMPLE_CHECK (gs, GIMPLE_GOTO);
2514   return gimple_op (gs, 0);
2515 }
2516
2517
2518 /* Set DEST to be the destination of the unconditonal jump GS.  */
2519
2520 static inline void
2521 gimple_goto_set_dest (gimple gs, tree dest)
2522 {
2523   GIMPLE_CHECK (gs, GIMPLE_GOTO);
2524   gimple_set_op (gs, 0, dest);
2525 }
2526
2527
2528 /* Return the variables declared in the GIMPLE_BIND statement GS.  */
2529
2530 static inline tree
2531 gimple_bind_vars (const_gimple gs)
2532 {
2533   GIMPLE_CHECK (gs, GIMPLE_BIND);
2534   return gs->gimple_bind.vars;
2535 }
2536
2537
2538 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
2539    statement GS.  */
2540
2541 static inline void
2542 gimple_bind_set_vars (gimple gs, tree vars)
2543 {
2544   GIMPLE_CHECK (gs, GIMPLE_BIND);
2545   gs->gimple_bind.vars = vars;
2546 }
2547
2548
2549 /* Append VARS to the set of variables declared in the GIMPLE_BIND
2550    statement GS.  */
2551
2552 static inline void
2553 gimple_bind_append_vars (gimple gs, tree vars)
2554 {
2555   GIMPLE_CHECK (gs, GIMPLE_BIND);
2556   gs->gimple_bind.vars = chainon (gs->gimple_bind.vars, vars);
2557 }
2558
2559
2560 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.  */
2561
2562 static inline gimple_seq
2563 gimple_bind_body (gimple gs)
2564 {
2565   GIMPLE_CHECK (gs, GIMPLE_BIND);
2566   return gs->gimple_bind.body;
2567 }
2568
2569
2570 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
2571    statement GS.  */
2572
2573 static inline void
2574 gimple_bind_set_body (gimple gs, gimple_seq seq)
2575 {
2576   GIMPLE_CHECK (gs, GIMPLE_BIND);
2577   gs->gimple_bind.body = seq;
2578 }
2579
2580
2581 /* Append a statement to the end of a GIMPLE_BIND's body.  */
2582
2583 static inline void
2584 gimple_bind_add_stmt (gimple gs, gimple stmt)
2585 {
2586   GIMPLE_CHECK (gs, GIMPLE_BIND);
2587   gimple_seq_add_stmt (&gs->gimple_bind.body, stmt);
2588 }
2589
2590
2591 /* Append a sequence of statements to the end of a GIMPLE_BIND's body.  */
2592
2593 static inline void
2594 gimple_bind_add_seq (gimple gs, gimple_seq seq)
2595 {
2596   GIMPLE_CHECK (gs, GIMPLE_BIND);
2597   gimple_seq_add_seq (&gs->gimple_bind.body, seq);
2598 }
2599
2600
2601 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
2602    GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.  */
2603
2604 static inline tree
2605 gimple_bind_block (const_gimple gs)
2606 {
2607   GIMPLE_CHECK (gs, GIMPLE_BIND);
2608   return gs->gimple_bind.block;
2609 }
2610
2611
2612 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
2613    statement GS.  */
2614
2615 static inline void
2616 gimple_bind_set_block (gimple gs, tree block)
2617 {
2618   GIMPLE_CHECK (gs, GIMPLE_BIND);
2619   gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK);
2620   gs->gimple_bind.block = block;
2621 }
2622
2623
2624 /* Return the number of input operands for GIMPLE_ASM GS.  */
2625
2626 static inline unsigned
2627 gimple_asm_ninputs (const_gimple gs)
2628 {
2629   GIMPLE_CHECK (gs, GIMPLE_ASM);
2630   return gs->gimple_asm.ni;
2631 }
2632
2633
2634 /* Return the number of output operands for GIMPLE_ASM GS.  */
2635
2636 static inline unsigned
2637 gimple_asm_noutputs (const_gimple gs)
2638 {
2639   GIMPLE_CHECK (gs, GIMPLE_ASM);
2640   return gs->gimple_asm.no;
2641 }
2642
2643
2644 /* Return the number of clobber operands for GIMPLE_ASM GS.  */
2645
2646 static inline unsigned
2647 gimple_asm_nclobbers (const_gimple gs)
2648 {
2649   GIMPLE_CHECK (gs, GIMPLE_ASM);
2650   return gs->gimple_asm.nc;
2651 }
2652
2653 /* Return the number of label operands for GIMPLE_ASM GS.  */
2654
2655 static inline unsigned
2656 gimple_asm_nlabels (const_gimple gs)
2657 {
2658   GIMPLE_CHECK (gs, GIMPLE_ASM);
2659   return gs->gimple_asm.nl;
2660 }
2661
2662 /* Return input operand INDEX of GIMPLE_ASM GS.  */
2663
2664 static inline tree
2665 gimple_asm_input_op (const_gimple gs, unsigned index)
2666 {
2667   GIMPLE_CHECK (gs, GIMPLE_ASM);
2668   gcc_assert (index <= gs->gimple_asm.ni);
2669   return gimple_op (gs, index);
2670 }
2671
2672 /* Return a pointer to input operand INDEX of GIMPLE_ASM GS.  */
2673
2674 static inline tree *
2675 gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
2676 {
2677   GIMPLE_CHECK (gs, GIMPLE_ASM);
2678   gcc_assert (index <= gs->gimple_asm.ni);
2679   return gimple_op_ptr (gs, index);
2680 }
2681
2682
2683 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS.  */
2684
2685 static inline void
2686 gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
2687 {
2688   GIMPLE_CHECK (gs, GIMPLE_ASM);
2689   gcc_assert (index <= gs->gimple_asm.ni);
2690   gcc_assert (TREE_CODE (in_op) == TREE_LIST);
2691   gimple_set_op (gs, index, in_op);
2692 }
2693
2694
2695 /* Return output operand INDEX of GIMPLE_ASM GS.  */
2696
2697 static inline tree
2698 gimple_asm_output_op (const_gimple gs, unsigned index)
2699 {
2700   GIMPLE_CHECK (gs, GIMPLE_ASM);
2701   gcc_assert (index <= gs->gimple_asm.no);
2702   return gimple_op (gs, index + gs->gimple_asm.ni);
2703 }
2704
2705 /* Return a pointer to output operand INDEX of GIMPLE_ASM GS.  */
2706
2707 static inline tree *
2708 gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
2709 {
2710   GIMPLE_CHECK (gs, GIMPLE_ASM);
2711   gcc_assert (index <= gs->gimple_asm.no);
2712   return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
2713 }
2714
2715
2716 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS.  */
2717
2718 static inline void
2719 gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
2720 {
2721   GIMPLE_CHECK (gs, GIMPLE_ASM);
2722   gcc_assert (index <= gs->gimple_asm.no);
2723   gcc_assert (TREE_CODE (out_op) == TREE_LIST);
2724   gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
2725 }
2726
2727
2728 /* Return clobber operand INDEX of GIMPLE_ASM GS.  */
2729
2730 static inline tree
2731 gimple_asm_clobber_op (const_gimple gs, unsigned index)
2732 {
2733   GIMPLE_CHECK (gs, GIMPLE_ASM);
2734   gcc_assert (index <= gs->gimple_asm.nc);
2735   return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
2736 }
2737
2738
2739 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS.  */
2740
2741 static inline void
2742 gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
2743 {
2744   GIMPLE_CHECK (gs, GIMPLE_ASM);
2745   gcc_assert (index <= gs->gimple_asm.nc);
2746   gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
2747   gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
2748 }
2749
2750 /* Return label operand INDEX of GIMPLE_ASM GS.  */
2751
2752 static inline tree
2753 gimple_asm_label_op (const_gimple gs, unsigned index)
2754 {
2755   GIMPLE_CHECK (gs, GIMPLE_ASM);
2756   gcc_assert (index <= gs->gimple_asm.nl);
2757   return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc);
2758 }
2759
2760 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS.  */
2761
2762 static inline void
2763 gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
2764 {
2765   GIMPLE_CHECK (gs, GIMPLE_ASM);
2766   gcc_assert (index <= gs->gimple_asm.nl);
2767   gcc_assert (TREE_CODE (label_op) == TREE_LIST);
2768   gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op);
2769 }
2770
2771 /* Return the string representing the assembly instruction in
2772    GIMPLE_ASM GS.  */
2773
2774 static inline const char *
2775 gimple_asm_string (const_gimple gs)
2776 {
2777   GIMPLE_CHECK (gs, GIMPLE_ASM);
2778   return gs->gimple_asm.string;
2779 }
2780
2781
2782 /* Return true if GS is an asm statement marked volatile.  */
2783
2784 static inline bool
2785 gimple_asm_volatile_p (const_gimple gs)
2786 {
2787   GIMPLE_CHECK (gs, GIMPLE_ASM);
2788   return (gs->gsbase.subcode & GF_ASM_VOLATILE) != 0;
2789 }
2790
2791
2792 /* If VOLATLE_P is true, mark asm statement GS as volatile.  */
2793
2794 static inline void
2795 gimple_asm_set_volatile (gimple gs, bool volatile_p)
2796 {
2797   GIMPLE_CHECK (gs, GIMPLE_ASM);
2798   if (volatile_p)
2799     gs->gsbase.subcode |= GF_ASM_VOLATILE;
2800   else
2801     gs->gsbase.subcode &= ~GF_ASM_VOLATILE;
2802 }
2803
2804
2805 /* If INPUT_P is true, mark asm GS as an ASM_INPUT.  */
2806
2807 static inline void
2808 gimple_asm_set_input (gimple gs, bool input_p)
2809 {
2810   GIMPLE_CHECK (gs, GIMPLE_ASM);
2811   if (input_p)
2812     gs->gsbase.subcode |= GF_ASM_INPUT;
2813   else
2814     gs->gsbase.subcode &= ~GF_ASM_INPUT;
2815 }
2816
2817
2818 /* Return true if asm GS is an ASM_INPUT.  */
2819
2820 static inline bool
2821 gimple_asm_input_p (const_gimple gs)
2822 {
2823   GIMPLE_CHECK (gs, GIMPLE_ASM);
2824   return (gs->gsbase.subcode & GF_ASM_INPUT) != 0;
2825 }
2826
2827
2828 /* Return the types handled by GIMPLE_CATCH statement GS.  */
2829
2830 static inline tree
2831 gimple_catch_types (const_gimple gs)
2832 {
2833   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2834   return gs->gimple_catch.types;
2835 }
2836
2837
2838 /* Return a pointer to the types handled by GIMPLE_CATCH statement GS.  */
2839
2840 static inline tree *
2841 gimple_catch_types_ptr (gimple gs)
2842 {
2843   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2844   return &gs->gimple_catch.types;
2845 }
2846
2847
2848 /* Return the GIMPLE sequence representing the body of the handler of
2849    GIMPLE_CATCH statement GS.  */
2850
2851 static inline gimple_seq
2852 gimple_catch_handler (gimple gs)
2853 {
2854   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2855   return gs->gimple_catch.handler;
2856 }
2857
2858
2859 /* Return a pointer to the GIMPLE sequence representing the body of
2860    the handler of GIMPLE_CATCH statement GS.  */
2861
2862 static inline gimple_seq *
2863 gimple_catch_handler_ptr (gimple gs)
2864 {
2865   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2866   return &gs->gimple_catch.handler;
2867 }
2868
2869
2870 /* Set T to be the set of types handled by GIMPLE_CATCH GS.  */
2871
2872 static inline void
2873 gimple_catch_set_types (gimple gs, tree t)
2874 {
2875   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2876   gs->gimple_catch.types = t;
2877 }
2878
2879
2880 /* Set HANDLER to be the body of GIMPLE_CATCH GS.  */
2881
2882 static inline void
2883 gimple_catch_set_handler (gimple gs, gimple_seq handler)
2884 {
2885   GIMPLE_CHECK (gs, GIMPLE_CATCH);
2886   gs->gimple_catch.handler = handler;
2887 }
2888
2889
2890 /* Return the types handled by GIMPLE_EH_FILTER statement GS.  */
2891
2892 static inline tree
2893 gimple_eh_filter_types (const_gimple gs)
2894 {
2895   GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2896   return gs->gimple_eh_filter.types;
2897 }
2898
2899
2900 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
2901    GS.  */
2902
2903 static inline tree *
2904 gimple_eh_filter_types_ptr (gimple gs)
2905 {
2906   GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2907   return &gs->gimple_eh_filter.types;
2908 }
2909
2910
2911 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
2912    statement fails.  */
2913
2914 static inline gimple_seq
2915 gimple_eh_filter_failure (gimple gs)
2916 {
2917   GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2918   return gs->gimple_eh_filter.failure;
2919 }
2920
2921
2922 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS.  */
2923
2924 static inline void
2925 gimple_eh_filter_set_types (gimple gs, tree types)
2926 {
2927   GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2928   gs->gimple_eh_filter.types = types;
2929 }
2930
2931
2932 /* Set FAILURE to be the sequence of statements to execute on failure
2933    for GIMPLE_EH_FILTER GS.  */
2934
2935 static inline void
2936 gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
2937 {
2938   GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2939   gs->gimple_eh_filter.failure = failure;
2940 }
2941
2942 /* Get the function decl to be called by the MUST_NOT_THROW region.  */
2943
2944 static inline tree
2945 gimple_eh_must_not_throw_fndecl (gimple gs)
2946 {
2947   GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW);
2948   return gs->gimple_eh_mnt.fndecl;
2949 }
2950
2951 /* Set the function decl to be called by GS to DECL.  */
2952
2953 static inline void
2954 gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
2955 {
2956   GIMPLE_CHECK (gs, GIMPLE_EH_MUST_NOT_THROW);
2957   gs->gimple_eh_mnt.fndecl = decl;
2958 }
2959
2960
2961 /* GIMPLE_TRY accessors. */
2962
2963 /* Return the kind of try block represented by GIMPLE_TRY GS.  This is
2964    either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.  */
2965
2966 static inline enum gimple_try_flags
2967 gimple_try_kind (const_gimple gs)
2968 {
2969   GIMPLE_CHECK (gs, GIMPLE_TRY);
2970   return (enum gimple_try_flags) (gs->gsbase.subcode & GIMPLE_TRY_KIND);
2971 }
2972
2973
2974 /* Set the kind of try block represented by GIMPLE_TRY GS.  */
2975
2976 static inline void
2977 gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
2978 {
2979   GIMPLE_CHECK (gs, GIMPLE_TRY);
2980   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
2981   if (gimple_try_kind (gs) != kind)
2982     gs->gsbase.subcode = (unsigned int) kind;
2983 }
2984
2985
2986 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
2987
2988 static inline bool
2989 gimple_try_catch_is_cleanup (const_gimple gs)
2990 {
2991   gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
2992   return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
2993 }
2994
2995
2996 /* Return the sequence of statements used as the body for GIMPLE_TRY GS.  */
2997
2998 static inline gimple_seq
2999 gimple_try_eval (gimple gs)
3000 {
3001   GIMPLE_CHECK (gs, GIMPLE_TRY);
3002   return gs->gimple_try.eval;
3003 }
3004
3005
3006 /* Return the sequence of statements used as the cleanup body for
3007    GIMPLE_TRY GS.  */
3008
3009 static inline gimple_seq
3010 gimple_try_cleanup (gimple gs)
3011 {
3012   GIMPLE_CHECK (gs, GIMPLE_TRY);
3013   return gs->gimple_try.cleanup;
3014 }
3015
3016
3017 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.  */
3018
3019 static inline void
3020 gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
3021 {
3022   gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
3023   if (catch_is_cleanup)
3024     g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
3025   else
3026     g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
3027 }
3028
3029
3030 /* Set EVAL to be the sequence of statements to use as the body for
3031    GIMPLE_TRY GS.  */
3032
3033 static inline void
3034 gimple_try_set_eval (gimple gs, gimple_seq eval)
3035 {
3036   GIMPLE_CHECK (gs, GIMPLE_TRY);
3037   gs->gimple_try.eval = eval;
3038 }
3039
3040
3041 /* Set CLEANUP to be the sequence of statements to use as the cleanup
3042    body for GIMPLE_TRY GS.  */
3043
3044 static inline void
3045 gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
3046 {
3047   GIMPLE_CHECK (gs, GIMPLE_TRY);
3048   gs->gimple_try.cleanup = cleanup;
3049 }
3050
3051
3052 /* Return the cleanup sequence for cleanup statement GS.  */
3053
3054 static inline gimple_seq
3055 gimple_wce_cleanup (gimple gs)
3056 {
3057   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3058   return gs->gimple_wce.cleanup;
3059 }
3060
3061
3062 /* Set CLEANUP to be the cleanup sequence for GS.  */
3063
3064 static inline void
3065 gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
3066 {
3067   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3068   gs->gimple_wce.cleanup = cleanup;
3069 }
3070
3071
3072 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple.  */
3073
3074 static inline bool
3075 gimple_wce_cleanup_eh_only (const_gimple gs)
3076 {
3077   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3078   return gs->gsbase.subcode != 0;
3079 }
3080
3081
3082 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple.  */
3083
3084 static inline void
3085 gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
3086 {
3087   GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3088   gs->gsbase.subcode = (unsigned int) eh_only_p;
3089 }
3090
3091
3092 /* Return the maximum number of arguments supported by GIMPLE_PHI GS.  */
3093
3094 static inline unsigned
3095 gimple_phi_capacity (const_gimple gs)
3096 {
3097   GIMPLE_CHECK (gs, GIMPLE_PHI);
3098   return gs->gimple_phi.capacity;
3099 }
3100
3101
3102 /* Return the number of arguments in GIMPLE_PHI GS.  This must always
3103    be exactly the number of incoming edges for the basic block holding
3104    GS.  */
3105
3106 static inline unsigned
3107 gimple_phi_num_args (const_gimple gs)
3108 {
3109   GIMPLE_CHECK (gs, GIMPLE_PHI);
3110   return gs->gimple_phi.nargs;
3111 }
3112
3113
3114 /* Return the SSA name created by GIMPLE_PHI GS.  */
3115
3116 static inline tree
3117 gimple_phi_result (const_gimple gs)
3118 {
3119   GIMPLE_CHECK (gs, GIMPLE_PHI);
3120   return gs->gimple_phi.result;
3121 }
3122
3123 /* Return a pointer to the SSA name created by GIMPLE_PHI GS.  */
3124
3125 static inline tree *
3126 gimple_phi_result_ptr (gimple gs)
3127 {
3128   GIMPLE_CHECK (gs, GIMPLE_PHI);
3129   return &gs->gimple_phi.result;
3130 }
3131
3132 /* Set RESULT to be the SSA name created by GIMPLE_PHI GS.  */
3133
3134 static inline void
3135 gimple_phi_set_result (gimple gs, tree result)
3136 {
3137   GIMPLE_CHECK (gs, GIMPLE_PHI);
3138   gs->gimple_phi.result = result;
3139 }
3140
3141
3142 /* Return the PHI argument corresponding to incoming edge INDEX for
3143    GIMPLE_PHI GS.  */
3144
3145 static inline struct phi_arg_d *
3146 gimple_phi_arg (gimple gs, unsigned index)
3147 {
3148   GIMPLE_CHECK (gs, GIMPLE_PHI);
3149   gcc_assert (index <= gs->gimple_phi.capacity);
3150   return &(gs->gimple_phi.args[index]);
3151 }
3152
3153 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
3154    for GIMPLE_PHI GS.  */
3155
3156 static inline void
3157 gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
3158 {
3159   GIMPLE_CHECK (gs, GIMPLE_PHI);
3160   gcc_assert (index <= gs->gimple_phi.nargs);
3161   memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
3162 }
3163
3164 /* Return the region number for GIMPLE_RESX GS.  */
3165
3166 static inline int
3167 gimple_resx_region (const_gimple gs)
3168 {
3169   GIMPLE_CHECK (gs, GIMPLE_RESX);
3170   return gs->gimple_eh_ctrl.region;
3171 }
3172
3173 /* Set REGION to be the region number for GIMPLE_RESX GS.  */
3174
3175 static inline void
3176 gimple_resx_set_region (gimple gs, int region)
3177 {
3178   GIMPLE_CHECK (gs, GIMPLE_RESX);
3179   gs->gimple_eh_ctrl.region = region;
3180 }
3181
3182 /* Return the region number for GIMPLE_EH_DISPATCH GS.  */
3183
3184 static inline int
3185 gimple_eh_dispatch_region (const_gimple gs)
3186 {
3187   GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH);
3188   return gs->gimple_eh_ctrl.region;
3189 }
3190
3191 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH GS.  */
3192
3193 static inline void
3194 gimple_eh_dispatch_set_region (gimple gs, int region)
3195 {
3196   GIMPLE_CHECK (gs, GIMPLE_EH_DISPATCH);
3197   gs->gimple_eh_ctrl.region = region;
3198 }
3199
3200 /* Return the number of labels associated with the switch statement GS.  */
3201
3202 static inline unsigned
3203 gimple_switch_num_labels (const_gimple gs)
3204 {
3205   unsigned num_ops;
3206   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3207   num_ops = gimple_num_ops (gs);
3208   gcc_assert (num_ops > 1);
3209   return num_ops - 1;
3210 }
3211
3212
3213 /* Set NLABELS to be the number of labels for the switch statement GS.  */
3214
3215 static inline void
3216 gimple_switch_set_num_labels (gimple g, unsigned nlabels)
3217 {
3218   GIMPLE_CHECK (g, GIMPLE_SWITCH);
3219   gimple_set_num_ops (g, nlabels + 1);
3220 }
3221
3222
3223 /* Return the index variable used by the switch statement GS.  */
3224
3225 static inline tree
3226 gimple_switch_index (const_gimple gs)
3227 {
3228   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3229   return gimple_op (gs, 0);
3230 }
3231
3232
3233 /* Return a pointer to the index variable for the switch statement GS.  */
3234
3235 static inline tree *
3236 gimple_switch_index_ptr (const_gimple gs)
3237 {
3238   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3239   return gimple_op_ptr (gs, 0);
3240 }
3241
3242
3243 /* Set INDEX to be the index variable for switch statement GS.  */
3244
3245 static inline void
3246 gimple_switch_set_index (gimple gs, tree index)
3247 {
3248   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3249   gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
3250   gimple_set_op (gs, 0, index);
3251 }
3252
3253
3254 /* Return the label numbered INDEX.  The default label is 0, followed by any
3255    labels in a switch statement.  */
3256
3257 static inline tree
3258 gimple_switch_label (const_gimple gs, unsigned index)
3259 {
3260   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3261   gcc_assert (gimple_num_ops (gs) > index + 1);
3262   return gimple_op (gs, index + 1);
3263 }
3264
3265 /* Set the label number INDEX to LABEL.  0 is always the default label.  */
3266
3267 static inline void
3268 gimple_switch_set_label (gimple gs, unsigned index, tree label)
3269 {
3270   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3271   gcc_assert (gimple_num_ops (gs) > index + 1);
3272   gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
3273   gimple_set_op (gs, index + 1, label);
3274 }
3275
3276 /* Return the default label for a switch statement.  */
3277
3278 static inline tree
3279 gimple_switch_default_label (const_gimple gs)
3280 {
3281   return gimple_switch_label (gs, 0);
3282 }
3283
3284 /* Set the default label for a switch statement.  */
3285
3286 static inline void
3287 gimple_switch_set_default_label (gimple gs, tree label)
3288 {
3289   gimple_switch_set_label (gs, 0, label);
3290 }
3291
3292 /* Return true if GS is a GIMPLE_DEBUG statement.  */
3293
3294 static inline bool
3295 is_gimple_debug (const_gimple gs)
3296 {
3297   return gimple_code (gs) == GIMPLE_DEBUG;
3298 }
3299
3300 /* Return true if S is a GIMPLE_DEBUG BIND statement.  */
3301
3302 static inline bool
3303 gimple_debug_bind_p (const_gimple s)
3304 {
3305   if (is_gimple_debug (s))
3306     return s->gsbase.subcode == GIMPLE_DEBUG_BIND;
3307
3308   return false;
3309 }
3310
3311 /* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
3312
3313 static inline tree
3314 gimple_debug_bind_get_var (gimple dbg)
3315 {
3316   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3317 #ifdef ENABLE_CHECKING
3318   gcc_assert (gimple_debug_bind_p (dbg));
3319 #endif
3320   return gimple_op (dbg, 0);
3321 }
3322
3323 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
3324    statement.  */
3325
3326 static inline tree
3327 gimple_debug_bind_get_value (gimple dbg)
3328 {
3329   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3330 #ifdef ENABLE_CHECKING
3331   gcc_assert (gimple_debug_bind_p (dbg));
3332 #endif
3333   return gimple_op (dbg, 1);
3334 }
3335
3336 /* Return a pointer to the value bound to the variable in a
3337    GIMPLE_DEBUG bind statement.  */
3338
3339 static inline tree *
3340 gimple_debug_bind_get_value_ptr (gimple dbg)
3341 {
3342   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3343 #ifdef ENABLE_CHECKING
3344   gcc_assert (gimple_debug_bind_p (dbg));
3345 #endif
3346   return gimple_op_ptr (dbg, 1);
3347 }
3348
3349 /* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
3350
3351 static inline void
3352 gimple_debug_bind_set_var (gimple dbg, tree var)
3353 {
3354   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3355 #ifdef ENABLE_CHECKING
3356   gcc_assert (gimple_debug_bind_p (dbg));
3357 #endif
3358   gimple_set_op (dbg, 0, var);
3359 }
3360
3361 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
3362    statement.  */
3363
3364 static inline void
3365 gimple_debug_bind_set_value (gimple dbg, tree value)
3366 {
3367   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3368 #ifdef ENABLE_CHECKING
3369   gcc_assert (gimple_debug_bind_p (dbg));
3370 #endif
3371   gimple_set_op (dbg, 1, value);
3372 }
3373
3374 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
3375    optimized away.  */
3376 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
3377
3378 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
3379    statement.  */
3380
3381 static inline void
3382 gimple_debug_bind_reset_value (gimple dbg)
3383 {
3384   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3385 #ifdef ENABLE_CHECKING
3386   gcc_assert (gimple_debug_bind_p (dbg));
3387 #endif
3388   gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
3389 }
3390
3391 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
3392    value.  */
3393
3394 static inline bool
3395 gimple_debug_bind_has_value_p (gimple dbg)
3396 {
3397   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
3398 #ifdef ENABLE_CHECKING
3399   gcc_assert (gimple_debug_bind_p (dbg));
3400 #endif
3401   return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
3402 }
3403
3404 #undef GIMPLE_DEBUG_BIND_NOVALUE
3405
3406 /* Return the body for the OMP statement GS.  */
3407
3408 static inline gimple_seq
3409 gimple_omp_body (gimple gs)
3410 {
3411   return gs->omp.body;
3412 }
3413
3414 /* Set BODY to be the body for the OMP statement GS.  */
3415
3416 static inline void
3417 gimple_omp_set_body (gimple gs, gimple_seq body)
3418 {
3419   gs->omp.body = body;
3420 }
3421
3422
3423 /* Return the name associated with OMP_CRITICAL statement GS.  */
3424
3425 static inline tree
3426 gimple_omp_critical_name (const_gimple gs)
3427 {
3428   GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3429   return gs->gimple_omp_critical.name;
3430 }
3431
3432
3433 /* Return a pointer to the name associated with OMP critical statement GS.  */
3434
3435 static inline tree *
3436 gimple_omp_critical_name_ptr (gimple gs)
3437 {
3438   GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3439   return &gs->gimple_omp_critical.name;
3440 }
3441
3442
3443 /* Set NAME to be the name associated with OMP critical statement GS.  */
3444
3445 static inline void
3446 gimple_omp_critical_set_name (gimple gs, tree name)
3447 {
3448   GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3449   gs->gimple_omp_critical.name = name;
3450 }
3451
3452
3453 /* Return the clauses associated with OMP_FOR GS.  */
3454
3455 static inline tree
3456 gimple_omp_for_clauses (const_gimple gs)
3457 {
3458   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3459   return gs->gimple_omp_for.clauses;
3460 }
3461
3462
3463 /* Return a pointer to the OMP_FOR GS.  */
3464
3465 static inline tree *
3466 gimple_omp_for_clauses_ptr (gimple gs)
3467 {
3468   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3469   return &gs->gimple_omp_for.clauses;
3470 }
3471
3472
3473 /* Set CLAUSES to be the list of clauses associated with OMP_FOR GS.  */
3474
3475 static inline void
3476 gimple_omp_for_set_clauses (gimple gs, tree clauses)
3477 {
3478   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3479   gs->gimple_omp_for.clauses = clauses;
3480 }
3481
3482
3483 /* Get the collapse count of OMP_FOR GS.  */
3484
3485 static inline size_t
3486 gimple_omp_for_collapse (gimple gs)
3487 {
3488   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3489   return gs->gimple_omp_for.collapse;
3490 }
3491
3492
3493 /* Return the index variable for OMP_FOR GS.  */
3494
3495 static inline tree
3496 gimple_omp_for_index (const_gimple gs, size_t i)
3497 {
3498   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3499   gcc_assert (i < gs->gimple_omp_for.collapse);
3500   return gs->gimple_omp_for.iter[i].index;
3501 }
3502
3503
3504 /* Return a pointer to the index variable for OMP_FOR GS.  */
3505
3506 static inline tree *
3507 gimple_omp_for_index_ptr (gimple gs, size_t i)
3508 {
3509   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3510   gcc_assert (i < gs->gimple_omp_for.collapse);
3511   return &gs->gimple_omp_for.iter[i].index;
3512 }
3513
3514
3515 /* Set INDEX to be the index variable for OMP_FOR GS.  */
3516
3517 static inline void
3518 gimple_omp_for_set_index (gimple gs, size_t i, tree index)
3519 {
3520   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3521   gcc_assert (i < gs->gimple_omp_for.collapse);
3522   gs->gimple_omp_for.iter[i].index = index;
3523 }
3524
3525
3526 /* Return the initial value for OMP_FOR GS.  */
3527
3528 static inline tree
3529 gimple_omp_for_initial (const_gimple gs, size_t i)
3530 {
3531   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3532   gcc_assert (i < gs->gimple_omp_for.collapse);
3533   return gs->gimple_omp_for.iter[i].initial;
3534 }
3535
3536
3537 /* Return a pointer to the initial value for OMP_FOR GS.  */
3538
3539 static inline tree *
3540 gimple_omp_for_initial_ptr (gimple gs, size_t i)
3541 {
3542   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3543   gcc_assert (i < gs->gimple_omp_for.collapse);
3544   return &gs->gimple_omp_for.iter[i].initial;
3545 }
3546
3547
3548 /* Set INITIAL to be the initial value for OMP_FOR GS.  */
3549
3550 static inline void
3551 gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
3552 {
3553   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3554   gcc_assert (i < gs->gimple_omp_for.collapse);
3555   gs->gimple_omp_for.iter[i].initial = initial;
3556 }
3557
3558
3559 /* Return the final value for OMP_FOR GS.  */
3560
3561 static inline tree
3562 gimple_omp_for_final (const_gimple gs, size_t i)
3563 {
3564   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3565   gcc_assert (i < gs->gimple_omp_for.collapse);
3566   return gs->gimple_omp_for.iter[i].final;
3567 }
3568
3569
3570 /* Return a pointer to the final value for OMP_FOR GS.  */
3571
3572 static inline tree *
3573 gimple_omp_for_final_ptr (gimple gs, size_t i)
3574 {
3575   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3576   gcc_assert (i < gs->gimple_omp_for.collapse);
3577   return &gs->gimple_omp_for.iter[i].final;
3578 }
3579
3580
3581 /* Set FINAL to be the final value for OMP_FOR GS.  */
3582
3583 static inline void
3584 gimple_omp_for_set_final (gimple gs, size_t i, tree final)
3585 {
3586   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3587   gcc_assert (i < gs->gimple_omp_for.collapse);
3588   gs->gimple_omp_for.iter[i].final = final;
3589 }
3590
3591
3592 /* Return the increment value for OMP_FOR GS.  */
3593
3594 static inline tree
3595 gimple_omp_for_incr (const_gimple gs, size_t i)
3596 {
3597   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3598   gcc_assert (i < gs->gimple_omp_for.collapse);
3599   return gs->gimple_omp_for.iter[i].incr;
3600 }
3601
3602
3603 /* Return a pointer to the increment value for OMP_FOR GS.  */
3604
3605 static inline tree *
3606 gimple_omp_for_incr_ptr (gimple gs, size_t i)
3607 {
3608   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3609   gcc_assert (i < gs->gimple_omp_for.collapse);
3610   return &gs->gimple_omp_for.iter[i].incr;
3611 }
3612
3613
3614 /* Set INCR to be the increment value for OMP_FOR GS.  */
3615
3616 static inline void
3617 gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
3618 {
3619   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3620   gcc_assert (i < gs->gimple_omp_for.collapse);
3621   gs->gimple_omp_for.iter[i].incr = incr;
3622 }
3623
3624
3625 /* Return the sequence of statements to execute before the OMP_FOR
3626    statement GS starts.  */
3627
3628 static inline gimple_seq
3629 gimple_omp_for_pre_body (gimple gs)
3630 {
3631   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3632   return gs->gimple_omp_for.pre_body;
3633 }
3634
3635
3636 /* Set PRE_BODY to be the sequence of statements to execute before the
3637    OMP_FOR statement GS starts.  */
3638
3639 static inline void
3640 gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
3641 {
3642   GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3643   gs->gimple_omp_for.pre_body = pre_body;
3644 }
3645
3646
3647 /* Return the clauses associated with OMP_PARALLEL GS.  */
3648
3649 static inline tree
3650 gimple_omp_parallel_clauses (const_gimple gs)
3651 {
3652   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3653   return gs->gimple_omp_parallel.clauses;
3654 }
3655
3656
3657 /* Return a pointer to the clauses associated with OMP_PARALLEL GS.  */
3658
3659 static inline tree *
3660 gimple_omp_parallel_clauses_ptr (gimple gs)
3661 {
3662   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3663   return &gs->gimple_omp_parallel.clauses;
3664 }
3665
3666
3667 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL
3668    GS.  */
3669
3670 static inline void
3671 gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
3672 {
3673   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3674   gs->gimple_omp_parallel.clauses = clauses;
3675 }
3676
3677
3678 /* Return the child function used to hold the body of OMP_PARALLEL GS.  */
3679
3680 static inline tree
3681 gimple_omp_parallel_child_fn (const_gimple gs)
3682 {
3683   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3684   return gs->gimple_omp_parallel.child_fn;
3685 }
3686
3687 /* Return a pointer to the child function used to hold the body of
3688    OMP_PARALLEL GS.  */
3689
3690 static inline tree *
3691 gimple_omp_parallel_child_fn_ptr (gimple gs)
3692 {
3693   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3694   return &gs->gimple_omp_parallel.child_fn;
3695 }
3696
3697
3698 /* Set CHILD_FN to be the child function for OMP_PARALLEL GS.  */
3699
3700 static inline void
3701 gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
3702 {
3703   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3704   gs->gimple_omp_parallel.child_fn = child_fn;
3705 }
3706
3707
3708 /* Return the artificial argument used to send variables and values
3709    from the parent to the children threads in OMP_PARALLEL GS.  */
3710
3711 static inline tree
3712 gimple_omp_parallel_data_arg (const_gimple gs)
3713 {
3714   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3715   return gs->gimple_omp_parallel.data_arg;
3716 }
3717
3718
3719 /* Return a pointer to the data argument for OMP_PARALLEL GS.  */
3720
3721 static inline tree *
3722 gimple_omp_parallel_data_arg_ptr (gimple gs)
3723 {
3724   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3725   return &gs->gimple_omp_parallel.data_arg;
3726 }
3727
3728
3729 /* Set DATA_ARG to be the data argument for OMP_PARALLEL GS.  */
3730
3731 static inline void
3732 gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
3733 {
3734   GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3735   gs->gimple_omp_parallel.data_arg = data_arg;
3736 }
3737
3738
3739 /* Return the clauses associated with OMP_TASK GS.  */
3740
3741 static inline tree
3742 gimple_omp_task_clauses (const_gimple gs)
3743 {
3744   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3745   return gs->gimple_omp_parallel.clauses;
3746 }
3747
3748
3749 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
3750
3751 static inline tree *
3752 gimple_omp_task_clauses_ptr (gimple gs)
3753 {
3754   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3755   return &gs->gimple_omp_parallel.clauses;
3756 }
3757
3758
3759 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
3760    GS.  */
3761
3762 static inline void
3763 gimple_omp_task_set_clauses (gimple gs, tree clauses)
3764 {
3765   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3766   gs->gimple_omp_parallel.clauses = clauses;
3767 }
3768
3769
3770 /* Return the child function used to hold the body of OMP_TASK GS.  */
3771
3772 static inline tree
3773 gimple_omp_task_child_fn (const_gimple gs)
3774 {
3775   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3776   return gs->gimple_omp_parallel.child_fn;
3777 }
3778
3779 /* Return a pointer to the child function used to hold the body of
3780    OMP_TASK GS.  */
3781
3782 static inline tree *
3783 gimple_omp_task_child_fn_ptr (gimple gs)
3784 {
3785   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3786   return &gs->gimple_omp_parallel.child_fn;
3787 }
3788
3789
3790 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
3791
3792 static inline void
3793 gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
3794 {
3795   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3796   gs->gimple_omp_parallel.child_fn = child_fn;
3797 }
3798
3799
3800 /* Return the artificial argument used to send variables and values
3801    from the parent to the children threads in OMP_TASK GS.  */
3802
3803 static inline tree
3804 gimple_omp_task_data_arg (const_gimple gs)
3805 {
3806   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3807   return gs->gimple_omp_parallel.data_arg;
3808 }
3809
3810
3811 /* Return a pointer to the data argument for OMP_TASK GS.  */
3812
3813 static inline tree *
3814 gimple_omp_task_data_arg_ptr (gimple gs)
3815 {
3816   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3817   return &gs->gimple_omp_parallel.data_arg;
3818 }
3819
3820
3821 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
3822
3823 static inline void
3824 gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
3825 {
3826   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3827   gs->gimple_omp_parallel.data_arg = data_arg;
3828 }
3829
3830
3831 /* Return the clauses associated with OMP_TASK GS.  */
3832
3833 static inline tree
3834 gimple_omp_taskreg_clauses (const_gimple gs)
3835 {
3836   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3837     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3838   return gs->gimple_omp_parallel.clauses;
3839 }
3840
3841
3842 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
3843
3844 static inline tree *
3845 gimple_omp_taskreg_clauses_ptr (gimple gs)
3846 {
3847   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3848     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3849   return &gs->gimple_omp_parallel.clauses;
3850 }
3851
3852
3853 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
3854    GS.  */
3855
3856 static inline void
3857 gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
3858 {
3859   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3860     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3861   gs->gimple_omp_parallel.clauses = clauses;
3862 }
3863
3864
3865 /* Return the child function used to hold the body of OMP_TASK GS.  */
3866
3867 static inline tree
3868 gimple_omp_taskreg_child_fn (const_gimple gs)
3869 {
3870   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3871     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3872   return gs->gimple_omp_parallel.child_fn;
3873 }
3874
3875 /* Return a pointer to the child function used to hold the body of
3876    OMP_TASK GS.  */
3877
3878 static inline tree *
3879 gimple_omp_taskreg_child_fn_ptr (gimple gs)
3880 {
3881   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3882     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3883   return &gs->gimple_omp_parallel.child_fn;
3884 }
3885
3886
3887 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
3888
3889 static inline void
3890 gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
3891 {
3892   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3893     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3894   gs->gimple_omp_parallel.child_fn = child_fn;
3895 }
3896
3897
3898 /* Return the artificial argument used to send variables and values
3899    from the parent to the children threads in OMP_TASK GS.  */
3900
3901 static inline tree
3902 gimple_omp_taskreg_data_arg (const_gimple gs)
3903 {
3904   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3905     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3906   return gs->gimple_omp_parallel.data_arg;
3907 }
3908
3909
3910 /* Return a pointer to the data argument for OMP_TASK GS.  */
3911
3912 static inline tree *
3913 gimple_omp_taskreg_data_arg_ptr (gimple gs)
3914 {
3915   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3916     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3917   return &gs->gimple_omp_parallel.data_arg;
3918 }
3919
3920
3921 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
3922
3923 static inline void
3924 gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
3925 {
3926   if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3927     GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3928   gs->gimple_omp_parallel.data_arg = data_arg;
3929 }
3930
3931
3932 /* Return the copy function used to hold the body of OMP_TASK GS.  */
3933
3934 static inline tree
3935 gimple_omp_task_copy_fn (const_gimple gs)
3936 {
3937   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3938   return gs->gimple_omp_task.copy_fn;
3939 }
3940
3941 /* Return a pointer to the copy function used to hold the body of
3942    OMP_TASK GS.  */
3943
3944 static inline tree *
3945 gimple_omp_task_copy_fn_ptr (gimple gs)
3946 {
3947   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3948   return &gs->gimple_omp_task.copy_fn;
3949 }
3950
3951
3952 /* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
3953
3954 static inline void
3955 gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
3956 {
3957   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3958   gs->gimple_omp_task.copy_fn = copy_fn;
3959 }
3960
3961
3962 /* Return size of the data block in bytes in OMP_TASK GS.  */
3963
3964 static inline tree
3965 gimple_omp_task_arg_size (const_gimple gs)
3966 {
3967   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3968   return gs->gimple_omp_task.arg_size;
3969 }
3970
3971
3972 /* Return a pointer to the data block size for OMP_TASK GS.  */
3973
3974 static inline tree *
3975 gimple_omp_task_arg_size_ptr (gimple gs)
3976 {
3977   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3978   return &gs->gimple_omp_task.arg_size;
3979 }
3980
3981
3982 /* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
3983
3984 static inline void
3985 gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
3986 {
3987   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3988   gs->gimple_omp_task.arg_size = arg_size;
3989 }
3990
3991
3992 /* Return align of the data block in bytes in OMP_TASK GS.  */
3993
3994 static inline tree
3995 gimple_omp_task_arg_align (const_gimple gs)
3996 {
3997   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3998   return gs->gimple_omp_task.arg_align;
3999 }
4000
4001
4002 /* Return a pointer to the data block align for OMP_TASK GS.  */
4003
4004 static inline tree *
4005 gimple_omp_task_arg_align_ptr (gimple gs)
4006 {
4007   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
4008   return &gs->gimple_omp_task.arg_align;
4009 }
4010
4011
4012 /* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
4013
4014 static inline void
4015 gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
4016 {
4017   GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
4018   gs->gimple_omp_tas