CbC/CbC_gcc: gcc/rtl.h comparison

comparison gcc/rtl.h @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Register Transfer Language (RTL) definitions for GCC
 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "real.h"
 #include "vec.h"
 #include "vecir.h"
 #include "fixed-value.h"
 #include "alias.h"
+#include "hashtab.h"
 #undef FFS  /* Some systems predefine this symbol; don't let it interfere.  */
 #undef FLOAT /* Likewise.  */
 #undef ABS /* Likewise.  */
 #undef PC /* Likewise.  */
 };
 /* RTL expression ("rtx").  */
 struct GTY((chain_next ("RTX_NEXT (&%h)"),
-		    chain_prev ("RTX_PREV (&%h)"))) rtx_def {
+	    chain_prev ("RTX_PREV (&%h)"), variable_size)) rtx_def {
 /* The kind of expression this is.  */
 ENUM_BITFIELD(rtx_code) code: 16;
 /* The kind of value the expression has.  */
 ENUM_BITFIELD(machine_mode) mode : 8;
 /* RTL vector.  These appear inside RTX's when there is a need
 for a variable number of things.  The principle use is inside
 PARALLEL expressions.  */
-struct GTY(()) rtvec_def {
+struct GTY((variable_size)) rtvec_def {
 int num_elem;		/* number of elements */
 rtx GTY ((length ("%h.num_elem"))) elem[1];
 };
 #define NULL_RTVEC (rtvec) 0
 /* Chain insns together in sequence.  */
 #define PREV_INSN(INSN)	XEXP (INSN, 1)
 #define NEXT_INSN(INSN)	XEXP (INSN, 2)
 #define BLOCK_FOR_INSN(INSN) XBBDEF (INSN, 3)
-#define INSN_LOCATOR(INSN) XINT (INSN, 4)
+/* The body of an insn.  */
+#define PATTERN(INSN)	XEXP (INSN, 4)
+#define INSN_LOCATOR(INSN) XINT (INSN, 5)
 /* LOCATION of an RTX if relevant.  */
 #define RTL_LOCATION(X) (INSN_P (X) ? \
 			 locator_location (INSN_LOCATOR (X)) \
 			 : UNKNOWN_LOCATION)
 /* LOCATION of current INSN.  */
 #define CURR_INSN_LOCATION (locator_location (curr_insn_locator ()))
-/* The body of an insn.  */
-#define PATTERN(INSN)	XEXP (INSN, 5)
 /* Code number of instruction, from when it was recognized.
 -1 means this instruction has not been recognized yet.  */
 #define INSN_CODE(INSN) XINT (INSN, 6)
 #define NOTE_DURING_CALL_P(RTX)				\
 (RTL_FLAG_CHECK1("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call)
 /* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX.  */
 #define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR)
+/* VAR_DECL/PARM_DECL DEBUG_IMPLICIT_PTR takes address of.  */
+#define DEBUG_IMPLICIT_PTR_DECL(RTX) XCTREE (RTX, 0, DEBUG_IMPLICIT_PTR)
 /* Possible initialization status of a variable.   When requested
 by the user, this information is tracked and recorded in the DWARF
 debug information, along with the variable's location.  */
 enum var_init_status
 in the input source code.  */
 #define LABEL_NAME(RTX) XCSTR (RTX, 7, CODE_LABEL)
 /* In jump.c, each label contains a count of the number
 of LABEL_REFs that point at it, so unused labels can be deleted.  */
-#define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL)
+#define LABEL_NUSES(RTX) XCINT (RTX, 5, CODE_LABEL)
 /* Labels carry a two-bit field composed of the ->jump and ->call
 bits.  This field indicates whether the label is an alternate
 entry point, and if so, what kind.  */
 enum label_kind
 #define JUMP_LABEL(INSN)   XCEXP (INSN, 8, JUMP_INSN)
 /* Once basic blocks are found, each CODE_LABEL starts a chain that
 goes through all the LABEL_REFs that jump to that label.  The chain
 eventually winds up at the CODE_LABEL: it is circular.  */
-#define LABEL_REFS(LABEL) XCEXP (LABEL, 5, CODE_LABEL)
+#define LABEL_REFS(LABEL) XCEXP (LABEL, 4, CODE_LABEL)
 /* For a REG rtx, REGNO extracts the register number.  REGNO can only
 be used on RHS.  Use SET_REGNO to change the value.  */
 #define REGNO(RTX) (rhs_regno(RTX))
 #define SET_REGNO(RTX,N) (df_ref_change_reg_with_loc (REGNO(RTX), N, RTX), XCUINT (RTX, 0, REG) = N)
+#define SET_REGNO_RAW(RTX,N) (XCUINT (RTX, 0, REG) = N)
 /* ORIGINAL_REGNO holds the number the register originally had; for a
 pseudo register turned into a hard reg this will hold the old pseudo
 register number.  */
 #define ORIGINAL_REGNO(RTX) X0UINT (RTX, 1)
 static inline unsigned int
 rhs_regno (const_rtx x)
 {
 return XCUINT (x, 0, REG);
 }
 /* 1 if RTX is a reg or parallel that is the current function's return
 value.  */
 #define REG_FUNCTION_VALUE_P(RTX)					\
 /* Maximum cost of an rtl expression.  This value has the special meaning
 not to use an rtx with this cost under any circumstances.  */
 #define MAX_COST INT_MAX
+/* A structure to hold all available cost information about an rtl
+expression.  */
+struct full_rtx_costs
+{
+int speed;
+int size;
+};
+/* Initialize a full_rtx_costs structure C to the maximum cost.  */
+static inline void
+init_costs_to_max (struct full_rtx_costs *c)
+{
+c->speed = MAX_COST;
+c->size = MAX_COST;
+}
+/* Initialize a full_rtx_costs structure C to zero cost.  */
+static inline void
+init_costs_to_zero (struct full_rtx_costs *c)
+{
+c->speed = 0;
+c->size = 0;
+}
+/* Compare two full_rtx_costs structures A and B, returning true
+if A < B when optimizing for speed.  */
+static inline bool
+costs_lt_p (struct full_rtx_costs *a, struct full_rtx_costs *b,
+	    bool speed)
+{
+if (speed)
+return (a->speed < b->speed
+	    || (a->speed == b->speed && a->size < b->size));
+else
+return (a->size < b->size
+	    || (a->size == b->size && a->speed < b->speed));
+}
+/* Increase both members of the full_rtx_costs structure C by the
+cost of N insns.  */
+static inline void
+costs_add_n_insns (struct full_rtx_costs *c, int n)
+{
+c->speed += COSTS_N_INSNS (n);
+c->size += COSTS_N_INSNS (n);
+}
 extern void init_rtlanal (void);
 extern int rtx_cost (rtx, enum rtx_code, bool);
 extern int address_cost (rtx, enum machine_mode, addr_space_t, bool);
+extern void get_full_rtx_cost (rtx, enum rtx_code, struct full_rtx_costs *);
 extern unsigned int subreg_lsb (const_rtx);
 extern unsigned int subreg_lsb_1 (enum machine_mode, enum machine_mode,
 				  unsigned int);
 extern unsigned int subreg_regno_offset	(unsigned int, enum machine_mode,
 					 unsigned int, enum machine_mode);
 (RTL_FLAG_CHECK1("MEM_SCALAR_P", (RTX), MEM)->return_val)
 /* 1 if RTX is a mem that cannot trap.  */
 #define MEM_NOTRAP_P(RTX) \
 (RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call)
-/* If VAL is nonzero, set MEM_IN_STRUCT_P and clear MEM_SCALAR_P in
-RTX.  Otherwise, vice versa.  Use this macro only when you are
-*sure* that you know that the MEM is in a structure, or is a
-scalar.  VAL is evaluated only once.  */
-#define MEM_SET_IN_STRUCT_P(RTX, VAL)		\
-do {						\
-if (VAL)					\
-{						\
-MEM_IN_STRUCT_P (RTX) = 1;		\
-MEM_SCALAR_P (RTX) = 0;			\
-}						\
-else						\
-{						\
-MEM_IN_STRUCT_P (RTX) = 0;		\
-MEM_SCALAR_P (RTX) = 1;			\
-}						\
-} while (0)
 /* The memory attribute block.  We provide access macros for each value
 in the block and provide defaults if none specified.  */
 #define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1)
 /* In expmed.c */
 extern int ceil_log2 (unsigned HOST_WIDE_INT);
 /* In explow.c */
-extern void set_stack_check_libfunc (rtx);
 extern HOST_WIDE_INT trunc_int_for_mode	(HOST_WIDE_INT, enum machine_mode);
 extern rtx plus_constant (rtx, HOST_WIDE_INT);
-/* In emit-rtl.c */
-extern rtx gen_blockage (void);
-extern rtvec gen_rtvec (int, ...);
-extern rtx copy_insn_1 (rtx);
-extern rtx copy_insn (rtx);
-extern rtx gen_int_mode (HOST_WIDE_INT, enum machine_mode);
-extern rtx emit_copy_of_insn_after (rtx, rtx);
-extern void set_reg_attrs_from_value (rtx, rtx);
-extern void set_reg_attrs_for_parm (rtx, rtx);
-extern void set_reg_attrs_for_decl_rtl (tree t, rtx x);
-extern void adjust_reg_mode (rtx, enum machine_mode);
-extern int mem_expr_equal_p (const_tree, const_tree);
 /* In rtl.c */
 extern rtx rtx_alloc_stat (RTX_CODE MEM_STAT_DECL);
 #define rtx_alloc(c) rtx_alloc_stat (c MEM_STAT_INFO)
 /* In rtl.c */
 extern unsigned int rtx_size (const_rtx);
 extern rtx shallow_copy_rtx_stat (const_rtx MEM_STAT_DECL);
 #define shallow_copy_rtx(a) shallow_copy_rtx_stat (a MEM_STAT_INFO)
 extern int rtx_equal_p (const_rtx, const_rtx);
+extern hashval_t iterative_hash_rtx (const_rtx, hashval_t);
 /* In emit-rtl.c */
 extern rtvec gen_rtvec_v (int, rtx *);
 extern rtx gen_reg_rtx (enum machine_mode);
 extern rtx gen_rtx_REG_offset (rtx, enum machine_mode, unsigned int, int);
 extern rtx make_safe_from (rtx, rtx);
 extern rtx convert_memory_address_addr_space (enum machine_mode, rtx,
 					      addr_space_t);
 #define convert_memory_address(to_mode,x) \
 	convert_memory_address_addr_space ((to_mode), (x), ADDR_SPACE_GENERIC)
-extern rtx get_insns (void);
 extern const char *get_insn_name (int);
-extern rtx get_last_insn (void);
 extern rtx get_last_insn_anywhere (void);
 extern rtx get_first_nonnote_insn (void);
 extern rtx get_last_nonnote_insn (void);
 extern void start_sequence (void);
 extern void push_to_sequence (rtx);
 extern enum machine_mode get_pool_mode (const_rtx);
 extern rtx simplify_subtraction (rtx);
 /* In function.c  */
 extern rtx assign_stack_local (enum machine_mode, HOST_WIDE_INT, int);
-extern rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int, bool);
+#define ASLK_REDUCE_ALIGN 1
+#define ASLK_RECORD_PAD 2
+extern rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int, int);
 extern rtx assign_stack_temp (enum machine_mode, HOST_WIDE_INT, int);
 extern rtx assign_stack_temp_for_type (enum machine_mode,
 				       HOST_WIDE_INT, int, tree);
 extern rtx assign_temp (tree, int, int, int);
 extern rtx prev_nonnote_insn_bb (rtx);
 extern rtx next_nonnote_insn (rtx);
 extern rtx next_nonnote_insn_bb (rtx);
 extern rtx prev_nondebug_insn (rtx);
 extern rtx next_nondebug_insn (rtx);
+extern rtx prev_nonnote_nondebug_insn (rtx);
+extern rtx next_nonnote_nondebug_insn (rtx);
 extern rtx prev_real_insn (rtx);
 extern rtx next_real_insn (rtx);
 extern rtx prev_active_insn (rtx);
 extern rtx next_active_insn (rtx);
 extern int active_insn_p (const_rtx);
 extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int);
 extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
 extern void add_reg_note (rtx, enum reg_note, rtx);
 extern void remove_note (rtx, const_rtx);
 extern void remove_reg_equal_equiv_notes (rtx);
