diff options
Diffstat (limited to 'Documentation/IR.rst')
| -rw-r--r-- | Documentation/IR.rst | 154 |
1 files changed, 80 insertions, 74 deletions
diff --git a/Documentation/IR.rst b/Documentation/IR.rst index ec297eed..67ef06a5 100644 --- a/Documentation/IR.rst +++ b/Documentation/IR.rst @@ -1,3 +1,5 @@ +.. default-domain:: ir + Sparse's Intermediate Representation ==================================== @@ -20,32 +22,32 @@ The common ones are: Terminators ----------- -OP_RET +.. op:: OP_RET Return from subroutine. * .src : returned value (NULL if void) * .type: type of .src -OP_BR +.. op:: OP_BR Unconditional branch * .bb_true: destination basic block -OP_CBR +.. op:: OP_CBR Conditional branch * .cond: condition * .type: type of .cond, must be an integral type * .bb_true, .bb_false: destination basic blocks -OP_SWITCH +.. op:: OP_SWITCH Switch / multi-branch * .cond: condition * .type: type of .cond, must be an integral type * .multijmp_list: pairs of case-value - destination basic block -OP_COMPUTEDGOTO +.. op:: OP_COMPUTEDGOTO Computed goto / branch to register * .src: address to branch to (void*) @@ -58,34 +60,34 @@ They all follow the same signature: * .target: result of the operation (must be an integral type) * .type: type of .target -OP_ADD +.. op:: OP_ADD Integer addition. -OP_SUB +.. op:: OP_SUB Integer subtraction. -OP_MUL +.. op:: OP_MUL Integer multiplication. -OP_DIVU +.. op:: OP_DIVU Integer unsigned division. -OP_DIVS +.. op:: OP_DIVS Integer signed division. -OP_MODU +.. op:: OP_MODU Integer unsigned remainder. -OP_MODS +.. op:: OP_MODS Integer signed remainder. -OP_SHL +.. op:: OP_SHL Shift left (integer only) -OP_LSR +.. op:: OP_LSR Logical Shift right (integer only) -OP_ASR +.. op:: OP_ASR Arithmetic Shift right (integer only) Floating-point binops @@ -95,16 +97,16 @@ They all follow the same signature: * .target: result of the operation (must be a floating-point type) * .type: type of .target -OP_FADD +.. op:: OP_FADD Floating-point addition. -OP_FSUB +.. op:: OP_FSUB Floating-point subtraction. -OP_FMUL +.. op:: OP_FMUL Floating-point multiplication. -OP_FDIV +.. op:: OP_FDIV Floating-point division. Logical ops @@ -114,21 +116,21 @@ They all follow the same signature: * .target: result of the operation * .type: type of .target, must be an integral type -OP_AND +.. op:: OP_AND Logical AND -OP_OR +.. op:: OP_OR Logical OR -OP_XOR +.. op:: OP_XOR Logical XOR Boolean ops ----------- -OP_AND_BOOL +.. op:: OP_AND_BOOL Boolean AND -OP_OR_BOOL +.. op:: OP_OR_BOOL Boolean OR Integer compares @@ -138,34 +140,34 @@ They all have the following signature: * .target: result of the operation (0/1 valued integer) * .type: type of .target, must be an integral type -OP_SET_EQ +.. op:: OP_SET_EQ Compare equal. -OP_SET_NE +.. op:: OP_SET_NE Compare not-equal. -OP_SET_LE +.. op:: OP_SET_LE Compare less-than-or-equal (signed). -OP_SET_GE +.. op:: OP_SET_GE Compare greater-than-or-equal (signed). -OP_SET_LT +.. op:: OP_SET_LT Compare less-than (signed). -OP_SET_GT +.. op:: OP_SET_GT Compare greater-than (signed). -OP_SET_B +.. op:: OP_SET_B Compare less-than (unsigned). -OP_SET_A +.. op:: OP_SET_A Compare greater-than (unsigned). -OP_SET_BE +.. op:: OP_SET_BE Compare less-than-or-equal (unsigned). -OP_SET_AE +.. op:: OP_SET_AE Compare greater-than-or-equal (unsigned). Floating-point compares @@ -178,76 +180,76 @@ NaN and if it is the case the ordered compares return false and then unordered return true, otherwise the result of the comparison, now guaranteed to be done on non-NaNs, is returned. -OP_FCMP_OEQ +.. op:: OP_FCMP_OEQ Floating-point compare ordered equal -OP_FCMP_ONE +.. op:: OP_FCMP_ONE Floating-point compare ordered not-equal -OP_FCMP_OLE +.. op:: OP_FCMP_OLE Floating-point compare ordered less-than-or-equal -OP_FCMP_OGE +.. op:: OP_FCMP_OGE Floating-point compare ordered greater-or-equal -OP_FCMP_OLT +.. op:: OP_FCMP_OLT Floating-point compare ordered less-than -OP_FCMP_OGT +.. op:: OP_FCMP_OGT Floating-point compare ordered greater-than -OP_FCMP_UEQ +.. op:: OP_FCMP_UEQ Floating-point compare unordered equal -OP_FCMP_UNE +.. op:: OP_FCMP_UNE Floating-point compare unordered not-equal -OP_FCMP_ULE +.. op:: OP_FCMP_ULE Floating-point compare unordered less-than-or-equal -OP_FCMP_UGE +.. op:: OP_FCMP_UGE Floating-point compare unordered greater-or-equal -OP_FCMP_ULT +.. op:: OP_FCMP_ULT Floating-point compare unordered less-than -OP_FCMP_UGT +.. op:: OP_FCMP_UGT Floating-point compare unordered greater-than -OP_FCMP_ORD +.. op:: OP_FCMP_ORD Floating-point compare ordered: return true if both operands are ordered (none of the operands are a NaN) and false otherwise. -OP_FCMP_UNO +.. op:: OP_FCMP_UNO Floating-point compare unordered: return false if no operands is ordered and true otherwise. Unary ops --------- -OP_NOT +.. op:: OP_NOT Logical not. * .src: operand (type must be compatible with .target) * .target: result of the operation * .type: type of .target, must be an integral type -OP_NEG +.. op:: OP_NEG Integer negation. * .src: operand (type must be compatible with .target) * .target: result of the operation (must be an integral type) * .type: type of .target -OP_FNEG +.. op:: OP_FNEG Floating-point negation. * .src: operand (type must be compatible with .target) * .target: result of the operation (must be a floating-point type) * .type: type of .target -OP_COPY +.. op:: OP_COPY Copy (only needed after out-of-SSA). * .src: operand (type must be compatible with .target) @@ -262,27 +264,27 @@ They all have the following signature: * .target: result value * .type: type of .target -OP_CAST +.. op:: OP_CAST Cast to unsigned integer (and to void pointer). -OP_SCAST +.. op:: OP_SCAST Cast to signed integer. -OP_FPCAST +.. op:: OP_FPCAST Cast to floating-point. -OP_PTRCAST +.. op:: OP_PTRCAST Cast to pointer. Ternary ops ----------- -OP_SEL +.. op:: OP_SEL * .src1: condition, must be of integral type * .src2, .src3: operands (types must be compatible with .target) * .target: result of the operation * .type: type of .target -OP_RANGE +.. op:: OP_RANGE Range/bounds checking (only used for an unused sparse extension). * .src1: value to be checked @@ -291,7 +293,7 @@ OP_RANGE Memory ops ---------- -OP_LOAD +.. op:: OP_LOAD Load. * .src: base address to load from @@ -299,7 +301,7 @@ OP_LOAD * .target: loaded value * .type: type of .target -OP_STORE +.. op:: OP_STORE Store. * .src: base address to store to @@ -309,20 +311,20 @@ OP_STORE Others ------ -OP_SYMADDR +.. op:: OP_SYMADDR Create a pseudo corresponding to the address of a symbol. * .symbol: (pseudo_t) input symbol (alias .src) * .target: symbol's address -OP_SETFVAL +.. op:: OP_SETFVAL Create a pseudo corresponding to a floating-point literal. * .fvalue: the literal's value (long double) * .target: the corresponding pseudo * .type: type of the literal & .target -OP_SETVAL +.. op:: OP_SETVAL Create a pseudo corresponding to a string literal or a label-as-value. The value is given as an expression EXPR_STRING or EXPR_LABEL. @@ -330,23 +332,24 @@ OP_SETVAL * .target: the resulting value * .type: type of .target, the value -OP_PHI +.. op:: OP_PHI Phi-node (for SSA form). * .phi_list: phi-operands (type must be compatible with .target) * .target: "result" * .type: type of .target -OP_PHISOURCE +.. op:: OP_PHISOURCE Phi-node source. Like OP_COPY but exclusively used to give a defining instructions (and thus also a type) to *all* OP_PHI operands. + * .phi_src: operand (type must be compatible with .target, alias .src) * .target: the "result" PSEUDO_PHI * .type: type of .target * .phi_users: list of phi instructions using the target pseudo -OP_CALL +.. op:: OP_CALL Function call. * .func: (pseudo_t) the function (can be a symbol or a "register", @@ -358,15 +361,16 @@ OP_CALL entry is the full function type, the next ones are the type of each arguments -OP_INLINED_CALL +.. op:: OP_INLINED_CALL Only used as an annotation to show that the instructions just above correspond to a function that have been inlined. + * .func: (pseudo_t) the function (must be a symbol, alias .src)) * .arguments: list of pseudos that where the function's arguments * .target: function return value (if any) * .type: type of .target -OP_SLICE +.. op:: OP_SLICE Extract a "slice" from an aggregate. * .base: (pseudo_t) aggregate (alias .src) @@ -374,7 +378,7 @@ OP_SLICE * .target: result * .type: type of .target -OP_ASM +.. op:: OP_ASM Inlined assembly code. * .string: asm template @@ -382,7 +386,7 @@ OP_ASM Sparse tagging (line numbers, context, whatever) ------------------------------------------------ -OP_CONTEXT +.. op:: OP_CONTEXT Currently only used for lock/unlock tracking. * .context_expr: unused @@ -391,15 +395,17 @@ OP_CONTEXT Misc ops -------- -OP_ENTRY +.. op:: OP_ENTRY Function entry point (no associated semantic). -OP_BADOP +.. op:: OP_BADOP Invalid operation (should never be generated). -OP_NOP +.. op:: OP_NOP No-op (should never be generated). -OP_DEATHNOTE +.. op:: OP_DEATHNOTE Annotation telling the pseudo will be death after the next instruction (other than some other annotation, that is). + +.. # vim: tabstop=4 |