| /* This file contains the definitions of the GIMPLE IR tuples used in GCC. |
| |
| Copyright (C) 2007-2017 Free Software Foundation, Inc. |
| Contributed by Aldy Hernandez <aldyh@redhat.com> |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| /* The format of this file is |
| DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol). */ |
| |
| |
| /* Error marker. This is used in similar ways as ERROR_MARK in tree.def. */ |
| DEFGSCODE(GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE) |
| |
| /* IMPORTANT. Do not rearrange the codes between GIMPLE_COND and |
| GIMPLE_RETURN. The ordering is exposed by gimple_has_ops calls. |
| These are all the GIMPLE statements with register operands. */ |
| |
| /* GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL> |
| represents the conditional jump: |
| |
| if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL |
| |
| COND_CODE is the tree code used as the comparison predicate. It |
| must be of class tcc_comparison. |
| |
| OP1 and OP2 are the operands used in the comparison. They must be |
| accepted by is_gimple_operand. |
| |
| TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the |
| jump target for the comparison. */ |
| DEFGSCODE(GIMPLE_COND, "gimple_cond", GSS_WITH_OPS) |
| |
| /* GIMPLE_DEBUG represents a debug statement. */ |
| DEFGSCODE(GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS) |
| |
| /* GIMPLE_GOTO <TARGET> represents unconditional jumps. |
| TARGET is a LABEL_DECL or an expression node for computed GOTOs. */ |
| DEFGSCODE(GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS) |
| |
| /* GIMPLE_LABEL <LABEL> represents label statements. LABEL is a |
| LABEL_DECL representing a jump target. */ |
| DEFGSCODE(GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS) |
| |
| /* GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the |
| multiway branch: |
| |
| switch (INDEX) |
| { |
| case LAB1: ...; break; |
| ... |
| case LABN: ...; break; |
| default: ... |
| } |
| |
| INDEX is the variable evaluated to decide which label to jump to. |
| |
| DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels. |
| They must be CASE_LABEL_EXPR nodes. */ |
| DEFGSCODE(GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS) |
| |
| /* IMPORTANT. |
| |
| Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN. |
| It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE |
| statements with memory and register operands. */ |
| |
| /* GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment |
| statement |
| |
| LHS = RHS1 SUBCODE RHS2. |
| |
| SUBCODE is the tree code for the expression computed by the RHS of the |
| assignment. It must be one of the tree codes accepted by |
| get_gimple_rhs_class. If LHS is not a gimple register according to |
| is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS. |
| |
| LHS is the operand on the LHS of the assignment. It must be a tree node |
| accepted by is_gimple_lvalue. |
| |
| RHS1 is the first operand on the RHS of the assignment. It must always be |
| present. It must be a tree node accepted by is_gimple_val. |
| |
| RHS2 is the second operand on the RHS of the assignment. It must be a tree |
| node accepted by is_gimple_val. This argument exists only if SUBCODE is |
| of class GIMPLE_BINARY_RHS. */ |
| DEFGSCODE(GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS) |
| |
| /* GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP> |
| represents inline assembly statements. |
| |
| STRING is the string containing the assembly statements. |
| I1 ... IN are the N input operands. |
| O1 ... OM are the M output operands. |
| C1 ... CP are the P clobber operands. |
| L1 ... LQ are the Q label operands. */ |
| DEFGSCODE(GIMPLE_ASM, "gimple_asm", GSS_ASM) |
| |
| /* GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function |
| calls. |
| |
| FN is the callee. It must be accepted by is_gimple_call_addr. |
| |
| LHS is the operand where the return value from FN is stored. It may |
| be NULL. |
| |
| ARG1 ... ARGN are the arguments. They must all be accepted by |
| is_gimple_operand. |
| |
| CHAIN is the optional static chain link for nested functions. */ |
| DEFGSCODE(GIMPLE_CALL, "gimple_call", GSS_CALL) |
| |
| /* GIMPLE_TRANSACTION <BODY, LABEL> represents __transaction_atomic and |
| __transaction_relaxed blocks. |
| BODY is the sequence of statements inside the transaction. |
| LABEL is a label for the statement immediately following the |
| transaction. This is before RETURN so that it has MEM_OPS, |
| so that it can clobber global memory. */ |
| DEFGSCODE(GIMPLE_TRANSACTION, "gimple_transaction", GSS_TRANSACTION) |
| |
| /* GIMPLE_RETURN <RETVAL> represents return statements. |
| |
| RETVAL is the value to return or NULL. If a value is returned it |
| must be accepted by is_gimple_operand. */ |
| DEFGSCODE(GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS) |
| |
| /* GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope. |
| VARS is the set of variables declared in that scope. |
| BLOCK is the symbol binding block used for debug information. |
| BODY is the sequence of statements in the scope. */ |
| DEFGSCODE(GIMPLE_BIND, "gimple_bind", GSS_BIND) |
| |
| /* GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler. |
| TYPES is the type (or list of types) handled. HANDLER is the |
| sequence of statements that handle these types. */ |
| DEFGSCODE(GIMPLE_CATCH, "gimple_catch", GSS_CATCH) |
| |
| /* GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception |
| specification. TYPES is a list of allowed types and FAILURE is the |
| sequence of statements to execute on failure. */ |
| DEFGSCODE(GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER) |
| |
| /* GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier. |
| DECL is a noreturn function decl taking no arguments that will |
| be invoked if an exception propagates to this point. */ |
| DEFGSCODE(GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT) |
| |
| /* GIMPLE_EH_ELSE <N_BODY, E_BODY> must be the sole contents of |
| a GIMPLE_TRY_FINALLY node. For all normal exits from the try block, |
| N_BODY is run; for all exception exits from the try block, |
| E_BODY is run. */ |
| DEFGSCODE(GIMPLE_EH_ELSE, "gimple_eh_else", GSS_EH_ELSE) |
| |
| /* GIMPLE_RESX resumes execution after an exception. */ |
| DEFGSCODE(GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL) |
| |
| /* GIMPLE_EH_DISPATCH demultiplexes an exception edge based on |
| the FILTER argument. */ |
| DEFGSCODE(GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL) |
| |
| /* GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node |
| |
| RESULT = PHI <ARG1, ..., ARGN> |
| |
| RESULT is the SSA name created by this PHI node. |
| |
| ARG1 ... ARGN are the arguments to the PHI node. N must be |
| exactly the same as the number of incoming edges to the basic block |
| holding the PHI node. Every argument is either an SSA name or a |
| tree node of class tcc_constant. */ |
| DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI) |
| |
| /* GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP> |
| represents a try/catch or a try/finally statement. |
| |
| TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. |
| |
| EVAL is the sequence of statements to execute on entry to GIMPLE_TRY. |
| |
| CLEANUP is the sequence of statements to execute according to |
| TRY_KIND. If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected |
| if an exception is thrown during execution of EVAL. If TRY_KIND is |
| GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL |
| (regardless of whether EVAL finished normally, or jumped out or an |
| exception was thrown). */ |
| DEFGSCODE(GIMPLE_TRY, "gimple_try", GSS_TRY) |
| |
| /* GIMPLE_NOP represents the "do nothing" statement. */ |
| DEFGSCODE(GIMPLE_NOP, "gimple_nop", GSS_BASE) |
| |
| |
| /* IMPORTANT. |
| |
| Do not rearrange any of the GIMPLE_OMP_* codes. This ordering is |
| exposed by the range check in gimple_omp_subcode(). */ |
| |
| |
| /* Tuples used for lowering of OMP_ATOMIC. Although the form of the OMP_ATOMIC |
| expression is very simple (just in form mem op= expr), various implicit |
| conversions may cause the expression to become more complex, so that it does |
| not fit the gimple grammar very well. To overcome this problem, OMP_ATOMIC |
| is rewritten as a sequence of two codes in gimplification: |
| |
| GIMPLE_OMP_LOAD (tmp, mem) |
| val = some computations involving tmp; |
| GIMPLE_OMP_STORE (val). */ |
| DEFGSCODE(GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load", |
| GSS_OMP_ATOMIC_LOAD) |
| DEFGSCODE(GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store", |
| GSS_OMP_ATOMIC_STORE_LAYOUT) |
| |
| /* GIMPLE_OMP_CONTINUE marks the location of the loop or sections |
| iteration in partially lowered OpenMP code. */ |
| DEFGSCODE(GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE) |
| |
| /* GIMPLE_OMP_CRITICAL <NAME, BODY> represents |
| |
| #pragma omp critical [name] |
| |
| NAME is the name given to the critical section. |
| BODY is the sequence of statements that are inside the critical section. */ |
| DEFGSCODE(GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL) |
| |
| /* GIMPLE_OMP_FOR <BODY, CLAUSES, INDEX, INITIAL, FINAL, COND, INCR, PRE_BODY> |
| represents |
| |
| PRE_BODY |
| #pragma omp for [clause1 ... clauseN] |
| for (INDEX = INITIAL; INDEX COND FINAL; INDEX {+=,-=} INCR) |
| BODY |
| |
| Likewise for: |
| #pragma acc loop [clause1 ... clauseN] |
| |
| BODY is the loop body. |
| |
| CLAUSES is the list of clauses. |
| |
| INDEX must be an integer or pointer variable, which is implicitly thread |
| private. It must be accepted by is_gimple_operand. |
| |
| INITIAL is the initial value given to INDEX. It must be |
| accepted by is_gimple_operand. |
| |
| FINAL is the final value that INDEX should take. It must |
| be accepted by is_gimple_operand. |
| |
| COND is the condition code for the controlling predicate. It must |
| be one of { <, >, <=, >= } |
| |
| INCR is the loop index increment. It must be tree node of type |
| tcc_constant. |
| |
| PRE_BODY is a landing pad filled by the gimplifier with things from |
| INIT, COND, and INCR that are technically part of the OMP_FOR |
| structured block, but are evaluated before the loop body begins. |
| |
| INITIAL, FINAL and INCR are required to be loop invariant integer |
| expressions that are evaluated without any synchronization. |
| The evaluation order, frequency of evaluation and side-effects are |
| unspecified by the standards. */ |
| DEFGSCODE(GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR) |
| |
| /* GIMPLE_OMP_MASTER <BODY> represents #pragma omp master. |
| BODY is the sequence of statements to execute in the master section. */ |
| DEFGSCODE(GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP) |
| |
| /* GIMPLE_OMP_TASKGROUP <BODY> represents #pragma omp taskgroup. |
| BODY is the sequence of statements to execute in the taskgroup section. */ |
| DEFGSCODE(GIMPLE_OMP_TASKGROUP, "gimple_omp_taskgroup", GSS_OMP) |
| |
| /* GIMPLE_OMP_PARALLEL <BODY, CLAUSES, CHILD_FN, DATA_ARG> represents |
| |
| #pragma omp parallel [CLAUSES] |
| BODY |
| |
| BODY is a the sequence of statements to be executed by all threads. |
| |
| CLAUSES is an OMP_CLAUSE chain with all the clauses. |
| |
| CHILD_FN is set when outlining the body of the parallel region. |
| All the statements in BODY are moved into this newly created |
| function when converting OMP constructs into low-GIMPLE. |
| |
| DATA_ARG is a local variable in the parent function containing data |
| to be shared with CHILD_FN. This is used to implement all the data |
| sharing clauses. */ |
| DEFGSCODE(GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL_LAYOUT) |
| |
| /* GIMPLE_OMP_TASK <BODY, CLAUSES, CHILD_FN, DATA_ARG, COPY_FN, |
| ARG_SIZE, ARG_ALIGN> represents |
| |
| #pragma omp task [CLAUSES] |
| BODY |
| |
| BODY is a the sequence of statements to be executed by all threads. |
| |
| CLAUSES is an OMP_CLAUSE chain with all the clauses. |
| |
| CHILD_FN is set when outlining the body of the explicit task region. |
| All the statements in BODY are moved into this newly created |
| function when converting OMP constructs into low-GIMPLE. |
| |
| DATA_ARG is a local variable in the parent function containing data |
| to be shared with CHILD_FN. This is used to implement all the data |
| sharing clauses. |
| |
| COPY_FN is set when outlining the firstprivate var initialization. |
| All the needed statements are emitted into the newly created |
| function, or when only memcpy is needed, it is NULL. |
| |
| ARG_SIZE and ARG_ALIGN are the size and alignment of the incoming |
| data area allocated by GOMP_task and passed to CHILD_FN. */ |
| DEFGSCODE(GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK) |
| |
| /* OMP_RETURN marks the end of an OpenMP directive. */ |
| DEFGSCODE(GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_OMP_ATOMIC_STORE_LAYOUT) |
| |
| /* OMP_SECTION <BODY> represents #pragma omp section. |
| BODY is the sequence of statements in the section body. */ |
| DEFGSCODE(GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP) |
| |
| /* OMP_SECTIONS <BODY, CLAUSES, CONTROL> represents #pragma omp sections. |
| |
| BODY is the sequence of statements in the sections body. |
| CLAUSES is an OMP_CLAUSE chain holding the list of associated clauses. |
| CONTROL is a VAR_DECL used for deciding which of the sections |
| to execute. */ |
| DEFGSCODE(GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS) |
| |
| /* GIMPLE_OMP_SECTIONS_SWITCH is a marker placed immediately after |
| OMP_SECTIONS. It represents the GIMPLE_SWITCH used to decide which |
| branch is taken. */ |
| DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE) |
| |
| /* GIMPLE_OMP_SINGLE <BODY, CLAUSES> represents #pragma omp single |
| BODY is the sequence of statements inside the single section. |
| CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */ |
| DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE_LAYOUT) |
| |
| /* GIMPLE_OMP_TARGET <BODY, CLAUSES, CHILD_FN> represents |
| #pragma acc {kernels,parallel,data,enter data,exit data,update} |
| #pragma omp target {,data,update} |
| BODY is the sequence of statements inside the construct |
| (NULL for some variants). |
| CLAUSES is an OMP_CLAUSE chain holding the associated clauses. |
| CHILD_FN is set when outlining the body of the offloaded region. |
| All the statements in BODY are moved into this newly created |
| function when converting OMP constructs into low-GIMPLE. |
| DATA_ARG is a vec of 3 local variables in the parent function |
| containing data to be mapped to CHILD_FN. This is used to |
| implement the MAP clauses. */ |
| DEFGSCODE(GIMPLE_OMP_TARGET, "gimple_omp_target", GSS_OMP_PARALLEL_LAYOUT) |
| |
| /* GIMPLE_OMP_TEAMS <BODY, CLAUSES> represents #pragma omp teams |
| BODY is the sequence of statements inside the single section. |
| CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */ |
| DEFGSCODE(GIMPLE_OMP_TEAMS, "gimple_omp_teams", GSS_OMP_SINGLE_LAYOUT) |
| |
| /* GIMPLE_OMP_ORDERED <BODY, CLAUSES> represents #pragma omp ordered. |
| BODY is the sequence of statements to execute in the ordered section. |
| CLAUSES is an OMP_CLAUSE chain holding the associated clauses. */ |
| DEFGSCODE(GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP_SINGLE_LAYOUT) |
| |
| /* GIMPLE_OMP_GRID_BODY <BODY> represents a parallel loop lowered for execution |
| on a GPU. It is an artificial statement created by omp lowering. */ |
| DEFGSCODE(GIMPLE_OMP_GRID_BODY, "gimple_omp_gpukernel", GSS_OMP) |
| |
| /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction. |
| |
| PREDICT is one of the predictors from predict.def. |
| |
| OUTCOME is NOT_TAKEN or TAKEN. */ |
| DEFGSCODE(GIMPLE_PREDICT, "gimple_predict", GSS_BASE) |
| |
| /* This node represents a cleanup expression. It is ONLY USED INTERNALLY |
| by the gimplifier as a placeholder for cleanups, and its uses will be |
| cleaned up by the time gimplification is done. |
| |
| This tuple should not exist outside of the gimplifier proper. */ |
| DEFGSCODE(GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE) |