+extern void remove_reg_equal_equiv_notes_for_regno (unsigned int);
 extern int side_effects_p (const_rtx);
 extern int volatile_refs_p (const_rtx);
 extern int volatile_insn_p (const_rtx);
 extern int may_trap_p_1 (const_rtx, unsigned);
 extern int may_trap_p (const_rtx);
 extern int computed_jump_p (const_rtx);
 typedef int (*rtx_function) (rtx *, void *);
 extern int for_each_rtx (rtx *, rtx_function, void *);
+/* Callback for for_each_inc_dec, to process the autoinc operation OP
+within MEM that sets DEST to SRC + SRCOFF, or SRC if SRCOFF is
+NULL.  The callback is passed the same opaque ARG passed to
+for_each_inc_dec.  Return zero to continue looking for other
+autoinc operations, -1 to skip OP's operands, and any other value
+to interrupt the traversal and return that value to the caller of
+for_each_inc_dec.  */
+typedef int (*for_each_inc_dec_fn) (rtx mem, rtx op, rtx dest, rtx src,
+				    rtx srcoff, void *arg);
+extern int for_each_inc_dec (rtx *, for_each_inc_dec_fn, void *arg);
 typedef int (*rtx_equal_p_callback_function) (const_rtx *, const_rtx *,
 rtx *, rtx *);
 extern int rtx_equal_p_cb (const_rtx, const_rtx,
 rtx_equal_p_callback_function);
 that cannot be determined until after register allocation.  We can assume
 that in this case ELIMINABLE_REGS will be defined, one action of which
 will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM.  */
 #ifndef HARD_FRAME_POINTER_REGNUM
 #define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
