gcc/gimple.def

   1 /* This file contains the definitions of the GIMPLE IR tuples used in GCC.
   2
   3    Copyright (C) 2007, 2008, 2009 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 DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM)
 111
 112 /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
 113    calls.
 114
 115    FN is the callee.  It must be accepted by is_gimple_call_addr.
 116
 117    LHS is the operand where the return value from FN is stored.  It may
 118    be NULL.
 119
 120    ARG1 ... ARGN are the arguments.  They must all be accepted by
 121    is_gimple_operand.
 122
 123     CHAIN is the optional static chain link for nested functions.  */
 124 DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_WITH_MEM_OPS)
 125
 126 /* GIMPLE_RETURN <RETVAL> represents return statements.
 127
 128    RETVAL is the value to return or NULL.  If a value is returned it
 129    must be accepted by is_gimple_operand.  */
 130 DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS)
 131
 132 /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
 133    VARS is the set of variables declared in that scope.
 134    BLOCK is the symbol binding block used for debug information.
 135    BODY is the sequence of statements in the scope.  */
 136 DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND)
 137
 138 /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
 139    TYPES is the type (or list of types) handled.  HANDLER is the
 140    sequence of statements that handle these types.  */
 141 DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH)
 142
 143 /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
 144    specification.  TYPES is a list of allowed types and FAILURE is the
 145    sequence of statements to execute on failure.  */
 146 DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER)
 147
 148 /* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
 149    DECL is a noreturn function decl taking no arguments that will
 150    be invoked if an exception propagates to this point.  */
 151 DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT)
 152
 153 /* GIMPLE_RESX resumes execution after an exception.  */
 154 DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL)
 155
 156 /* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
 157    the FILTER argument.  */
 158 DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL)
 159
 160 /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node
 161
 162    RESULT = PHI <ARG1, ..., ARGN>
 163
 164    RESULT is the SSA name created by this PHI node.
 165
 166    ARG1 ... ARGN are the arguments to the PHI node.  N must be
 167    exactly the same as the number of incoming edges to the basic block
 168    holding the PHI node.  Every argument is either an SSA name or a
 169    tree node of class tcc_constant.  */
 170 DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
 171
 172 /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
 173    represents a try/catch or a try/finally statement.
 174
 175    TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.
 176
 177    EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
 178
 179    CLEANUP is the sequence of statements to execute according to
 180    TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected
 181    if an exception is thrown during execution of EVAL.  If TRY_KIND is
 182    GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
 183    (regardless of whether EVAL finished normally, or jumped out or an
 184    exception was thrown).  */
 185 DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY)
 186
 187 /* GIMPLE_NOP represents the "do nothing" statement.  */
 188 DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE)
 189
 190
 191 /* IMPORTANT.
 192
 193    Do not rearrange any of the GIMPLE_OMP_* codes.  This ordering is
 194    exposed by the range check in gimple_omp_subcode().  */
 195
 196
 197 /* Tuples used for lowering of OMP_ATOMIC.  Although the form of the OMP_ATOMIC
 198    expression is very simple (just in form mem op= expr), various implicit
 199    conversions may cause the expression to become more complex, so that it does
 200    not fit the gimple grammar very well.  To overcome this problem, OMP_ATOMIC
 201    is rewritten as a sequence of two codes in gimplification:
 202
 203    GIMPLE_OMP_LOAD (tmp, mem)
 204    val = some computations involving tmp;
 205    GIMPLE_OMP_STORE (val).  */
 206 DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load",
 207           GSS_OMP_ATOMIC_LOAD)
 208 DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store",
 209           GSS_OMP_ATOMIC_STORE)
 210
 211 /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections
 212    iteration in partially lowered OpenMP code.  */
 213 DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE)
 214
 215 /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents
 216
 217    #pragma omp critical [name]
 218
 219    NAME is the name given to the critical section.
 220    BODY is the sequence of statements that are inside the critical section.  */
 221 DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL)
 222
 223 /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY>
 224    represents
 225
 226    PRE_BODY
 227    #pragma omp for [clause1 ... clauseN]
 228    for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR)
 229    BODY
 230
 231    BODY is the loop body.
 232
 233    CLAUSES is the list of clauses.
 234
 235    INDEX must be an integer or pointer variable, which is implicitly thread
 236    private.  It must be accepted by is_gimple_operand.
 237
 238    INITIAL is the initial value given to INDEX. It must be
 239    accepted by is_gimple_operand.
 240
 241    FINAL is the final value that INDEX should take. It must
 242    be accepted by is_gimple_operand.
 243
 244    COND is the condition code for the controlling predicate.  It must
 245    be one of { <, >, <=, >= }
 246
 247    INCR is the loop index increment.  It must be tree node of type
 248    tcc_constant.
 249
 250    PRE_BODY is a landing pad filled by the gimplifier with things from
 251    INIT, COND, and INCR that are technically part of the OMP_FOR
 252    structured block, but are evaluated before the loop body begins.
 253
 254    INITIAL, FINAL and INCR are required to be loop invariant integer
 255    expressions that are evaluated without any synchronization.
 256    The evaluation order, frequency of evaluation and side-effects are
 257    unspecified by the standard.  */
 258 DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR)
 259
 260 /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master.
 261    BODY is the sequence of statements to execute in the master section.  */
 262 DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP)
 263
 264 /* GIMPLE_OMP_ORDERED <BODY> represents #pragma omp ordered.
 265    BODY is the sequence of statements to execute in the ordered section.  */
 266 DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP)
 267
 268 /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents
 269
 270    #pragma omp parallel [CLAUSES]
 271    BODY
 272
 273    BODY is a the sequence of statements to be executed by all threads.
 274
 275    CLAUSES is a TREE_LIST node with all the clauses.
 276
 277    CHILD_FN is set when outlining the body of the parallel region.
 278    All the statements in BODY are moved into this newly created
 279    function when converting OMP constructs into low-GIMPLE.
 280
 281    DATA_ARG is a local variable in the parent function containing data
 282    to be shared with CHILD_FN.  This is used to implement all the data
 283    sharing clauses.  */
 284 DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL)
 285
 286 /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN,
 287                     ARG_SIZE, ARG_ALIGN> represents
 288
 289    #pragma omp task [CLAUSES]
 290    BODY
 291
 292    BODY is a the sequence of statements to be executed by all threads.
 293
 294    CLAUSES is a TREE_LIST node with all the clauses.
 295
 296    CHILD_FN is set when outlining the body of the explicit task region.
 297    All the statements in BODY are moved into this newly created
 298    function when converting OMP constructs into low-GIMPLE.
 299
 300    DATA_ARG is a local variable in the parent function containing data
 301    to be shared with CHILD_FN.  This is used to implement all the data
 302    sharing clauses.
 303
 304    COPY_FN is set when outlining the firstprivate var initialization.
 305    All the needed statements are emitted into the newly created
 306    function, or when only memcpy is needed, it is NULL.
 307
 308    ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming
 309    data area allocated by GOMP_task and passed to CHILD_FN.  */
 310 DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK)
 311
 312 /* OMP_RETURN marks the end of an OpenMP directive.  */
 313 DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_BASE)
 314
 315 /* OMP_SECTION <BODY> represents #pragma omp section.
 316    BODY is the sequence of statements in the section body.  */
 317 DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP)
 318
 319 /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections.
 320
 321    BODY is the sequence of statements in the sections body.
 322    CLAUSES is a TREE_LIST node holding the list of associated clauses.
 323    CONTROL is a VAR_DECL used for deciding which of the sections
 324    to execute.  */
 325 DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS)
 326
 327 /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after
 328    OMP_SECTIONS.  It represents the GIMPLE_SWITCH used to decide which
 329    branch is taken.  */
 330 DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
 331
 332 /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single
 333    BODY is the sequence of statements inside the single section.
 334    CLAUSES is a TREE_LIST node holding the associated clauses.  */
 335 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE)
 336
 337 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
 338
 339    PREDICT is one of the predictors from predict.def.
 340
 341    OUTCOME is NOT_TAKEN or TAKEN.  */
 342 DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE)
 343
 344 /*  This node represents a cleanup expression.  It is ONLY USED INTERNALLY
 345     by the gimplifier as a placeholder for cleanups, and its uses will be
 346     cleaned up by the time gimplification is done.
 347
 348     This tuple should not exist outside of the gimplifier proper.  */
 349 DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE)