gcc/gimple.h

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