+#endif
+#ifndef HARD_FRAME_POINTER_IS_FRAME_POINTER
+#define HARD_FRAME_POINTER_IS_FRAME_POINTER \
+(HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM)
+#endif
+#ifndef HARD_FRAME_POINTER_IS_ARG_POINTER
+#define HARD_FRAME_POINTER_IS_ARG_POINTER \
+(HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
 #endif
 /* Index labels for global_rtl.  */
 enum global_rtl_index
 {
 frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
 the same register.  */
 #if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
 GR_ARG_POINTER = GR_FRAME_POINTER,
 #endif
-#if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM
+#if HARD_FRAME_POINTER_IS_FRAME_POINTER
 GR_HARD_FRAME_POINTER = GR_FRAME_POINTER,
 #else
 GR_HARD_FRAME_POINTER,
 #endif
 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
-#if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
+#if HARD_FRAME_POINTER_IS_ARG_POINTER
 GR_ARG_POINTER = GR_HARD_FRAME_POINTER,
 #else
 GR_ARG_POINTER,
 #endif
 #endif
 GR_VIRTUAL_INCOMING_ARGS,
 GR_VIRTUAL_STACK_ARGS,
 GR_VIRTUAL_STACK_DYNAMIC,
 GR_VIRTUAL_OUTGOING_ARGS,
 GR_VIRTUAL_CFA,
+GR_VIRTUAL_PREFERRED_STACK_BOUNDARY,
 GR_MAX
 };
-/* Pointers to standard pieces of rtx are stored here.  */
+/* Target-dependent globals.  */
-extern GTY(()) rtx global_rtl[GR_MAX];
+struct GTY(()) target_rtl {
+/* All references to the hard registers in global_rtl_index go through
+these unique rtl objects.  On machines where the frame-pointer and
+arg-pointer are the same register, they use the same unique object.
+After register allocation, other rtl objects which used to be pseudo-regs
+may be clobbered to refer to the frame-pointer register.
+But references that were originally to the frame-pointer can be
+distinguished from the others because they contain frame_pointer_rtx.
+When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
+tricky: until register elimination has taken place hard_frame_pointer_rtx
+should be used if it is being set, and frame_pointer_rtx otherwise.  After
+register elimination hard_frame_pointer_rtx should always be used.
+On machines where the two registers are same (most) then these are the
+same.  */
+rtx x_global_rtl[GR_MAX];
+/* A unique representation of (REG:Pmode PIC_OFFSET_TABLE_REGNUM).  */
+rtx x_pic_offset_table_rtx;
+/* A unique representation of (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM).
+This is used to implement __builtin_return_address for some machines;
+see for instance the MIPS port.  */
+rtx x_return_address_pointer_rtx;
+/* Commonly used RTL for hard registers.  These objects are not
+necessarily unique, so we allocate them separately from global_rtl.
+They are initialized once per compilation unit, then copied into
+regno_reg_rtx at the beginning of each function.  */
+rtx x_initial_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
+/* A sample (mem:M stack_pointer_rtx) rtx for each mode M.  */
+rtx x_top_of_stack[MAX_MACHINE_MODE];
+/* Static hunks of RTL used by the aliasing code; these are treated
+as persistent to avoid unnecessary RTL allocations.  */
+rtx x_static_reg_base_value[FIRST_PSEUDO_REGISTER];
+};
+extern GTY(()) struct target_rtl default_target_rtl;
+#if SWITCHABLE_TARGET
+extern struct target_rtl *this_target_rtl;
+#else
+#define this_target_rtl (&default_target_rtl)
+#endif
+#define global_rtl				\
+(this_target_rtl->x_global_rtl)
+#define pic_offset_table_rtx \
+(this_target_rtl->x_pic_offset_table_rtx)
+#define return_address_pointer_rtx \
+(this_target_rtl->x_return_address_pointer_rtx)
+#define top_of_stack \
+(this_target_rtl->x_top_of_stack)
 /* Standard pieces of rtx, to be substituted directly into things.  */
 #define pc_rtx                  (global_rtl[GR_PC])
 #define cc0_rtx                 (global_rtl[GR_CC0])
 #define stack_pointer_rtx       (global_rtl[GR_STACK_POINTER])
 #define frame_pointer_rtx       (global_rtl[GR_FRAME_POINTER])
 #define hard_frame_pointer_rtx	(global_rtl[GR_HARD_FRAME_POINTER])
 #define arg_pointer_rtx		(global_rtl[GR_ARG_POINTER])
-extern GTY(()) rtx pic_offset_table_rtx;
-extern GTY(()) rtx return_address_pointer_rtx;
 /* Include the RTL generation functions.  */
 #ifndef GENERATOR_FILE
 #include "genrtl.h"
 #undef gen_rtx_ASM_INPUT
 #define virtual_cfa_rtx			(global_rtl[GR_VIRTUAL_CFA])
 #define VIRTUAL_CFA_REGNUM		((FIRST_VIRTUAL_REGISTER) + 4)
-#define LAST_VIRTUAL_REGISTER		((FIRST_VIRTUAL_REGISTER) + 4)
+#define LAST_VIRTUAL_POINTER_REGISTER	((FIRST_VIRTUAL_REGISTER) + 4)
+/* This is replaced by crtl->preferred_stack_boundary / BITS_PER_UNIT
+when finalized.  */
+#define virtual_preferred_stack_boundary_rtx \
+	(global_rtl[GR_VIRTUAL_PREFERRED_STACK_BOUNDARY])
+#define VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM \
+					((FIRST_VIRTUAL_REGISTER) + 5)
+#define LAST_VIRTUAL_REGISTER		((FIRST_VIRTUAL_REGISTER) + 5)
 /* Nonzero if REGNUM is a pointer into the stack frame.  */
 #define REGNO_PTR_FRAME_P(REGNUM)		\
 ((REGNUM) == STACK_POINTER_REGNUM		\
 || (REGNUM) == FRAME_POINTER_REGNUM		\
 || (REGNUM) == HARD_FRAME_POINTER_REGNUM	\
 || (REGNUM) == ARG_POINTER_REGNUM		\
 || ((REGNUM) >= FIRST_VIRTUAL_REGISTER	\
-&& (REGNUM) <= LAST_VIRTUAL_REGISTER))
+&& (REGNUM) <= LAST_VIRTUAL_POINTER_REGISTER))
 /* REGNUM never really appearing in the INSN stream.  */
 #define INVALID_REGNUM			(~(unsigned int) 0)
 extern rtx output_constant_def (tree, int);
 /* In cse.c */
 extern int delete_trivially_dead_insns (rtx, int);
 extern int cse_main (rtx, int);
 extern int exp_equiv_p (const_rtx, const_rtx, int, bool);
 extern unsigned hash_rtx (const_rtx x, enum machine_mode, int *, int *, bool);
