gcc/gimple.h

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