gcc/gimple.h

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