+/* In dse.c */
+extern void check_for_inc_dec (rtx insn);
 /* In jump.c */
 extern int comparison_dominates_p (enum rtx_code, enum rtx_code);
 extern int condjump_p (const_rtx);
 extern int any_condjump_p (const_rtx);
 extern void mark_user_reg (rtx);
 extern void reset_used_flags (rtx);
 extern void set_used_flags (rtx);
 extern void reorder_insns (rtx, rtx, rtx);
 extern void reorder_insns_nobb (rtx, rtx, rtx);
-extern int get_max_uid (void);
 extern int get_max_insn_count (void);
 extern int in_sequence_p (void);
 extern void force_next_line_note (void);
 extern void init_emit (void);
 extern void init_emit_regs (void);
 extern void set_new_first_and_last_insn (rtx, rtx);
 extern unsigned int unshare_all_rtl (void);
 extern void unshare_all_rtl_again (rtx);
 extern void unshare_all_rtl_in_chain (rtx);
 extern void verify_rtl_sharing (void);
-extern void set_first_insn (rtx);
-extern void set_last_insn (rtx);
 extern void link_cc0_insns (rtx);
 extern void add_insn (rtx);
 extern void add_insn_before (rtx, rtx, struct basic_block_def *);
 extern void add_insn_after (rtx, rtx, struct basic_block_def *);
 extern void remove_insn (rtx);
 extern void schedule_insns (void);
 /* In sched-ebb.c.  */
 extern void schedule_ebbs (void);
