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_replaceable_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 first nondebug statement in GIMPLE sequence S.  */
4732
4733 static inline gimple *
4734 gimple_seq_first_nondebug_stmt (gimple_seq s)
4735 {
4736   gimple_seq_node n = gimple_seq_first (s);
4737   while (n && is_gimple_debug (n))
4738     n = n->next;
4739   return n;
4740 }
4741
4742
4743 /* Return the last nondebug statement in GIMPLE sequence S.  */
4744
4745 static inline gimple *
4746 gimple_seq_last_nondebug_stmt (gimple_seq s)
4747 {
4748   gimple_seq_node n;
4749   for (n = gimple_seq_last (s);
4750        n && is_gimple_debug (n);
4751        n = n->prev)
4752     if (n == s)
4753       return NULL;
4754   return n;
4755 }
4756
4757
4758 /* Return true if S is a GIMPLE_DEBUG BIND statement.  */
4759
4760 static inline bool
4761 gimple_debug_bind_p (const gimple *s)
4762 {
4763   if (is_gimple_debug (s))
4764     return s->subcode == GIMPLE_DEBUG_BIND;
4765
4766   return false;
4767 }
4768
4769 /* Return the variable bound in a GIMPLE_DEBUG bind statement.  */
4770
4771 static inline tree
4772 gimple_debug_bind_get_var (const gimple *dbg)
4773 {
4774   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4775   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4776   return gimple_op (dbg, 0);
4777 }
4778
4779 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
4780    statement.  */
4781
4782 static inline tree
4783 gimple_debug_bind_get_value (const gimple *dbg)
4784 {
4785   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4786   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4787   return gimple_op (dbg, 1);
4788 }
4789
4790 /* Return a pointer to the value bound to the variable in a
4791    GIMPLE_DEBUG bind statement.  */
4792
4793 static inline tree *
4794 gimple_debug_bind_get_value_ptr (gimple *dbg)
4795 {
4796   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4797   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4798   return gimple_op_ptr (dbg, 1);
4799 }
4800
4801 /* Set the variable bound in a GIMPLE_DEBUG bind statement.  */
4802
4803 static inline void
4804 gimple_debug_bind_set_var (gimple *dbg, tree var)
4805 {
4806   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4807   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4808   gimple_set_op (dbg, 0, var);
4809 }
4810
4811 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
4812    statement.  */
4813
4814 static inline void
4815 gimple_debug_bind_set_value (gimple *dbg, tree value)
4816 {
4817   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4818   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4819   gimple_set_op (dbg, 1, value);
4820 }
4821
4822 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
4823    optimized away.  */
4824 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
4825
4826 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
4827    statement.  */
4828
4829 static inline void
4830 gimple_debug_bind_reset_value (gimple *dbg)
4831 {
4832   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4833   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4834   gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
4835 }
4836
4837 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
4838    value.  */
4839
4840 static inline bool
4841 gimple_debug_bind_has_value_p (gimple *dbg)
4842 {
4843   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4844   gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
4845   return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
4846 }
4847
4848 #undef GIMPLE_DEBUG_BIND_NOVALUE
4849
4850 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.  */
4851
4852 static inline bool
4853 gimple_debug_source_bind_p (const gimple *s)
4854 {
4855   if (is_gimple_debug (s))
4856     return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
4857
4858   return false;
4859 }
4860
4861 /* Return the variable bound in a GIMPLE_DEBUG source bind statement.  */
4862
4863 static inline tree
4864 gimple_debug_source_bind_get_var (const gimple *dbg)
4865 {
4866   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4867   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
4868   return gimple_op (dbg, 0);
4869 }
4870
4871 /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
4872    statement.  */
4873
4874 static inline tree
4875 gimple_debug_source_bind_get_value (const gimple *dbg)
4876 {
4877   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4878   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
4879   return gimple_op (dbg, 1);
4880 }
4881
4882 /* Return a pointer to the value bound to the variable in a
4883    GIMPLE_DEBUG source bind statement.  */
4884
4885 static inline tree *
4886 gimple_debug_source_bind_get_value_ptr (gimple *dbg)
4887 {
4888   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4889   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
4890   return gimple_op_ptr (dbg, 1);
4891 }
4892
4893 /* Set the variable bound in a GIMPLE_DEBUG source bind statement.  */
4894
4895 static inline void
4896 gimple_debug_source_bind_set_var (gimple *dbg, tree var)
4897 {
4898   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4899   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
4900   gimple_set_op (dbg, 0, var);
4901 }
4902
4903 /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
4904    statement.  */
4905
4906 static inline void
4907 gimple_debug_source_bind_set_value (gimple *dbg, tree value)
4908 {
4909   GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
4910   gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
4911   gimple_set_op (dbg, 1, value);
4912 }
4913
4914 /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement.  */
4915
4916 static inline bool
4917 gimple_debug_begin_stmt_p (const gimple *s)
4918 {
4919   if (is_gimple_debug (s))
4920     return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
4921
4922   return false;
4923 }
4924
4925 /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement.  */
4926
4927 static inline bool
4928 gimple_debug_inline_entry_p (const gimple *s)
4929 {
4930   if (is_gimple_debug (s))
4931     return s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
4932
4933   return false;
4934 }
4935
4936 /* Return true if S is a GIMPLE_DEBUG non-binding marker statement.  */
4937
4938 static inline bool
4939 gimple_debug_nonbind_marker_p (const gimple *s)
4940 {
4941   if (is_gimple_debug (s))
4942     return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
4943       || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
4944
4945   return false;
4946 }
4947
4948 /* Return the line number for EXPR, or return -1 if we have no line
4949    number information for it.  */
4950 static inline int
4951 get_lineno (const gimple *stmt)
4952 {
4953   location_t loc;
4954
4955   if (!stmt)
4956     return -1;
4957
4958   loc = gimple_location (stmt);
4959   if (loc == UNKNOWN_LOCATION)
4960     return -1;
4961
4962   return LOCATION_LINE (loc);
4963 }
4964
4965 /* Return a pointer to the body for the OMP statement GS.  */
4966
4967 static inline gimple_seq *
4968 gimple_omp_body_ptr (gimple *gs)
4969 {
4970   return &static_cast <gimple_statement_omp *> (gs)->body;
4971 }
4972
4973 /* Return the body for the OMP statement GS.  */
4974
4975 static inline gimple_seq
4976 gimple_omp_body (const gimple *gs)
4977 {
4978   return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
4979 }
4980
4981 /* Set BODY to be the body for the OMP statement GS.  */
4982
4983 static inline void
4984 gimple_omp_set_body (gimple *gs, gimple_seq body)
4985 {
4986   static_cast <gimple_statement_omp *> (gs)->body = body;
4987 }
4988
4989
4990 /* Return the name associated with OMP_CRITICAL statement CRIT_STMT.  */
4991
4992 static inline tree
4993 gimple_omp_critical_name (const gomp_critical *crit_stmt)
4994 {
4995   return crit_stmt->name;
4996 }
4997
4998
4999 /* Return a pointer to the name associated with OMP critical statement
5000    CRIT_STMT.  */
5001
5002 static inline tree *
5003 gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
5004 {
5005   return &crit_stmt->name;
5006 }
5007
5008
5009 /* Set NAME to be the name associated with OMP critical statement
5010    CRIT_STMT.  */
5011
5012 static inline void
5013 gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
5014 {
5015   crit_stmt->name = name;
5016 }
5017
5018
5019 /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT.  */
5020
5021 static inline tree
5022 gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
5023 {
5024   return crit_stmt->clauses;
5025 }
5026
5027
5028 /* Return a pointer to the clauses associated with OMP critical statement
5029    CRIT_STMT.  */
5030
5031 static inline tree *
5032 gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
5033 {
5034   return &crit_stmt->clauses;
5035 }
5036
5037
5038 /* Set CLAUSES to be the clauses associated with OMP critical statement
5039    CRIT_STMT.  */
5040
5041 static inline void
5042 gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
5043 {
5044   crit_stmt->clauses = clauses;
5045 }
5046
5047
5048 /* Return the clauses associated with OMP_ORDERED statement ORD_STMT.  */
5049
5050 static inline tree
5051 gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
5052 {
5053   return ord_stmt->clauses;
5054 }
5055
5056
5057 /* Return a pointer to the clauses associated with OMP ordered statement
5058    ORD_STMT.  */
5059
5060 static inline tree *
5061 gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
5062 {
5063   return &ord_stmt->clauses;
5064 }
5065
5066
5067 /* Set CLAUSES to be the clauses associated with OMP ordered statement
5068    ORD_STMT.  */
5069
5070 static inline void
5071 gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
5072 {
5073   ord_stmt->clauses = clauses;
5074 }
5075
5076
5077 /* Return the clauses associated with OMP_SCAN statement SCAN_STMT.  */
5078
5079 static inline tree
5080 gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
5081 {
5082   return scan_stmt->clauses;
5083 }
5084
5085
5086 /* Return a pointer to the clauses associated with OMP scan statement
5087    ORD_STMT.  */
5088
5089 static inline tree *
5090 gimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
5091 {
5092   return &scan_stmt->clauses;
5093 }
5094
5095
5096 /* Set CLAUSES to be the clauses associated with OMP scan statement
5097    ORD_STMT.  */
5098
5099 static inline void
5100 gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
5101 {
5102   scan_stmt->clauses = clauses;
5103 }
5104
5105
5106 /* Return the clauses associated with OMP_TASKGROUP statement GS.  */
5107
5108 static inline tree
5109 gimple_omp_taskgroup_clauses (const gimple *gs)
5110 {
5111   GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5112   return
5113     static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5114 }
5115
5116
5117 /* Return a pointer to the clauses associated with OMP taskgroup statement
5118    GS.  */
5119
5120 static inline tree *
5121 gimple_omp_taskgroup_clauses_ptr (gimple *gs)
5122 {
5123   GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5124   return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5125 }
5126
5127
5128 /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
5129    GS.  */
5130
5131 static inline void
5132 gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
5133 {
5134   GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5135   static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5136     = clauses;
5137 }
5138
5139
5140 /* Return the kind of the OMP_FOR statemement G.  */
5141
5142 static inline int
5143 gimple_omp_for_kind (const gimple *g)
5144 {
5145   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5146   return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
5147 }
5148
5149
5150 /* Set the kind of the OMP_FOR statement G.  */
5151
5152 static inline void
5153 gimple_omp_for_set_kind (gomp_for *g, int kind)
5154 {
5155   g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
5156                       | (kind & GF_OMP_FOR_KIND_MASK);
5157 }
5158
5159
5160 /* Return true if OMP_FOR statement G has the
5161    GF_OMP_FOR_COMBINED flag set.  */
5162
5163 static inline bool
5164 gimple_omp_for_combined_p (const gimple *g)
5165 {
5166   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5167   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
5168 }
5169
5170
5171 /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5172    the boolean value of COMBINED_P.  */
5173
5174 static inline void
5175 gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
5176 {
5177   if (combined_p)
5178     g->subcode |= GF_OMP_FOR_COMBINED;
5179   else
5180     g->subcode &= ~GF_OMP_FOR_COMBINED;
5181 }
5182
5183
5184 /* Return true if the OMP_FOR statement G has the
5185    GF_OMP_FOR_COMBINED_INTO flag set.  */
5186
5187 static inline bool
5188 gimple_omp_for_combined_into_p (const gimple *g)
5189 {
5190   GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5191   return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
5192 }
5193
5194
5195 /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5196    on the boolean value of COMBINED_P.  */
5197
5198 static inline void
5199 gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
5200 {
5201   if (combined_p)
5202     g->subcode |= GF_OMP_FOR_COMBINED_INTO;
5203   else
5204     g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
5205 }
5206
5207
5208 /* Return the clauses associated with the OMP_FOR statement GS.  */
5209
5210 static inline tree
5211 gimple_omp_for_clauses (const gimple *gs)
5212 {
5213   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5214   return omp_for_stmt->clauses;
5215 }
5216
5217
5218 /* Return a pointer to the clauses associated with the OMP_FOR statement
5219    GS.  */
5220
5221 static inline tree *
5222 gimple_omp_for_clauses_ptr (gimple *gs)
5223 {
5224   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5225   return &omp_for_stmt->clauses;
5226 }
5227
5228
5229 /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5230    GS.  */
5231
5232 static inline void
5233 gimple_omp_for_set_clauses (gimple *gs, tree clauses)
5234 {
5235   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5236   omp_for_stmt->clauses = clauses;
5237 }
5238
5239
5240 /* Get the collapse count of the OMP_FOR statement GS.  */
5241
5242 static inline size_t
5243 gimple_omp_for_collapse (const gimple *gs)
5244 {
5245   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5246   return omp_for_stmt->collapse;
5247 }
5248
5249
5250 /* Return the condition code associated with the OMP_FOR statement GS.  */
5251
5252 static inline enum tree_code
5253 gimple_omp_for_cond (const gimple *gs, size_t i)
5254 {
5255   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5256   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5257   return omp_for_stmt->iter[i].cond;
5258 }
5259
5260
5261 /* Set COND to be the condition code for the OMP_FOR statement GS.  */
5262
5263 static inline void
5264 gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
5265 {
5266   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5267   gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
5268                               && i < omp_for_stmt->collapse);
5269   omp_for_stmt->iter[i].cond = cond;
5270 }
5271
5272
5273 /* Return the index variable for the OMP_FOR statement GS.  */
5274
5275 static inline tree
5276 gimple_omp_for_index (const gimple *gs, size_t i)
5277 {
5278   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5279   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5280   return omp_for_stmt->iter[i].index;
5281 }
5282
5283
5284 /* Return a pointer to the index variable for the OMP_FOR statement GS.  */
5285
5286 static inline tree *
5287 gimple_omp_for_index_ptr (gimple *gs, size_t i)
5288 {
5289   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5290   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5291   return &omp_for_stmt->iter[i].index;
5292 }
5293
5294
5295 /* Set INDEX to be the index variable for the OMP_FOR statement GS.  */
5296
5297 static inline void
5298 gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
5299 {
5300   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5301   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5302   omp_for_stmt->iter[i].index = index;
5303 }
5304
5305
5306 /* Return the initial value for the OMP_FOR statement GS.  */
5307
5308 static inline tree
5309 gimple_omp_for_initial (const gimple *gs, size_t i)
5310 {
5311   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5312   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5313   return omp_for_stmt->iter[i].initial;
5314 }
5315
5316
5317 /* Return a pointer to the initial value for the OMP_FOR statement GS.  */
5318
5319 static inline tree *
5320 gimple_omp_for_initial_ptr (gimple *gs, size_t i)
5321 {
5322   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5323   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5324   return &omp_for_stmt->iter[i].initial;
5325 }
5326
5327
5328 /* Set INITIAL to be the initial value for the OMP_FOR statement GS.  */
5329
5330 static inline void
5331 gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
5332 {
5333   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5334   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5335   omp_for_stmt->iter[i].initial = initial;
5336 }
5337
5338
5339 /* Return the final value for the OMP_FOR statement GS.  */
5340
5341 static inline tree
5342 gimple_omp_for_final (const gimple *gs, size_t i)
5343 {
5344   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5345   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5346   return omp_for_stmt->iter[i].final;
5347 }
5348
5349
5350 /* Return a pointer to the final value for the OMP_FOR statement GS.  */
5351
5352 static inline tree *
5353 gimple_omp_for_final_ptr (gimple *gs, size_t i)
5354 {
5355   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5356   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5357   return &omp_for_stmt->iter[i].final;
5358 }
5359
5360
5361 /* Set FINAL to be the final value for the OMP_FOR statement GS.  */
5362
5363 static inline void
5364 gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
5365 {
5366   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5367   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5368   omp_for_stmt->iter[i].final = final;
5369 }
5370
5371
5372 /* Return the increment value for the OMP_FOR statement GS.  */
5373
5374 static inline tree
5375 gimple_omp_for_incr (const gimple *gs, size_t i)
5376 {
5377   const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5378   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5379   return omp_for_stmt->iter[i].incr;
5380 }
5381
5382
5383 /* Return a pointer to the increment value for the OMP_FOR statement GS.  */
5384
5385 static inline tree *
5386 gimple_omp_for_incr_ptr (gimple *gs, size_t i)
5387 {
5388   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5389   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5390   return &omp_for_stmt->iter[i].incr;
5391 }
5392
5393
5394 /* Set INCR to be the increment value for the OMP_FOR statement GS.  */
5395
5396 static inline void
5397 gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
5398 {
5399   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5400   gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5401   omp_for_stmt->iter[i].incr = incr;
5402 }
5403
5404
5405 /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5406    statement GS starts.  */
5407
5408 static inline gimple_seq *
5409 gimple_omp_for_pre_body_ptr (gimple *gs)
5410 {
5411   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5412   return &omp_for_stmt->pre_body;
5413 }
5414
5415
5416 /* Return the sequence of statements to execute before the OMP_FOR
5417    statement GS starts.  */
5418
5419 static inline gimple_seq
5420 gimple_omp_for_pre_body (const gimple *gs)
5421 {
5422   return *gimple_omp_for_pre_body_ptr (const_cast <gimple *> (gs));
5423 }
5424
5425
5426 /* Set PRE_BODY to be the sequence of statements to execute before the
5427    OMP_FOR statement GS starts.  */
5428
5429 static inline void
5430 gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
5431 {
5432   gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5433   omp_for_stmt->pre_body = pre_body;
5434 }
5435
5436 /* Return the kernel_phony of OMP_FOR statement.  */
5437
5438 static inline bool
5439 gimple_omp_for_grid_phony (const gomp_for *omp_for)
5440 {
5441   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5442                        != GF_OMP_FOR_KIND_GRID_LOOP);
5443   return (gimple_omp_subcode (omp_for) & GF_OMP_FOR_GRID_PHONY) != 0;
5444 }
5445
5446 /* Set kernel_phony flag of OMP_FOR to VALUE.  */
5447
5448 static inline void
5449 gimple_omp_for_set_grid_phony (gomp_for *omp_for, bool value)
5450 {
5451   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5452                        != GF_OMP_FOR_KIND_GRID_LOOP);
5453   if (value)
5454     omp_for->subcode |= GF_OMP_FOR_GRID_PHONY;
5455   else
5456     omp_for->subcode &= ~GF_OMP_FOR_GRID_PHONY;
5457 }
5458
5459 /* Return the kernel_intra_group of a GRID_LOOP OMP_FOR statement.  */
5460
5461 static inline bool
5462 gimple_omp_for_grid_intra_group (const gomp_for *omp_for)
5463 {
5464   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5465                        == GF_OMP_FOR_KIND_GRID_LOOP);
5466   return (gimple_omp_subcode (omp_for) & GF_OMP_FOR_GRID_INTRA_GROUP) != 0;
5467 }
5468
5469 /* Set kernel_intra_group flag of OMP_FOR to VALUE.  */
5470
5471 static inline void
5472 gimple_omp_for_set_grid_intra_group (gomp_for *omp_for, bool value)
5473 {
5474   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5475                        == GF_OMP_FOR_KIND_GRID_LOOP);
5476   if (value)
5477     omp_for->subcode |= GF_OMP_FOR_GRID_INTRA_GROUP;
5478   else
5479     omp_for->subcode &= ~GF_OMP_FOR_GRID_INTRA_GROUP;
5480 }
5481
5482 /* Return true if iterations of a grid OMP_FOR statement correspond to HSA
5483    groups.  */
5484
5485 static inline bool
5486 gimple_omp_for_grid_group_iter (const gomp_for *omp_for)
5487 {
5488   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5489                        == GF_OMP_FOR_KIND_GRID_LOOP);
5490   return (gimple_omp_subcode (omp_for) & GF_OMP_FOR_GRID_GROUP_ITER) != 0;
5491 }
5492
5493 /* Set group_iter flag of OMP_FOR to VALUE.  */
5494
5495 static inline void
5496 gimple_omp_for_set_grid_group_iter (gomp_for *omp_for, bool value)
5497 {
5498   gcc_checking_assert (gimple_omp_for_kind (omp_for)
5499                        == GF_OMP_FOR_KIND_GRID_LOOP);
5500   if (value)
5501     omp_for->subcode |= GF_OMP_FOR_GRID_GROUP_ITER;
5502   else
5503     omp_for->subcode &= ~GF_OMP_FOR_GRID_GROUP_ITER;
5504 }
5505
5506 /* Return the clauses associated with OMP_PARALLEL GS.  */
5507
5508 static inline tree
5509 gimple_omp_parallel_clauses (const gimple *gs)
5510 {
5511   const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
5512   return omp_parallel_stmt->clauses;
5513 }
5514
5515
5516 /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT.  */
5517
5518 static inline tree *
5519 gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
5520 {
5521   return &omp_parallel_stmt->clauses;
5522 }
5523
5524
5525 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT.  */
5526
5527 static inline void
5528 gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
5529                                  tree clauses)
5530 {
5531   omp_parallel_stmt->clauses = clauses;
5532 }
5533
5534
5535 /* Return the child function used to hold the body of OMP_PARALLEL_STMT.  */
5536
5537 static inline tree
5538 gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
5539 {
5540   return omp_parallel_stmt->child_fn;
5541 }
5542
5543 /* Return a pointer to the child function used to hold the body of
5544    OMP_PARALLEL_STMT.  */
5545
5546 static inline tree *
5547 gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
5548 {
5549   return &omp_parallel_stmt->child_fn;
5550 }
5551
5552
5553 /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT.  */
5554
5555 static inline void
5556 gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
5557                                   tree child_fn)
5558 {
5559   omp_parallel_stmt->child_fn = child_fn;
5560 }
5561
5562
5563 /* Return the artificial argument used to send variables and values
5564    from the parent to the children threads in OMP_PARALLEL_STMT.  */
5565
5566 static inline tree
5567 gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
5568 {
5569   return omp_parallel_stmt->data_arg;
5570 }
5571
5572
5573 /* Return a pointer to the data argument for OMP_PARALLEL_STMT.  */
5574
5575 static inline tree *
5576 gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
5577 {
5578   return &omp_parallel_stmt->data_arg;
5579 }
5580
5581
5582 /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT.  */
5583
5584 static inline void
5585 gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
5586                                   tree data_arg)
5587 {
5588   omp_parallel_stmt->data_arg = data_arg;
5589 }
5590
5591 /* Return the kernel_phony flag of OMP_PARALLEL_STMT.  */
5592
5593 static inline bool
5594 gimple_omp_parallel_grid_phony (const gomp_parallel *stmt)
5595 {
5596   return (gimple_omp_subcode (stmt) & GF_OMP_PARALLEL_GRID_PHONY) != 0;
5597 }
5598
5599 /* Set kernel_phony flag of OMP_PARALLEL_STMT to VALUE.  */
5600
5601 static inline void
5602 gimple_omp_parallel_set_grid_phony (gomp_parallel *stmt, bool value)
5603 {
5604   if (value)
5605     stmt->subcode |= GF_OMP_PARALLEL_GRID_PHONY;
5606   else
5607     stmt->subcode &= ~GF_OMP_PARALLEL_GRID_PHONY;
5608 }
5609
5610 /* Return the clauses associated with OMP_TASK GS.  */
5611
5612 static inline tree
5613 gimple_omp_task_clauses (const gimple *gs)
5614 {
5615   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5616   return omp_task_stmt->clauses;
5617 }
5618
5619
5620 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
5621
5622 static inline tree *
5623 gimple_omp_task_clauses_ptr (gimple *gs)
5624 {
5625   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5626   return &omp_task_stmt->clauses;
5627 }
5628
5629
5630 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5631    GS.  */
5632
5633 static inline void
5634 gimple_omp_task_set_clauses (gimple *gs, tree clauses)
5635 {
5636   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5637   omp_task_stmt->clauses = clauses;
5638 }
5639
5640
5641 /* Return true if OMP task statement G has the
5642    GF_OMP_TASK_TASKLOOP flag set.  */
5643
5644 static inline bool
5645 gimple_omp_task_taskloop_p (const gimple *g)
5646 {
5647   GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5648   return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0;
5649 }
5650
5651
5652 /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5653    value of TASKLOOP_P.  */
5654
5655 static inline void
5656 gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
5657 {
5658   GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5659   if (taskloop_p)
5660     g->subcode |= GF_OMP_TASK_TASKLOOP;
5661   else
5662     g->subcode &= ~GF_OMP_TASK_TASKLOOP;
5663 }
5664
5665
5666 /* Return true if OMP task statement G has the
5667    GF_OMP_TASK_TASKWAIT flag set.  */
5668
5669 static inline bool
5670 gimple_omp_task_taskwait_p (const gimple *g)
5671 {
5672   GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5673   return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKWAIT) != 0;
5674 }
5675
5676
5677 /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5678    value of TASKWAIT_P.  */
5679
5680 static inline void
5681 gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
5682 {
5683   GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5684   if (taskwait_p)
5685     g->subcode |= GF_OMP_TASK_TASKWAIT;
5686   else
5687     g->subcode &= ~GF_OMP_TASK_TASKWAIT;
5688 }
5689
5690
5691 /* Return the child function used to hold the body of OMP_TASK GS.  */
5692
5693 static inline tree
5694 gimple_omp_task_child_fn (const gimple *gs)
5695 {
5696   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5697   return omp_task_stmt->child_fn;
5698 }
5699
5700 /* Return a pointer to the child function used to hold the body of
5701    OMP_TASK GS.  */
5702
5703 static inline tree *
5704 gimple_omp_task_child_fn_ptr (gimple *gs)
5705 {
5706   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5707   return &omp_task_stmt->child_fn;
5708 }
5709
5710
5711 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
5712
5713 static inline void
5714 gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
5715 {
5716   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5717   omp_task_stmt->child_fn = child_fn;
5718 }
5719
5720
5721 /* Return the artificial argument used to send variables and values
5722    from the parent to the children threads in OMP_TASK GS.  */
5723
5724 static inline tree
5725 gimple_omp_task_data_arg (const gimple *gs)
5726 {
5727   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5728   return omp_task_stmt->data_arg;
5729 }
5730
5731
5732 /* Return a pointer to the data argument for OMP_TASK GS.  */
5733
5734 static inline tree *
5735 gimple_omp_task_data_arg_ptr (gimple *gs)
5736 {
5737   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5738   return &omp_task_stmt->data_arg;
5739 }
5740
5741
5742 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
5743
5744 static inline void
5745 gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
5746 {
5747   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5748   omp_task_stmt->data_arg = data_arg;
5749 }
5750
5751
5752 /* Return the clauses associated with OMP_TASK GS.  */
5753
5754 static inline tree
5755 gimple_omp_taskreg_clauses (const gimple *gs)
5756 {
5757   const gimple_statement_omp_taskreg *omp_taskreg_stmt
5758     = as_a <const gimple_statement_omp_taskreg *> (gs);
5759   return omp_taskreg_stmt->clauses;
5760 }
5761
5762
5763 /* Return a pointer to the clauses associated with OMP_TASK GS.  */
5764
5765 static inline tree *
5766 gimple_omp_taskreg_clauses_ptr (gimple *gs)
5767 {
5768   gimple_statement_omp_taskreg *omp_taskreg_stmt
5769     = as_a <gimple_statement_omp_taskreg *> (gs);
5770   return &omp_taskreg_stmt->clauses;
5771 }
5772
5773
5774 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5775    GS.  */
5776
5777 static inline void
5778 gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
5779 {
5780   gimple_statement_omp_taskreg *omp_taskreg_stmt
5781     = as_a <gimple_statement_omp_taskreg *> (gs);
5782   omp_taskreg_stmt->clauses = clauses;
5783 }
5784
5785
5786 /* Return the child function used to hold the body of OMP_TASK GS.  */
5787
5788 static inline tree
5789 gimple_omp_taskreg_child_fn (const gimple *gs)
5790 {
5791   const gimple_statement_omp_taskreg *omp_taskreg_stmt
5792     = as_a <const gimple_statement_omp_taskreg *> (gs);
5793   return omp_taskreg_stmt->child_fn;
5794 }
5795
5796 /* Return a pointer to the child function used to hold the body of
5797    OMP_TASK GS.  */
5798
5799 static inline tree *
5800 gimple_omp_taskreg_child_fn_ptr (gimple *gs)
5801 {
5802   gimple_statement_omp_taskreg *omp_taskreg_stmt
5803     = as_a <gimple_statement_omp_taskreg *> (gs);
5804   return &omp_taskreg_stmt->child_fn;
5805 }
5806
5807
5808 /* Set CHILD_FN to be the child function for OMP_TASK GS.  */
5809
5810 static inline void
5811 gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
5812 {
5813   gimple_statement_omp_taskreg *omp_taskreg_stmt
5814     = as_a <gimple_statement_omp_taskreg *> (gs);
5815   omp_taskreg_stmt->child_fn = child_fn;
5816 }
5817
5818
5819 /* Return the artificial argument used to send variables and values
5820    from the parent to the children threads in OMP_TASK GS.  */
5821
5822 static inline tree
5823 gimple_omp_taskreg_data_arg (const gimple *gs)
5824 {
5825   const gimple_statement_omp_taskreg *omp_taskreg_stmt
5826     = as_a <const gimple_statement_omp_taskreg *> (gs);
5827   return omp_taskreg_stmt->data_arg;
5828 }
5829
5830
5831 /* Return a pointer to the data argument for OMP_TASK GS.  */
5832
5833 static inline tree *
5834 gimple_omp_taskreg_data_arg_ptr (gimple *gs)
5835 {
5836   gimple_statement_omp_taskreg *omp_taskreg_stmt
5837     = as_a <gimple_statement_omp_taskreg *> (gs);
5838   return &omp_taskreg_stmt->data_arg;
5839 }
5840
5841
5842 /* Set DATA_ARG to be the data argument for OMP_TASK GS.  */
5843
5844 static inline void
5845 gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
5846 {
5847   gimple_statement_omp_taskreg *omp_taskreg_stmt
5848     = as_a <gimple_statement_omp_taskreg *> (gs);
5849   omp_taskreg_stmt->data_arg = data_arg;
5850 }
5851
5852
5853 /* Return the copy function used to hold the body of OMP_TASK GS.  */
5854
5855 static inline tree
5856 gimple_omp_task_copy_fn (const gimple *gs)
5857 {
5858   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5859   return omp_task_stmt->copy_fn;
5860 }
5861
5862 /* Return a pointer to the copy function used to hold the body of
5863    OMP_TASK GS.  */
5864
5865 static inline tree *
5866 gimple_omp_task_copy_fn_ptr (gimple *gs)
5867 {
5868   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5869   return &omp_task_stmt->copy_fn;
5870 }
5871
5872
5873 /* Set CHILD_FN to be the copy function for OMP_TASK GS.  */
5874
5875 static inline void
5876 gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
5877 {
5878   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5879   omp_task_stmt->copy_fn = copy_fn;
5880 }
5881
5882
5883 /* Return size of the data block in bytes in OMP_TASK GS.  */
5884
5885 static inline tree
5886 gimple_omp_task_arg_size (const gimple *gs)
5887 {
5888   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5889   return omp_task_stmt->arg_size;
5890 }
5891
5892
5893 /* Return a pointer to the data block size for OMP_TASK GS.  */
5894
5895 static inline tree *
5896 gimple_omp_task_arg_size_ptr (gimple *gs)
5897 {
5898   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5899   return &omp_task_stmt->arg_size;
5900 }
5901
5902
5903 /* Set ARG_SIZE to be the data block size for OMP_TASK GS.  */
5904
5905 static inline void
5906 gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
5907 {
5908   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5909   omp_task_stmt->arg_size = arg_size;
5910 }
5911
5912
5913 /* Return align of the data block in bytes in OMP_TASK GS.  */
5914
5915 static inline tree
5916 gimple_omp_task_arg_align (const gimple *gs)
5917 {
5918   const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5919   return omp_task_stmt->arg_align;
5920 }
5921
5922
5923 /* Return a pointer to the data block align for OMP_TASK GS.  */
5924
5925 static inline tree *
5926 gimple_omp_task_arg_align_ptr (gimple *gs)
5927 {
5928   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5929   return &omp_task_stmt->arg_align;
5930 }
5931
5932
5933 /* Set ARG_SIZE to be the data block align for OMP_TASK GS.  */
5934
5935 static inline void
5936 gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
5937 {
5938   gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5939   omp_task_stmt->arg_align = arg_align;
5940 }
5941
5942
5943 /* Return the clauses associated with OMP_SINGLE GS.  */
5944
5945 static inline tree
5946 gimple_omp_single_clauses (const gimple *gs)
5947 {
5948   const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
5949   return omp_single_stmt->clauses;
5950 }
5951
5952
5953 /* Return a pointer to the clauses associated with OMP_SINGLE GS.  */
5954
5955 static inline tree *
5956 gimple_omp_single_clauses_ptr (gimple *gs)
5957 {
5958   gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
5959   return &omp_single_stmt->clauses;
5960 }
5961
5962
5963 /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT.  */
5964
5965 static inline void
5966 gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
5967 {
5968   omp_single_stmt->clauses = clauses;
5969 }
5970
5971
5972 /* Return the clauses associated with OMP_TARGET GS.  */
5973
5974 static inline tree
5975 gimple_omp_target_clauses (const gimple *gs)
5976 {
5977   const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
5978   return omp_target_stmt->clauses;
5979 }
5980
5981
5982 /* Return a pointer to the clauses associated with OMP_TARGET GS.  */
5983
5984 static inline tree *
5985 gimple_omp_target_clauses_ptr (gimple *gs)
5986 {
5987   gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
5988   return &omp_target_stmt->clauses;
5989 }
5990
5991
5992 /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT.  */
5993
5994 static inline void
5995 gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
5996                                tree clauses)
5997 {
5998   omp_target_stmt->clauses = clauses;
5999 }
6000
6001
6002 /* Return the kind of the OMP_TARGET G.  */
6003
6004 static inline int
6005 gimple_omp_target_kind (const gimple *g)
6006 {
6007   GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
6008   return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
6009 }
6010
6011
6012 /* Set the kind of the OMP_TARGET G.  */
6013
6014 static inline void
6015 gimple_omp_target_set_kind (gomp_target *g, int kind)
6016 {
6017   g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
6018                       | (kind & GF_OMP_TARGET_KIND_MASK);
6019 }
6020
6021
6022 /* Return the child function used to hold the body of OMP_TARGET_STMT.  */
6023
6024 static inline tree
6025 gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
6026 {
6027   return omp_target_stmt->child_fn;
6028 }
6029
6030 /* Return a pointer to the child function used to hold the body of
6031    OMP_TARGET_STMT.  */
6032
6033 static inline tree *
6034 gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
6035 {
6036   return &omp_target_stmt->child_fn;
6037 }
6038
6039
6040 /* Set CHILD_FN to be the child function for OMP_TARGET_STMT.  */
6041
6042 static inline void
6043 gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
6044                                 tree child_fn)
6045 {
6046   omp_target_stmt->child_fn = child_fn;
6047 }
6048
6049
6050 /* Return the artificial argument used to send variables and values
6051    from the parent to the children threads in OMP_TARGET_STMT.  */
6052
6053 static inline tree
6054 gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
6055 {
6056   return omp_target_stmt->data_arg;
6057 }
6058
6059
6060 /* Return a pointer to the data argument for OMP_TARGET GS.  */
6061
6062 static inline tree *
6063 gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
6064 {
6065   return &omp_target_stmt->data_arg;
6066 }
6067
6068
6069 /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT.  */
6070
6071 static inline void
6072 gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
6073                                 tree data_arg)
6074 {
6075   omp_target_stmt->data_arg = data_arg;
6076 }
6077
6078
6079 /* Return the clauses associated with OMP_TEAMS GS.  */
6080
6081 static inline tree
6082 gimple_omp_teams_clauses (const gimple *gs)
6083 {
6084   const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
6085   return omp_teams_stmt->clauses;
6086 }
6087
6088
6089 /* Return a pointer to the clauses associated with OMP_TEAMS GS.  */
6090
6091 static inline tree *
6092 gimple_omp_teams_clauses_ptr (gimple *gs)
6093 {
6094   gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
6095   return &omp_teams_stmt->clauses;
6096 }
6097
6098
6099 /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT.  */
6100
6101 static inline void
6102 gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
6103 {
6104   omp_teams_stmt->clauses = clauses;
6105 }
6106
6107 /* Return the child function used to hold the body of OMP_TEAMS_STMT.  */
6108
6109 static inline tree
6110 gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
6111 {
6112   return omp_teams_stmt->child_fn;
6113 }
6114
6115 /* Return a pointer to the child function used to hold the body of
6116    OMP_TEAMS_STMT.  */
6117
6118 static inline tree *
6119 gimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
6120 {
6121   return &omp_teams_stmt->child_fn;
6122 }
6123
6124
6125 /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT.  */
6126
6127 static inline void
6128 gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
6129 {
6130   omp_teams_stmt->child_fn = child_fn;
6131 }
6132
6133
6134 /* Return the artificial argument used to send variables and values
6135    from the parent to the children threads in OMP_TEAMS_STMT.  */
6136
6137 static inline tree
6138 gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
6139 {
6140   return omp_teams_stmt->data_arg;
6141 }
6142
6143
6144 /* Return a pointer to the data argument for OMP_TEAMS_STMT.  */
6145
6146 static inline tree *
6147 gimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
6148 {
6149   return &omp_teams_stmt->data_arg;
6150 }
6151
6152
6153 /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT.  */
6154
6155 static inline void
6156 gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
6157 {
6158   omp_teams_stmt->data_arg = data_arg;
6159 }
6160
6161 /* Return the kernel_phony flag of an OMP_TEAMS_STMT.  */
6162
6163 static inline bool
6164 gimple_omp_teams_grid_phony (const gomp_teams *omp_teams_stmt)
6165 {
6166   return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_GRID_PHONY) != 0;
6167 }
6168
6169 /* Set kernel_phony flag of an OMP_TEAMS_STMT to VALUE.  */
6170
6171 static inline void
6172 gimple_omp_teams_set_grid_phony (gomp_teams *omp_teams_stmt, bool value)
6173 {
6174   if (value)
6175     omp_teams_stmt->subcode |= GF_OMP_TEAMS_GRID_PHONY;
6176   else
6177     omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_GRID_PHONY;
6178 }
6179
6180 /* Return the host flag of an OMP_TEAMS_STMT.  */
6181
6182 static inline bool
6183 gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
6184 {
6185   return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
6186 }
6187
6188 /* Set host flag of an OMP_TEAMS_STMT to VALUE.  */
6189
6190 static inline void
6191 gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
6192 {
6193   if (value)
6194     omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
6195   else
6196     omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
6197 }
6198
6199 /* Return the clauses associated with OMP_SECTIONS GS.  */
6200
6201 static inline tree
6202 gimple_omp_sections_clauses (const gimple *gs)
6203 {
6204   const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6205   return omp_sections_stmt->clauses;
6206 }
6207
6208
6209 /* Return a pointer to the clauses associated with OMP_SECTIONS GS.  */
6210
6211 static inline tree *
6212 gimple_omp_sections_clauses_ptr (gimple *gs)
6213 {
6214   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6215   return &omp_sections_stmt->clauses;
6216 }
6217
6218
6219 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6220    GS.  */
6221
6222 static inline void
6223 gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
6224 {
6225   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6226   omp_sections_stmt->clauses = clauses;
6227 }
6228
6229
6230 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6231    in GS.  */
6232
6233 static inline tree
6234 gimple_omp_sections_control (const gimple *gs)
6235 {
6236   const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6237   return omp_sections_stmt->control;
6238 }
6239
6240
6241 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6242    GS.  */
6243
6244 static inline tree *
6245 gimple_omp_sections_control_ptr (gimple *gs)
6246 {
6247   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6248   return &omp_sections_stmt->control;
6249 }
6250
6251
6252 /* Set CONTROL to be the set of clauses associated with the
6253    GIMPLE_OMP_SECTIONS in GS.  */
6254
6255 static inline void
6256 gimple_omp_sections_set_control (gimple *gs, tree control)
6257 {
6258   gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6259   omp_sections_stmt->control = control;
6260 }
6261
6262
6263 /* Set the value being stored in an atomic store.  */
6264
6265 static inline void
6266 gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
6267 {
6268   store_stmt->val = val;
6269 }
6270
6271
6272 /* Return the value being stored in an atomic store.  */
6273
6274 static inline tree
6275 gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
6276 {
6277   return store_stmt->val;
6278 }
6279
6280
6281 /* Return a pointer to the value being stored in an atomic store.  */
6282
6283 static inline tree *
6284 gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
6285 {
6286   return &store_stmt->val;
6287 }
6288
6289
6290 /* Set the LHS of an atomic load.  */
6291
6292 static inline void
6293 gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
6294 {
6295   load_stmt->lhs = lhs;
6296 }
6297
6298
6299 /* Get the LHS of an atomic load.  */
6300
6301 static inline tree
6302 gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
6303 {
6304   return load_stmt->lhs;
6305 }
6306
6307
6308 /* Return a pointer to the LHS of an atomic load.  */
6309
6310 static inline tree *
6311 gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
6312 {
6313   return &load_stmt->lhs;
6314 }
6315
6316
6317 /* Set the RHS of an atomic load.  */
6318
6319 static inline void
6320 gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
6321 {
6322   load_stmt->rhs = rhs;
6323 }
6324
6325
6326 /* Get the RHS of an atomic load.  */
6327
6328 static inline tree
6329 gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
6330 {
6331   return load_stmt->rhs;
6332 }
6333
6334
6335 /* Return a pointer to the RHS of an atomic load.  */
6336
6337 static inline tree *
6338 gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
6339 {
6340   return &load_stmt->rhs;
6341 }
6342
6343
6344 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
6345
6346 static inline tree
6347 gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
6348 {
6349   return cont_stmt->control_def;
6350 }
6351
6352 /* The same as above, but return the address.  */
6353
6354 static inline tree *
6355 gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
6356 {
6357   return &cont_stmt->control_def;
6358 }
6359
6360 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.  */
6361
6362 static inline void
6363 gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
6364 {
6365   cont_stmt->control_def = def;
6366 }
6367
6368
6369 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
6370
6371 static inline tree
6372 gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
6373 {
6374   return cont_stmt->control_use;
6375 }
6376
6377
6378 /* The same as above, but return the address.  */
6379
6380 static inline tree *
6381 gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
6382 {
6383   return &cont_stmt->control_use;
6384 }
6385
6386
6387 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE.  */
6388
6389 static inline void
6390 gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
6391 {
6392   cont_stmt->control_use = use;
6393 }
6394
6395 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6396    TRANSACTION_STMT.  */
6397
6398 static inline gimple_seq *
6399 gimple_transaction_body_ptr (gtransaction *transaction_stmt)
6400 {
6401   return &transaction_stmt->body;
6402 }
6403
6404 /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT.  */
6405
6406 static inline gimple_seq
6407 gimple_transaction_body (const gtransaction *transaction_stmt)
6408 {
6409   return transaction_stmt->body;
6410 }
6411
6412 /* Return the label associated with a GIMPLE_TRANSACTION.  */
6413
6414 static inline tree
6415 gimple_transaction_label_norm (const gtransaction *transaction_stmt)
6416 {
6417   return transaction_stmt->label_norm;
6418 }
6419
6420 static inline tree *
6421 gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
6422 {
6423   return &transaction_stmt->label_norm;
6424 }
6425
6426 static inline tree
6427 gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
6428 {
6429   return transaction_stmt->label_uninst;
6430 }
6431
6432 static inline tree *
6433 gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
6434 {
6435   return &transaction_stmt->label_uninst;
6436 }
6437
6438 static inline tree
6439 gimple_transaction_label_over (const gtransaction *transaction_stmt)
6440 {
6441   return transaction_stmt->label_over;
6442 }
6443
6444 static inline tree *
6445 gimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
6446 {
6447   return &transaction_stmt->label_over;
6448 }
6449
6450 /* Return the subcode associated with a GIMPLE_TRANSACTION.  */
6451
6452 static inline unsigned int
6453 gimple_transaction_subcode (const gtransaction *transaction_stmt)
6454 {
6455   return transaction_stmt->subcode;
6456 }
6457
6458 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6459    TRANSACTION_STMT.  */
6460
6461 static inline void
6462 gimple_transaction_set_body (gtransaction *transaction_stmt,
6463                              gimple_seq body)
6464 {
6465   transaction_stmt->body = body;
6466 }
6467
6468 /* Set the label associated with a GIMPLE_TRANSACTION.  */
6469
6470 static inline void
6471 gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
6472 {
6473   transaction_stmt->label_norm = label;
6474 }
6475
6476 static inline void
6477 gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
6478 {
6479   transaction_stmt->label_uninst = label;
6480 }
6481
6482 static inline void
6483 gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
6484 {
6485   transaction_stmt->label_over = label;
6486 }
6487
6488 /* Set the subcode associated with a GIMPLE_TRANSACTION.  */
6489
6490 static inline void
6491 gimple_transaction_set_subcode (gtransaction *transaction_stmt,
6492                                 unsigned int subcode)
6493 {
6494   transaction_stmt->subcode = subcode;
6495 }
6496
6497 /* Return a pointer to the return value for GIMPLE_RETURN GS.  */
6498
6499 static inline tree *
6500 gimple_return_retval_ptr (greturn *gs)
6501 {
6502   return &gs->op[0];
6503 }
6504
6505 /* Return the return value for GIMPLE_RETURN GS.  */
6506
6507 static inline tree
6508 gimple_return_retval (const greturn *gs)
6509 {
6510   return gs->op[0];
6511 }
6512
6513
6514 /* Set RETVAL to be the return value for GIMPLE_RETURN GS.  */
6515
6516 static inline void
6517 gimple_return_set_retval (greturn *gs, tree retval)
6518 {
6519   gs->op[0] = retval;
6520 }
6521
6522
6523 /* Returns true when the gimple statement STMT is any of the OMP types.  */
6524
6525 #define CASE_GIMPLE_OMP                         \
6526     case GIMPLE_OMP_PARALLEL:                   \
6527     case GIMPLE_OMP_TASK:                       \
6528     case GIMPLE_OMP_FOR:                        \
6529     case GIMPLE_OMP_SECTIONS:                   \
6530     case GIMPLE_OMP_SECTIONS_SWITCH:            \
6531     case GIMPLE_OMP_SINGLE:                     \
6532     case GIMPLE_OMP_TARGET:                     \
6533     case GIMPLE_OMP_TEAMS:                      \
6534     case GIMPLE_OMP_SECTION:                    \
6535     case GIMPLE_OMP_MASTER:                     \
6536     case GIMPLE_OMP_TASKGROUP:                  \
6537     case GIMPLE_OMP_ORDERED:                    \
6538     case GIMPLE_OMP_CRITICAL:                   \
6539     case GIMPLE_OMP_SCAN:                       \
6540     case GIMPLE_OMP_RETURN:                     \
6541     case GIMPLE_OMP_ATOMIC_LOAD:                \
6542     case GIMPLE_OMP_ATOMIC_STORE:               \
6543     case GIMPLE_OMP_CONTINUE:                   \
6544     case GIMPLE_OMP_GRID_BODY
6545
6546 static inline bool
6547 is_gimple_omp (const gimple *stmt)
6548 {
6549   switch (gimple_code (stmt))
6550     {
6551     CASE_GIMPLE_OMP:
6552       return true;
6553     default:
6554       return false;
6555     }
6556 }
6557
6558 /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6559    specifically.  */
6560
6561 static inline bool
6562 is_gimple_omp_oacc (const gimple *stmt)
6563 {
6564   gcc_assert (is_gimple_omp (stmt));
6565   switch (gimple_code (stmt))
6566     {
6567     case GIMPLE_OMP_FOR:
6568       switch (gimple_omp_for_kind (stmt))
6569         {
6570         case GF_OMP_FOR_KIND_OACC_LOOP:
6571           return true;
6572         default:
6573           return false;
6574         }
6575     case GIMPLE_OMP_TARGET:
6576       switch (gimple_omp_target_kind (stmt))
6577         {
6578         case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6579         case GF_OMP_TARGET_KIND_OACC_KERNELS:
6580         case GF_OMP_TARGET_KIND_OACC_SERIAL:
6581         case GF_OMP_TARGET_KIND_OACC_DATA:
6582         case GF_OMP_TARGET_KIND_OACC_UPDATE:
6583         case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA:
6584         case GF_OMP_TARGET_KIND_OACC_DECLARE:
6585         case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
6586           return true;
6587         default:
6588           return false;
6589         }
6590     default:
6591       return false;
6592     }
6593 }
6594
6595
6596 /* Return true if the OMP gimple statement STMT is offloaded.  */
6597
6598 static inline bool
6599 is_gimple_omp_offloaded (const gimple *stmt)
6600 {
6601   gcc_assert (is_gimple_omp (stmt));
6602   switch (gimple_code (stmt))
6603     {
6604     case GIMPLE_OMP_TARGET:
6605       switch (gimple_omp_target_kind (stmt))
6606         {
6607         case GF_OMP_TARGET_KIND_REGION:
6608         case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6609         case GF_OMP_TARGET_KIND_OACC_KERNELS:
6610         case GF_OMP_TARGET_KIND_OACC_SERIAL:
6611           return true;
6612         default:
6613           return false;
6614         }
6615     default:
6616       return false;
6617     }
6618 }
6619
6620
6621 /* Returns TRUE if statement G is a GIMPLE_NOP.  */
6622
6623 static inline bool
6624 gimple_nop_p (const gimple *g)
6625 {
6626   return gimple_code (g) == GIMPLE_NOP;
6627 }
6628
6629
6630 /* Return true if GS is a GIMPLE_RESX.  */
6631
6632 static inline bool
6633 is_gimple_resx (const gimple *gs)
6634 {
6635   return gimple_code (gs) == GIMPLE_RESX;
6636 }
6637
6638 /* Return the type of the main expression computed by STMT.  Return
6639    void_type_node if the statement computes nothing.  */
6640
6641 static inline tree
6642 gimple_expr_type (const gimple *stmt)
6643 {
6644   enum gimple_code code = gimple_code (stmt);
6645   /* In general we want to pass out a type that can be substituted
6646      for both the RHS and the LHS types if there is a possibly
6647      useless conversion involved.  That means returning the
6648      original RHS type as far as we can reconstruct it.  */
6649   if (code == GIMPLE_CALL)
6650     {
6651       const gcall *call_stmt = as_a <const gcall *> (stmt);
6652       if (gimple_call_internal_p (call_stmt))
6653         switch (gimple_call_internal_fn (call_stmt))
6654           {
6655           case IFN_MASK_STORE:
6656           case IFN_SCATTER_STORE:
6657             return TREE_TYPE (gimple_call_arg (call_stmt, 3));
6658           case IFN_MASK_SCATTER_STORE:
6659             return TREE_TYPE (gimple_call_arg (call_stmt, 4));
6660           default:
6661             break;
6662           }
6663       return gimple_call_return_type (call_stmt);
6664     }
6665   else if (code == GIMPLE_ASSIGN)
6666     {
6667       if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
6668         return TREE_TYPE (gimple_assign_rhs1 (stmt));
6669       else
6670         /* As fallback use the type of the LHS.  */
6671         return TREE_TYPE (gimple_get_lhs (stmt));
6672     }
6673   else if (code == GIMPLE_COND)
6674     return boolean_type_node;
6675   else
6676     return void_type_node;
6677 }
6678
6679 /* Enum and arrays used for allocation stats.  Keep in sync with
6680    gimple.c:gimple_alloc_kind_names.  */
6681 enum gimple_alloc_kind
6682 {
6683   gimple_alloc_kind_assign,     /* Assignments.  */
6684   gimple_alloc_kind_phi,        /* PHI nodes.  */
6685   gimple_alloc_kind_cond,       /* Conditionals.  */
6686   gimple_alloc_kind_rest,       /* Everything else.  */
6687   gimple_alloc_kind_all
6688 };
6689
6690 extern uint64_t gimple_alloc_counts[];
6691 extern uint64_t gimple_alloc_sizes[];
6692
6693 /* Return the allocation kind for a given stmt CODE.  */
6694 static inline enum gimple_alloc_kind
6695 gimple_alloc_kind (enum gimple_code code)
6696 {
6697   switch (code)
6698     {
6699       case GIMPLE_ASSIGN:
6700         return gimple_alloc_kind_assign;
6701       case GIMPLE_PHI:
6702         return gimple_alloc_kind_phi;
6703       case GIMPLE_COND:
6704         return gimple_alloc_kind_cond;
6705       default:
6706         return gimple_alloc_kind_rest;
6707     }
6708 }
6709
6710 /* Return true if a location should not be emitted for this statement
6711    by annotate_all_with_location.  */
6712
6713 static inline bool
6714 gimple_do_not_emit_location_p (gimple *g)
6715 {
6716   return gimple_plf (g, GF_PLF_1);
6717 }
6718
6719 /* Mark statement G so a location will not be emitted by
6720    annotate_one_with_location.  */
6721
6722 static inline void
6723 gimple_set_do_not_emit_location (gimple *g)
6724 {
6725   /* The PLF flags are initialized to 0 when a new tuple is created,
6726      so no need to initialize it anywhere.  */
6727   gimple_set_plf (g, GF_PLF_1, true);
6728 }
6729
6730 #endif  /* GCC_GIMPLE_H */