gcc/gimple.def

   1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC.
   2
   3    Copyright (C) 2007-2023 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 /* The format of this file is
  23    DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol).  */
  24
  25
  26 /* Error marker.  This is used in similar ways as ERROR_MARK in tree.def.  */
  27 DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE)
  28
  29 /* IMPORTANT.  Do not rearrange the codes between GIMPLE_COND and
  30    GIMPLE_RETURN.  The ordering is exposed by gimple_has_ops calls.
  31    These are all the GIMPLE statements with register operands.  */
  32
  33 /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
  34    represents the conditional jump:
  35
  36    if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL
  37
  38    COND_CODE is the tree code used as the comparison predicate.  It
  39    must be of class tcc_comparison.
  40
  41    OP1 and OP2 are the operands used in the comparison.  They must be
  42    accepted by is_gimple_operand.
  43
  44    TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
  45    jump target for the comparison.  */
  46 DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS)
  47
  48 /* GIMPLE_DEBUG represents a debug statement.  */
  49 DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS)
  50
  51 /* GIMPLE_GOTO <TARGET> represents unconditional jumps.
  52    TARGET is a LABEL_DECL or an expression node for computed GOTOs.  */
  53 DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS)
  54
  55 /* GIMPLE_LABEL <LABEL> represents label statements.  LABEL is a
  56    LABEL_DECL representing a jump target.  */
  57 DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS)
  58
  59 /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
  60    multiway branch:
  61
  62    switch (INDEX)
  63    {
  64      case LAB1: ...; break;
  65      ...
  66      case LABN: ...; break;
  67      default: ...
  68    }
  69
  70    INDEX is the variable evaluated to decide which label to jump to.
  71
  72    DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
  73    They must be CASE_LABEL_EXPR nodes.  */
  74 DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS)
  75
  76 /* IMPORTANT.
  77
  78    Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN.
  79    It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
  80    statements with memory and register operands.  */
  81
  82 /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
  83    statement
  84
  85    LHS = RHS1 SUBCODE RHS2.
  86
  87    SUBCODE is the tree code for the expression computed by the RHS of the
  88    assignment.  It must be one of the tree codes accepted by
  89    get_gimple_rhs_class.  If LHS is not a gimple register according to
  90    is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS.
  91
  92    LHS is the operand on the LHS of the assignment.  It must be a tree node
  93    accepted by is_gimple_lvalue.
  94
  95    RHS1 is the first operand on the RHS of the assignment.  It must always be
  96    present.  It must be a tree node accepted by is_gimple_val.
  97
  98    RHS2 is the second operand on the RHS of the assignment.  It must be a tree
  99    node accepted by is_gimple_val.  This argument exists only if SUBCODE is
 100    of class GIMPLE_BINARY_RHS.  */
 101 DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS)
 102
 103 /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
 104    represents inline assembly statements.
 105
 106    STRING is the string containing the assembly statements.
 107    I1 ... IN are the N input operands.
 108    O1 ... OM are the M output operands.
 109    C1 ... CP are the P clobber operands.
 110    L1 ... LQ are the Q label operands.  */
 111 DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM)
 112
 113 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
 114    calls.
 115
 116    FN is the callee.  It must be accepted by is_gimple_call_addr.
 117
 118    LHS is the operand where the return value from FN is stored.  It may
 119    be NULL.
 120
 121    ARG1 ... ARGN are the arguments.  They must all be accepted by
 122    is_gimple_operand.
 123
 124     CHAIN is the optional static chain link for nested functions.  */
 125 DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_CALL)
 126
 127 /* GIMPLE_TRANSACTION <BODY, LABEL> represents __transaction_atomic and
 128    __transaction_relaxed blocks.
 129    BODY is the sequence of statements inside the transaction.
 130    LABEL is a label for the statement immediately following the
 131    transaction.  This is before RETURN so that it has MEM_OPS,
 132    so that it can clobber global memory.  */
 133 DEFGSCODE(GIMPLE_TRANSACTION, "gimple_transaction", GSS_TRANSACTION)
 134
 135 /* GIMPLE_RETURN <RETVAL> represents return statements.
 136
 137    RETVAL is the value to return or NULL.  If a value is returned it
 138    must be accepted by is_gimple_operand.  */
 139 DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS)
 140
 141 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
 142    VARS is the set of variables declared in that scope.
 143    BLOCK is the symbol binding block used for debug information.
 144    BODY is the sequence of statements in the scope.  */
 145 DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND)
 146
 147 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
 148    TYPES is the type (or list of types) handled.  HANDLER is the
 149    sequence of statements that handle these types.  */
 150 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH)
 151
 152 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
 153    specification.  TYPES is a list of allowed types and FAILURE is the
 154    sequence of statements to execute on failure.  */
 155 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER)
 156
 157 /* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
 158    DECL is a noreturn function decl taking no arguments that will
 159    be invoked if an exception propagates to this point.  */
 160 DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT)
 161
 162 /* GIMPLE_EH_ELSE <N_BODY, E_BODY> must be the sole contents of
 163    a GIMPLE_TRY_FINALLY node.  For all normal exits from the try block,
 164    N_BODY is run; for all exception exits from the try block,
 165    E_BODY is run.  */
 166 DEFGSCODE(GIMPLE_EH_ELSE, "gimple_eh_else", GSS_EH_ELSE)
 167
 168 /* GIMPLE_RESX resumes execution after an exception.  */
 169 DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL)
 170
 171 /* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
 172    the FILTER argument.  */
 173 DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL)
 174
 175 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
 176
 177    RESULT = PHI <ARG1, ..., ARGN>
 178
 179    RESULT is the SSA name created by this PHI node.
 180
 181    ARG1 ... ARGN are the arguments to the PHI node.  N must be
 182    exactly the same as the number of incoming edges to the basic block
 183    holding the PHI node.  Every argument is either an SSA name or a
 184    tree node of class tcc_constant.  */
 185 DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
 186
 187 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
 188    represents a try/catch or a try/finally statement.
 189
 190    TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
 191
 192    EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
 193
 194    CLEANUP is the sequence of statements to execute according to
 195    TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected
 196    if an exception is thrown during execution of EVAL.  If TRY_KIND is
 197    GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
 198    (regardless of whether EVAL finished normally, or jumped out or an
 199    exception was thrown).  */
 200 DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY)
 201
 202 /* GIMPLE_NOP represents the "do nothing" statement.  */
 203 DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE)
 204
 205
 206 /* IMPORTANT.
 207
 208    Do not rearrange any of the GIMPLE_OMP_* codes.  This ordering is
 209    exposed by the range check in gimple_omp_subcode().  */
 210
 211
 212 /* Tuples used for lowering of OMP_ATOMIC.  Although the form of the OMP_ATOMIC
 213    expression is very simple (just in form mem op= expr), various implicit
 214    conversions may cause the expression to become more complex, so that it does
 215    not fit the gimple grammar very well.  To overcome this problem, OMP_ATOMIC
 216    is rewritten as a sequence of two codes in gimplification:
 217
 218    GIMPLE_OMP_LOAD (tmp, mem)
 219    val = some computations involving tmp;
 220    GIMPLE_OMP_STORE (val).  */
 221 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load",
 222           GSS_OMP_ATOMIC_LOAD)
 223 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store",
 224           GSS_OMP_ATOMIC_STORE_LAYOUT)
 225
 226 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
 227    iteration in partially lowered OpenMP code.  */
 228 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE)
 229
 230 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
 231
 232    #pragma omp critical [name]
 233
 234    NAME is the name given to the critical section.
 235    BODY is the sequence of statements that are inside the critical section.  */
 236 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL)
 237
 238 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
 239    represents
 240
 241    PRE_BODY
 242    #pragma omp for [clause1 ... clauseN]
 243    for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR)
 244    BODY
 245
 246    Likewise for:
 247    #pragma acc loop [clause1 ... clauseN]
 248
 249    BODY is the loop body.
 250
 251    CLAUSES is the list of clauses.
 252
 253    INDEX must be an integer or pointer variable, which is implicitly thread
 254    private.  It must be accepted by is_gimple_operand.
 255
 256    INITIAL is the initial value given to INDEX. It must be
 257    accepted by is_gimple_operand.
 258
 259    FINAL is the final value that INDEX should take. It must
 260    be accepted by is_gimple_operand.
 261
 262    COND is the condition code for the controlling predicate.  It must
 263    be one of { <, >, <=, >= }
 264
 265    INCR is the loop index increment.  It must be tree node of type
 266    tcc_constant.
 267
 268    PRE_BODY is a landing pad filled by the gimplifier with things from
 269    INIT, COND, and INCR that are technically part of the OMP_FOR
 270    structured block, but are evaluated before the loop body begins.
 271
 272    INITIAL, FINAL and INCR are required to be loop invariant integer
 273    expressions that are evaluated without any synchronization.
 274    The evaluation order, frequency of evaluation and side-effects are
 275    unspecified by the standards.  */
 276 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR)
 277
 278 /* GIMPLE_STRUCTURED_BLOCK <BODY> is an internal construct used to assert
 279    that BODY is a structured block sequence, with no other semantics.  It is
 280    used to allow error-checking of intervening code in OMP_FOR constructs.  */
 281 DEFGSCODE(GIMPLE_OMP_STRUCTURED_BLOCK, "gimple_omp_structured_block", GSS_OMP)
 282
 283 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
 284    BODY is the sequence of statements to execute in the master section.  */
 285 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP)
 286
 287 /* GIMPLE_OMP_MASKED <BODY, CLAUSES> represents #pragma omp masked.
 288    BODY is the sequence of statements to execute in the masked section.  */
 289 DEFGSCODE(GIMPLE_OMP_MASKED, "gimple_omp_masked", GSS_OMP_SINGLE_LAYOUT)
 290
 291 /* GIMPLE_OMP_TASKGROUP <BODY, CLAUSES> represents #pragma omp taskgroup.
 292    BODY is the sequence of statements inside the taskgroup section.
 293    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 294 DEFGSCODE(GIMPLE_OMP_TASKGROUP, "gimple_omp_taskgroup", GSS_OMP_SINGLE_LAYOUT)
 295
 296 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
 297
 298    #pragma omp parallel [CLAUSES]
 299    BODY
 300
 301    BODY is a the sequence of statements to be executed by all threads.
 302
 303    CLAUSES is an OMP_CLAUSE chain with all the clauses.
 304
 305    CHILD_FN is set when outlining the body of the parallel region.
 306    All the statements in BODY are moved into this newly created
 307    function when converting OMP constructs into low-GIMPLE.
 308
 309    DATA_ARG is a local variable in the parent function containing data
 310    to be shared with CHILD_FN.  This is used to implement all the data
 311    sharing clauses.  */
 312 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL_LAYOUT)
 313
 314 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
 315                     ARG_SIZE, ARG_ALIGN> represents
 316
 317    #pragma omp task [CLAUSES]
 318    BODY
 319
 320    BODY is a the sequence of statements to be executed by all threads.
 321
 322    CLAUSES is an OMP_CLAUSE chain with all the clauses.
 323
 324    CHILD_FN is set when outlining the body of the explicit task region.
 325    All the statements in BODY are moved into this newly created
 326    function when converting OMP constructs into low-GIMPLE.
 327
 328    DATA_ARG is a local variable in the parent function containing data
 329    to be shared with CHILD_FN.  This is used to implement all the data
 330    sharing clauses.
 331
 332    COPY_FN is set when outlining the firstprivate var initialization.
 333    All the needed statements are emitted into the newly created
 334    function, or when only memcpy is needed, it is NULL.
 335
 336    ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming
 337    data area allocated by GOMP_task and passed to CHILD_FN.  */
 338 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK)
 339
 340 /* OMP_RETURN marks the end of an OpenMP directive.  */
 341 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_OMP_ATOMIC_STORE_LAYOUT)
 342
 343 /* GIMPLE_OMP_SCAN <BODY, CLAUSES> represents #pragma omp scan
 344    BODY is the sequence of statements inside the single section.
 345    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 346 DEFGSCODE(GIMPLE_OMP_SCAN, "gimple_omp_scan", GSS_OMP_SINGLE_LAYOUT)
 347
 348 /* GIMPLE_OMP_SCOPE <BODY, CLAUSES> represents #pragma omp scope
 349    BODY is the sequence of statements inside the single section.
 350    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 351 DEFGSCODE(GIMPLE_OMP_SCOPE, "gimple_omp_scope", GSS_OMP_SINGLE_LAYOUT)
 352
 353 /* OMP_SECTION <BODY> represents #pragma omp section.
 354    BODY is the sequence of statements in the section body.  */
 355 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP)
 356
 357 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
 358
 359    BODY is the sequence of statements in the sections body.
 360    CLAUSES is an OMP_CLAUSE chain holding the list of associated clauses.
 361    CONTROL is a VAR_DECL used for deciding which of the sections
 362    to execute.  */
 363 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS)
 364
 365 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
 366    OMP_SECTIONS.  It represents the GIMPLE_SWITCH used to decide which
 367    branch is taken.  */
 368 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
 369
 370 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
 371    BODY is the sequence of statements inside the single section.
 372    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 373 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE_LAYOUT)
 374
 375 /* GIMPLE_OMP_TARGET <BODY, CLAUSES, CHILD_FN> represents
 376    #pragma acc {kernels,parallel,serial,data,enter data,exit data,update}
 377    #pragma omp target {,data,update}
 378    BODY is the sequence of statements inside the construct
 379    (NULL for some variants).
 380    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.
 381    CHILD_FN is set when outlining the body of the offloaded region.
 382    All the statements in BODY are moved into this newly created
 383    function when converting OMP constructs into low-GIMPLE.
 384    DATA_ARG is a vec of 3 local variables in the parent function
 385    containing data to be mapped to CHILD_FN.  This is used to
 386    implement the MAP clauses.  */
 387 DEFGSCODE(GIMPLE_OMP_TARGET, "gimple_omp_target", GSS_OMP_PARALLEL_LAYOUT)
 388
 389 /* GIMPLE_OMP_TEAMS <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
 390    #pragma omp teams
 391    BODY is the sequence of statements inside the single section.
 392    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.
 393    CHILD_FN and DATA_ARG like for GIMPLE_OMP_PARALLEL.  */
 394 DEFGSCODE(GIMPLE_OMP_TEAMS, "gimple_omp_teams", GSS_OMP_PARALLEL_LAYOUT)
 395
 396 /* GIMPLE_OMP_ORDERED <BODY, CLAUSES> represents #pragma omp ordered.
 397    BODY is the sequence of statements to execute in the ordered section.
 398    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 399 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP_SINGLE_LAYOUT)
 400
 401 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
 402
 403    PREDICT is one of the predictors from predict.def.
 404
 405    OUTCOME is NOT_TAKEN or TAKEN.  */
 406 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE)
 407
 408 /*  This node represents a cleanup expression.  It is ONLY USED INTERNALLY
 409     by the gimplifier as a placeholder for cleanups, and its uses will be
 410     cleaned up by the time gimplification is done.
 411
 412     This tuple should not exist outside of the gimplifier proper.  */
 413 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE)
 414
 415 /* GIMPLE_ASSUME <GUARD, BODY> represents [[assume(cond)]].
 416    BODY is the GIMPLE_BIND with the condition which sets GUARD to true
 417    (otherwise UB).  */
 418 DEFGSCODE(GIMPLE_ASSUME, "gimple_assume", GSS_ASSUME)