-/* In haifa-sched.c.  */
-extern void fix_sched_param (const char *, const char *);
 /* In sel-sched-dump.c.  */
 extern void sel_sched_fix_param (const char *param, const char *val);
 /* In print-rtl.c */
 extern const char *print_rtx_head;
 extern void reposition_prologue_and_epilogue_notes (void);
 extern int prologue_epilogue_contains (const_rtx);
 extern int sibcall_epilogue_contains (const_rtx);
 extern void mark_temp_addr_taken (rtx);
 extern void update_temp_slot_address (rtx, rtx);
-extern void maybe_copy_epilogue_insn (rtx, rtx);
+extern void maybe_copy_prologue_epilogue_insn (rtx, rtx);
 /* In stmt.c */
 extern void expand_null_return (void);
 extern void expand_naked_return (void);
 extern void emit_jump (rtx);
 extern HARD_REG_SET eliminable_regset;
 #endif
 extern void mark_elimination (int, int);
 /* In reginfo.c */
-extern int reg_classes_intersect_p (enum reg_class, enum reg_class);
+extern int reg_classes_intersect_p (reg_class_t, reg_class_t);
-extern int reg_class_subset_p (enum reg_class, enum reg_class);
+extern int reg_class_subset_p (reg_class_t, reg_class_t);
 extern void globalize_reg (int);
 extern void init_reg_modes_target (void);
 extern void init_regs (void);
 extern void reinit_regs (void);
 extern void init_fake_stack_mems (void);
 extern void save_register_info (void);
 extern void init_reg_sets (void);
 extern void regclass (rtx, int);
 extern void reg_scan (rtx, unsigned int);
 extern void fix_register (const char *, int, int);
