Index: gcc/ChangeLog =================================================================== --- gcc/ChangeLog (revision 214171) +++ gcc/ChangeLog (revision 214172) @@ -1,3 +1,41 @@ +2014-08-19 David Malcolm + + * coretypes.h (class rtx_debug_insn): Add forward declaration. + (class rtx_nonjump_insn): Likewise. + (class rtx_jump_insn): Likewise. + (class rtx_call_insn): Likewise. + (class rtx_jump_table_data): Likewise. + (class rtx_barrier): Likewise. + (class rtx_code_label): Likewise. + (class rtx_note): Likewise. + + * rtl.h (class rtx_debug_insn): New, a subclass of rtx_insn, + adding the invariant DEBUG_INSN_P (X). + (class rtx_nonjump_insn): New, a subclass of rtx_insn, adding + the invariant NONJUMP_INSN_P (X). + (class rtx_jump_insn): New, a subclass of rtx_insn, adding + the invariant JUMP_P (X). + (class rtx_call_insn): New, a subclass of rtx_insn, adding + the invariant CALL_P (X). + (class rtx_jump_table): New, a subclass of rtx_insn, adding the + invariant JUMP_TABLE_DATA_P (X). + (class rtx_barrier): New, a subclass of rtx_insn, adding the + invariant BARRIER_P (X). + (class rtx_code_label): New, a subclass of rtx_insn, adding + the invariant LABEL_P (X). + (class rtx_note): New, a subclass of rtx_insn, adding + the invariant NOTE_P(X). + (is_a_helper ::test): New. + (is_a_helper ::test): New. + (is_a_helper ::test): New. + (is_a_helper ::test): New. + (is_a_helper ::test): New functions, + overloaded for both rtx and rtx_insn *. + (is_a_helper ::test): New. + (is_a_helper ::test): New functions, overloaded + for both rtx and rtx_insn *. + (is_a_helper ::test): New. + 2014-08-19 Marek Polacek * config/alpha/alpha.h (CLZ_DEFINED_VALUE_AT_ZERO, Index: gcc/coretypes.h =================================================================== --- gcc/coretypes.h (revision 214171) +++ gcc/coretypes.h (revision 214172) @@ -57,10 +57,18 @@ typedef const struct rtx_def *const_rtx; /* Subclasses of rtx_def, using indentation to show the class - hierarchy. + hierarchy, along with the relevant invariant. Where possible, keep this list in the same order as in rtl.def. */ class rtx_def; class rtx_insn; + class rtx_debug_insn; /* DEBUG_INSN_P (X) */ + class rtx_nonjump_insn; /* NONJUMP_INSN_P (X) */ + class rtx_jump_insn; /* JUMP_P (X) */ + class rtx_call_insn; /* CALL_P (X) */ + class rtx_jump_table_data; /* JUMP_TABLE_DATA_P (X) */ + class rtx_barrier; /* BARRIER_P (X) */ + class rtx_code_label; /* LABEL_P (X) */ + class rtx_note; /* NOTE_P (X) */ struct rtvec_def; typedef struct rtvec_def *rtvec; Index: gcc/rtl.h =================================================================== --- gcc/rtl.h (revision 214171) +++ gcc/rtl.h (revision 214172) @@ -421,6 +421,99 @@ */ }; +/* Subclasses of rtx_insn. */ + +class GTY(()) rtx_debug_insn : public rtx_insn +{ + /* No extra fields, but adds the invariant: + DEBUG_INSN_P (X) aka (GET_CODE (X) == DEBUG_INSN) + i.e. an annotation for tracking variable assignments. + + This is an instance of: + DEF_RTL_EXPR(DEBUG_INSN, "debug_insn", "uuBeiie", RTX_INSN) + from rtl.def. */ +}; + +class GTY(()) rtx_nonjump_insn : public rtx_insn +{ + /* No extra fields, but adds the invariant: + NONJUMP_INSN_P (X) aka (GET_CODE (X) == INSN) + i.e an instruction that cannot jump. + + This is an instance of: + DEF_RTL_EXPR(INSN, "insn", "uuBeiie", RTX_INSN) + from rtl.def. */ +}; + +class GTY(()) rtx_jump_insn : public rtx_insn +{ + /* No extra fields, but adds the invariant: + JUMP_P (X) aka (GET_CODE (X) == JUMP_INSN) + i.e. an instruction that can possibly jump. + + This is an instance of: + DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "uuBeiie0", RTX_INSN) + from rtl.def. */ +}; + +class GTY(()) rtx_call_insn : public rtx_insn +{ + /* No extra fields, but adds the invariant: + CALL_P (X) aka (GET_CODE (X) == CALL_INSN) + i.e. an instruction that can possibly call a subroutine + but which will not change which instruction comes next + in the current function. + + This is an instance of: + DEF_RTL_EXPR(CALL_INSN, "call_insn", "uuBeiiee", RTX_INSN) + from rtl.def. */ +}; + +class GTY(()) rtx_jump_table_data : public rtx_insn +{ + /* No extra fields, but adds the invariant: + JUMP_TABLE_DATA_P (X) aka (GET_CODE (INSN) == JUMP_TABLE_DATA) + i.e. a data for a jump table, considered an instruction for + historical reasons. + + This is an instance of: + DEF_RTL_EXPR(JUMP_TABLE_DATA, "jump_table_data", "uuBe0000", RTX_INSN) + from rtl.def. */ +}; + +class GTY(()) rtx_barrier : public rtx_insn +{ + /* No extra fields, but adds the invariant: + BARRIER_P (X) aka (GET_CODE (X) == BARRIER) + i.e. a marker that indicates that control will not flow through. + + This is an instance of: + DEF_RTL_EXPR(BARRIER, "barrier", "uu00000", RTX_EXTRA) + from rtl.def. */ +}; + +class GTY(()) rtx_code_label : public rtx_insn +{ + /* No extra fields, but adds the invariant: + LABEL_P (X) aka (GET_CODE (X) == CODE_LABEL) + i.e. a label in the assembler. + + This is an instance of: + DEF_RTL_EXPR(CODE_LABEL, "code_label", "uuB00is", RTX_EXTRA) + from rtl.def. */ +}; + +class GTY(()) rtx_note : public rtx_insn +{ + /* No extra fields, but adds the invariant: + NOTE_P(X) aka (GET_CODE (X) == NOTE) + i.e. a note about the corresponding source code. + + This is an instance of: + DEF_RTL_EXPR(NOTE, "note", "uuB0ni", RTX_EXTRA) + from rtl.def. */ +}; + /* The size in bytes of an rtx header (code, mode and flags). */ #define RTX_HDR_SIZE offsetof (struct rtx_def, u) @@ -606,6 +699,94 @@ || LABEL_P (rt)); } +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return DEBUG_INSN_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return NONJUMP_INSN_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return JUMP_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return CALL_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return JUMP_TABLE_DATA_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx_insn *insn) +{ + return JUMP_TABLE_DATA_P (insn); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return BARRIER_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return LABEL_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx_insn *insn) +{ + return LABEL_P (insn); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx rt) +{ + return NOTE_P (rt); +} + +template <> +template <> +inline bool +is_a_helper ::test (rtx_insn *insn) +{ + return NOTE_P (insn); +} + /* Predicate yielding nonzero iff X is a return or simple_return. */ #define ANY_RETURN_P(X) \ (GET_CODE (X) == RETURN || GET_CODE (X) == SIMPLE_RETURN)