/* This file contains the definitions and documentation for the
Register Transfer Expressions (rtx's) that make up the
Register Transfer Language (rtl) used in the Back End of the GNU compiler.
- Copyright (C) 1987, 88, 92, 94, 95, 97, 98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 92, 94, 95, 97, 98, 1999, 2000
+ Free Software Foundation, Inc.
This file is part of GNU CC.
DEF_RTL_EXPR(MATCH_PAR_DUP, "match_par_dup", "iE", 'm')
/* Appears only in machine descriptions.
- Should be used only in attribute tests.
- The predicate in operand 0 is applied to the whole insn being checked. */
-DEF_RTL_EXPR(MATCH_INSN, "match_insn", "s", 'm')
-
-/* Appears only in machine descriptions.
Operand 0 is the operand number, as in match_operand.
Operand 1 is the predicate to apply to the insn. */
-DEF_RTL_EXPR(MATCH_INSN2, "match_insn2", "is", 'm')
+DEF_RTL_EXPR(MATCH_INSN, "match_insn", "is", 'm')
/* Appears only in machine descriptions.
Defines the pattern for one kind of instruction.
(`operands' is an alias here for `recog_operand'). */
DEF_RTL_EXPR(DEFINE_SPLIT, "define_split", "EsES", 'x')
+/* Definition of an RTL peephole operation.
+ Follows the same arguments as define_split. */
+DEF_RTL_EXPR(DEFINE_PEEPHOLE2, "define_peephole2", "EsES", 'x')
+
/* Definition of a combiner pattern.
Operands not defined yet. */
DEF_RTL_EXPR(DEFINE_COMBINE, "define_combine", "Ess", 'x')
`emit_insn' takes the SEQUENCE apart and makes separate insns. */
DEF_RTL_EXPR(SEQUENCE, "sequence", "E", 'x')
-/* Refers to the address of its argument.
- This appears only in machine descriptions, indicating that
- any expression that would be acceptable as the operand of MEM
- should be matched. */
+/* Refers to the address of its argument. This is only used in alias.c. */
DEF_RTL_EXPR(ADDRESS, "address", "e", 'm')
/* ----------------------------------------------------------------------
3: is a number that is unique in the entire compilation.
4: is the user-given name of the label, if any.
5: is used in jump.c for the use-count of the label.
- 6: is used in flow.c to point to the chain of label_ref's to this label. */
-DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuis00", 'x')
+ 6: is used in flow.c to point to the chain of label_ref's to this label.
+ 7: is the alternate label name. */
+DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuis00s", 'x')
/* Say where in the code a source line starts, for symbol table's sake.
Contains a filename and a line number. Line numbers <= 0 are special:
are really changed to NOTEs with a number of -1.
-2 means beginning of a name binding contour; output N_LBRAC.
-3 means end of a contour; output N_RBRAC. */
-DEF_RTL_EXPR(NOTE, "note", "iuusn", 'x')
-
-/* INLINE_HEADER is use by inline function machinery. The information
- it contains helps to build the mapping function between the rtx's of
- the function to be inlined and the current function being expanded. */
-
-DEF_RTL_EXPR(INLINE_HEADER, "inline_header", "iuuuiiiiiieeiiEeEssE", 'x')
+DEF_RTL_EXPR(NOTE, "note", "iuu0n", 'x')
/* ----------------------------------------------------------------------
Top level constituents of INSN, JUMP_INSN and CALL_INSN.
CASE_VECTOR_SHORTEN_MODE is defined, and only in an optimizing
compilations. */
-DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eEeei", 'x')
+DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eEee0", 'x')
/* ----------------------------------------------------------------------
At the top level of an instruction (perhaps under PARALLEL).
/* numeric integer constant */
DEF_RTL_EXPR(CONST_INT, "const_int", "w", 'o')
-/* numeric double constant.
- Operand 0 is the MEM that stores this constant in memory,
- or various other things (see comments at immed_double_const in varasm.c).
- Operand 1 is a chain of all CONST_DOUBLEs in use in the current function.
- Remaining operands hold the actual value.
- The number of operands may be more than 2 if cross-compiling;
- see init_rtl. */
-DEF_RTL_EXPR(CONST_DOUBLE, "const_double", "e0ww", 'o')
+/* numeric floating point constant.
+ Operand 0 ('e') is the MEM that stores this constant in memory, or
+ various other things (see comments at immed_double_const in
+ varasm.c).
+ Operand 1 ('0') is a chain of all CONST_DOUBLEs in use in the
+ current function.
+ Remaining operands hold the actual value. They are all 'w' and
+ there may be from 1 to 4; see rtl.c. */
+DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, 'o')
/* String constant. Used only for attributes right now. */
DEF_RTL_EXPR(CONST_STRING, "const_string", "s", 'o')
by a SET whose first operand is (PC). */
DEF_RTL_EXPR(PC, "pc", "", 'o')
+/* Used in the cselib routines to describe a value. */
+DEF_RTL_EXPR(VALUE, "value", "0", 'o')
+
/* A register. The "operand" is the register number, accessed with
the REGNO macro. If this number is less than FIRST_PSEUDO_REGISTER
than a hardware register is being referred to. The second operand
3rd operand: the decl for the object in the register, for
put_reg_in_stack. */
-DEF_RTL_EXPR(ADDRESSOF, "addressof", "ei0", 'o')
+DEF_RTL_EXPR(ADDRESSOF, "addressof", "eit", 'o')
/* =====================================================================
A QUEUED expression really points to a member of the queue of instructions
DEF_RTL_EXPR(LEU, "leu", "ee", '<')
DEF_RTL_EXPR(LTU, "ltu", "ee", '<')
+/* Additional floating point unordered comparision flavors. */
+DEF_RTL_EXPR(UNORDERED, "unordered", "ee", '<')
+DEF_RTL_EXPR(ORDERED, "ordered", "ee", '<')
+
+/* These are equivalent to unordered or ... */
+DEF_RTL_EXPR(UNEQ, "uneq", "ee", '<')
+DEF_RTL_EXPR(UNGE, "unge", "ee", '<')
+DEF_RTL_EXPR(UNGT, "ungt", "ee", '<')
+DEF_RTL_EXPR(UNLE, "unle", "ee", '<')
+DEF_RTL_EXPR(UNLT, "unlt", "ee", '<')
+
+/* This is an ordered NE, ie !UNEQ, ie false for NaN. */
+DEF_RTL_EXPR(LTGT, "ltgt", "ee", '<')
+
/* Represents the result of sign-extending the sole operand.
The machine modes of the operand and of the SIGN_EXTEND expression
determine how much sign-extension is going on. */
eliminated by the first CSE pass. */
DEF_RTL_EXPR(CONSTANT_P_RTX, "constant_p_rtx", "e", 'x')
+/* A placeholder for a CALL_INSN which may be turned into a normal call,
+ a sibling (tail) call or tail recursion.
+
+ Immediately after RTL generation, this placeholder will be replaced
+ by the insns to perform the call, sibcall or tail recursion.
+
+ This RTX has 4 operands. The first three are lists of instructions to
+ perform the call as a normal call, sibling call and tail recursion
+ respectively. The latter two lists may be NULL, the first may never
+ be NULL.
+
+ The last operand is the tail recursion CODE_LABEL, which may be NULL if no
+ potential tail recursive calls were found.
+
+ The tail recursion label is needed so that we can clear LABEL_PRESERVE_P
+ after we select a call method.
+
+ This method of tail-call elimination is intended to be replaced by
+ tree-based optimizations once front-end conversions are complete. */
+DEF_RTL_EXPR(CALL_PLACEHOLDER, "call_placeholder", "uuuu", 'x')
+
+/* The SSA phi operator.
+
+ The argument is a vector of 2N rtxes. Element 2N+1 is a CONST_INT
+ containing the block number of the predecessor through which control
+ has passed when the register at element 2N is used.
+
+ Note that PHI may only appear at the beginning of a basic block.
+
+ ??? There may be multiple PHI insns, but they are all evaluated
+ in parallel. This probably ought to be changed to use a real
+ PARALLEL, as that would be less confusing and more in the spirit
+ of canonical RTL. It is, however, easier to manipulate this way. */
+DEF_RTL_EXPR(PHI, "phi", "E", 'x')
+
+
/*
Local variables:
mode:c
OSDN Git Service