-extern bool invalid_mode_change_p (unsigned int, enum reg_class,
+extern bool invalid_mode_change_p (unsigned int, enum reg_class);
-				   enum machine_mode);
 /* In reorg.c */
 extern void dbr_schedule (rtx);
 /* In reload1.c */
 extern rtx emit_library_call_value (rtx, rtx, enum libcall_type,
 				    enum machine_mode, int, ...);
 /* In varasm.c */
 extern void init_varasm_once (void);
-extern enum tls_model decl_default_tls_model (const_tree);
 extern rtx make_debug_expr_from_rtl (const_rtx);
-/* In rtl.c */
-extern void traverse_md_constants (int (*) (void **, void *), void *);
-struct md_constant { char *name, *value; };
 /* In read-rtl.c */
-extern int read_skip_spaces (FILE *);
+extern bool read_rtx (const char *, rtx *);
-extern bool read_rtx (FILE *, rtx *, int *);
-extern void copy_rtx_ptr_loc (const void *, const void *);
-extern void print_rtx_ptr_loc (const void *);
-extern const char *join_c_conditions (const char *, const char *);
-extern void print_c_condition (const char *);
-extern const char *read_rtx_filename;
-extern int read_rtx_lineno;
 /* In alias.c */
 extern rtx canon_rtx (rtx);
 extern int true_dependence (const_rtx, enum machine_mode, const_rtx, bool (*)(const_rtx, bool));
 extern rtx get_addr (rtx);
 extern int canon_true_dependence (const_rtx, enum machine_mode, rtx, const_rtx,
 				  rtx, bool (*)(const_rtx, bool));
 extern int read_dependence (const_rtx, const_rtx);
 extern int anti_dependence (const_rtx, const_rtx);
 extern int output_dependence (const_rtx, const_rtx);
+extern int may_alias_p (const_rtx, const_rtx);
 extern void init_alias_target (void);
 extern void init_alias_analysis (void);
 extern void end_alias_analysis (void);
+extern void vt_equate_reg_base_value (const_rtx, const_rtx);
 extern bool memory_modified_in_insn_p (const_rtx, const_rtx);
 extern rtx find_base_term (rtx);
 extern rtx gen_hard_reg_clobber (enum machine_mode, unsigned int);
 extern rtx get_reg_known_value (unsigned int);
 extern bool get_reg_known_equiv_p (unsigned int);
+extern rtx get_reg_base_value (unsigned int);
 #ifdef STACK_REGS
 extern int stack_regs_mentioned (const_rtx insn);
 #endif
 extern tree get_curr_insn_block (void);
 extern int curr_insn_locator (void);
 extern bool optimize_insn_for_size_p (void);
 extern bool optimize_insn_for_speed_p (void);
+/* rtl-error.c */
+extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *)
+ATTRIBUTE_NORETURN;
+extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *)
+ATTRIBUTE_NORETURN;
+#define fatal_insn(msgid, insn) \
+	_fatal_insn (msgid, insn, __FILE__, __LINE__, __FUNCTION__)
+#define fatal_insn_not_found(insn) \
+	_fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__)
 #endif /* ! GCC_RTL_H */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/rtl.h @ 67:f6334be47118