This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
Re: gen_rtx_FOO
- To: law at cygnus dot com
- Subject: Re: gen_rtx_FOO
- From: Richard Henderson <rth at cygnus dot com>
- Date: Tue, 30 Dec 1997 10:49:24 -0800
- Cc: Richard Henderson <rth at cygnus dot com>, egcs at cygnus dot com
- References: <199710010853.BAA13130@twiddle.rth.home> <17163.882229603@hurl.cygnus.com>
- Reply-To: Richard Henderson <rth at cygnus dot com>
On Mon, Dec 15, 1997 at 04:46:43PM -0700, Jeffrey A Law wrote:
> Considering that it does give us some compile time checks on calls
> to gen_rtx_blah and may speed up the compiler on machines that
> flush register args to the stack in varargs functions, I say let's
> go ahead and move forward with this change.
>
> Note that this patchkit may need some updating after some of jfc's
> recent changes. Any takers?
Here is an updated version of the patch, with the additional change that
rtx codes with the same format share the same generating function. This
because the generated file was really rather bigger than it needed to be.
r~
Index: Makefile.in
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/Makefile.in,v
retrieving revision 1.50
diff -u -p -r1.50 Makefile.in
--- Makefile.in 1997/12/24 23:55:56 1.50
+++ Makefile.in 1997/12/30 09:37:46
@@ -587,7 +587,7 @@ SCHED_CFLAGS = @sched_cflags@
# Language-independent object files.
OBJS = toplev.o version.o tree.o print-tree.o stor-layout.o fold-const.o \
function.o stmt.o except.o expr.o calls.o expmed.o explow.o optabs.o \
- varasm.o rtl.o print-rtl.o rtlanal.o emit-rtl.o real.o regmove.o \
+ varasm.o rtl.o print-rtl.o rtlanal.o emit-rtl.o genrtl.o real.o regmove.o \
dbxout.o sdbout.o dwarfout.o dwarf2out.o xcoffout.o bitmap.o alias.o \
integrate.o jump.o cse.o loop.o unroll.o flow.o stupid.o combine.o \
regclass.o local-alloc.o global.o reload.o reload1.o caller-save.o \
@@ -598,7 +598,8 @@ OBJS = toplev.o version.o tree.o print-t
# GEN files are listed separately, so they can be built before doing parallel
# makes for cc1 or cc1plus. Otherwise sequent parallel make attempts to load
# them before rtl.o is compiled.
-GEN= genemit genoutput genrecog genextract genflags gencodes genconfig genpeep
+GEN= genemit genoutput genrecog genextract genflags gencodes genconfig \
+ genpeep gengenrtl
CCCP=cccp
# Uncomment this line if you want to use cppmain (w/cpplib) as cpp.
@@ -607,13 +608,14 @@ CCCP=cccp
# Files to be copied away after each stage in building.
STAGESTUFF = *$(objext) insn-flags.h insn-config.h insn-codes.h \
insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \
- insn-attr.h insn-attrtab.c insn-opinit.c \
+ insn-attr.h insn-attrtab.c insn-opinit.c genrtl.c genrtl.h \
stamp-flags stamp-config stamp-codes stamp-mlib \
stamp-output stamp-recog stamp-emit stamp-extract stamp-peep \
- stamp-attr stamp-attrtab stamp-opinit stamp-proto stamp-crt stamp-crtS stamp-crt0 \
+ stamp-attr stamp-attrtab stamp-opinit stamp-proto stamp-crt stamp-crtS \
+ stamp-crt0 stamp-genrtl \
genemit$(exeext) genoutput$(exeext) genrecog$(exeext) genextract$(exeext) \
genflags$(exeext) gencodes$(exeext) genconfig$(exeext) genpeep$(exeext) \
- genattrtab$(exeext) genattr$(exeext) genopinit$(exeext) \
+ genattrtab$(exeext) genattr$(exeext) genopinit$(exeext) gengenrtl$(exeext) \
$(BC_ALL) \
stamp-bcarity stamp-bcopcode stamp-bcopname \
bi-arity$(exeext) bi-opcode$(exeext) bi-opname$(exeext) \
@@ -666,7 +668,8 @@ DPBIT_FUNCS = _pack_df _unpack_df _addsu
# If it is, rm *.o is an easy way to do it.
# CONFIG_H = $(host_xm_file) $(tm_file)
CONFIG_H =
-RTL_H = rtl.h rtl.def gansidecl.h machmode.h machmode.def
+RTL_BASE_H = rtl.h rtl.def gansidecl.h machmode.h machmode.def
+RTL_H = $(RTL_BASE_H) genrtl.h
TREE_H = tree.h real.h tree.def gansidecl.h machmode.h machmode.def
BYTECODE_H = bytecode.h bc-emit.h bc-optab.h
BASIC_BLOCK_H = basic-block.h bitmap.h
@@ -1239,8 +1242,8 @@ $(srcdir)/c-gperf.h: c-parse.gperf
c-decl.o : c-decl.c $(CONFIG_H) $(TREE_H) c-tree.h c-lex.h flags.h output.h
c-typeck.o : c-typeck.c $(CONFIG_H) $(TREE_H) c-tree.h flags.h output.h
c-lang.o : c-lang.c $(CONFIG_H) $(TREE_H)
-c-lex.o : c-lex.c $(CONFIG_H) $(TREE_H) c-lex.h c-tree.h $(srcdir)/c-parse.h \
- input.h flags.h $(srcdir)/c-gperf.h c-pragma.h
+c-lex.o : c-lex.c $(CONFIG_H) $(TREE_H) $(RTL_H) c-lex.h c-tree.h \
+ $(srcdir)/c-parse.h input.h flags.h $(srcdir)/c-gperf.h c-pragma.h
c-aux-info.o : c-aux-info.c $(CONFIG_H) $(TREE_H) c-tree.h flags.h
c-convert.o : c-convert.c $(CONFIG_H) $(TREE_H) flags.h
c-pragma.o: c-pragma.c $(CONFIG_H) $(TREE_H) except.h function.h \
@@ -1577,6 +1580,15 @@ stamp-output : $(md_file) genoutput $(sr
./genoutput $(md_file) > tmp-output.c
$(srcdir)/move-if-change tmp-output.c insn-output.c
touch stamp-output
+
+genrtl.o : genrtl.c $(CONFIG_H) $(RTL_H)
+genrtl.c genrtl.h : stamp-genrtl
+stamp-genrtl: gengenrtl $(srcdir)/move-if-change $(RTL_BASE_H)
+ ./gengenrtl tmp-genrtl.h tmp-genrtl.c
+ $(srcdir)/move-if-change tmp-genrtl.h genrtl.h
+ $(srcdir)/move-if-change tmp-genrtl.c genrtl.c
+ touch stamp-genrtl
+
#
# Compile the programs that generate insn-* from the machine description.
# They are compiled with $(HOST_CC), and associated libraries,
@@ -1670,6 +1682,14 @@ genoutput : genoutput.o $(HOST_RTL) $(HO
genoutput.o : genoutput.c $(RTL_H) $(build_xm_file)
$(HOST_CC) -c $(HOST_CFLAGS) $(HOST_CPPFLAGS) $(INCLUDES) $(srcdir)/genoutput.c
+
+gengenrtl : gengenrtl.o $(HOST_LIBDEPS)
+ $(HOST_CC) $(HOST_CFLAGS) $(HOST_LDFLAGS) -o $@ \
+ gengenrtl.o $(HOST_LIBS)
+
+gengenrtl.o : gengenrtl.c $(RTL_BASE_H)
+ $(HOST_CC) -c $(HOST_CFLAGS) $(HOST_CPPFLAGS) $(INCLUDES) $(srcdir)/gengenrtl.c
+
#
# Compile the libraries to be used by gen*.
# If we are not cross-building, gen* use the same .o's that cc1 will use,
Index: emit-rtl.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/emit-rtl.c,v
retrieving revision 1.9
diff -u -p -r1.9 emit-rtl.c
--- emit-rtl.c 1997/12/20 11:31:27 1.9
+++ emit-rtl.c 1997/12/30 09:39:19
@@ -259,6 +259,64 @@ static rtx make_jump_insn_raw PROTO((rt
static rtx make_call_insn_raw PROTO((rtx));
static rtx find_line_note PROTO((rtx));
+rtx
+gen_rtx_CONST_INT (mode, arg)
+ enum machine_mode mode;
+ HOST_WIDE_INT arg;
+{
+ if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
+ return &const_int_rtx[arg + MAX_SAVED_CONST_INT];
+
+#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
+ if (const_true_rtx && arg == STORE_FLAG_VALUE)
+ return const_true_rtx;
+#endif
+
+ return gen_rtx_raw_CONST_INT (mode, arg);
+}
+
+rtx
+gen_rtx_REG (mode, regno)
+ enum machine_mode mode;
+ int regno;
+{
+ /* In case the MD file explicitly references the frame pointer, have
+ all such references point to the same frame pointer. This is
+ used during frame pointer elimination to distinguish the explicit
+ references to these registers from pseudos that happened to be
+ assigned to them.
+
+ If we have eliminated the frame pointer or arg pointer, we will
+ be using it as a normal register, for example as a spill
+ register. In such cases, we might be accessing it in a mode that
+ is not Pmode and therefore cannot use the pre-allocated rtx.
+
+ Also don't do this when we are making new REGs in reload, since
+ we don't want to get confused with the real pointers. */
+
+ if (mode == Pmode && !reload_in_progress)
+ {
+ if (regno == FRAME_POINTER_REGNUM)
+ return frame_pointer_rtx;
+#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+ if (regno == HARD_FRAME_POINTER_REGNUM)
+ return hard_frame_pointer_rtx;
+#endif
+#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
+ if (regno == ARG_POINTER_REGNUM)
+ return arg_pointer_rtx;
+#endif
+#ifdef RETURN_ADDRESS_POINTER_REGNUM
+ if (regno == RETURN_ADDRESS_POINTER_REGNUM)
+ return return_address_pointer_rtx;
+#endif
+ if (regno == STACK_POINTER_REGNUM)
+ return stack_pointer_rtx;
+ }
+
+ return gen_rtx_raw_REG (mode, regno);
+}
+
/* rtx gen_rtx (code, mode, [element1, ..., elementn])
**
** This routine generates an RTX of the size specified by
@@ -306,67 +364,9 @@ gen_rtx VPROTO((enum rtx_code code, enum
#endif
if (code == CONST_INT)
- {
- HOST_WIDE_INT arg = va_arg (p, HOST_WIDE_INT);
-
- if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
- return &const_int_rtx[arg + MAX_SAVED_CONST_INT];
-
-#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
- if (const_true_rtx && arg == STORE_FLAG_VALUE)
- return const_true_rtx;
-#endif
-
- rt_val = rtx_alloc (code);
- INTVAL (rt_val) = arg;
- }
+ rt_val = gen_rtx_CONST_INT (mode, va_arg (p, HOST_WIDE_INT));
else if (code == REG)
- {
- int regno = va_arg (p, int);
-
- /* In case the MD file explicitly references the frame pointer, have
- all such references point to the same frame pointer. This is used
- during frame pointer elimination to distinguish the explicit
- references to these registers from pseudos that happened to be
- assigned to them.
-
- If we have eliminated the frame pointer or arg pointer, we will
- be using it as a normal register, for example as a spill register.
- In such cases, we might be accessing it in a mode that is not
- Pmode and therefore cannot use the pre-allocated rtx.
-
- Also don't do this when we are making new REGs in reload,
- since we don't want to get confused with the real pointers. */
-
- if (regno == FRAME_POINTER_REGNUM && mode == Pmode
- && ! reload_in_progress)
- return frame_pointer_rtx;
-#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- if (regno == HARD_FRAME_POINTER_REGNUM && mode == Pmode
- && ! reload_in_progress)
- return hard_frame_pointer_rtx;
-#endif
-#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
- if (regno == ARG_POINTER_REGNUM && mode == Pmode
- && ! reload_in_progress)
- return arg_pointer_rtx;
-#endif
-#ifdef RETURN_ADDRESS_POINTER_REGNUM
- if (return_address_pointer_rtx && regno == RETURN_ADDRESS_POINTER_REGNUM
- && mode == Pmode && ! reload_in_progress)
- return return_address_pointer_rtx;
-#endif
- if (regno == STACK_POINTER_REGNUM && mode == Pmode
- && ! reload_in_progress)
- return stack_pointer_rtx;
- else
- {
- rt_val = rtx_alloc (code);
- rt_val->mode = mode;
- REGNO (rt_val) = regno;
- return rt_val;
- }
- }
+ rt_val = gen_rtx_REG (mode, va_arg (p, int));
else
{
rt_val = rtx_alloc (code); /* Allocate the storage space. */
@@ -517,7 +517,7 @@ gen_reg_rtx (mode)
realpart = gen_reg_rtx (partmode);
imagpart = gen_reg_rtx (partmode);
- return gen_rtx (CONCAT, mode, realpart, imagpart);
+ return gen_rtx_CONCAT (mode, realpart, imagpart);
}
/* Make sure regno_pointer_flag and regno_reg_rtx are large
@@ -547,7 +547,7 @@ gen_reg_rtx (mode)
regno_pointer_flag_length *= 2;
}
- val = gen_rtx (REG, mode, reg_rtx_no);
+ val = gen_rtx_raw_REG (mode, reg_rtx_no);
regno_reg_rtx[reg_rtx_no++] = val;
return val;
}
@@ -659,14 +659,14 @@ gen_lowpart_common (mode, x)
else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
return gen_lowpart_common (mode, XEXP (x, 0));
else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
- return gen_rtx (GET_CODE (x), mode, XEXP (x, 0));
+ return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
}
else if (GET_CODE (x) == SUBREG
&& (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
|| GET_MODE_SIZE (mode) == GET_MODE_UNIT_SIZE (GET_MODE (x))))
return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
? SUBREG_REG (x)
- : gen_rtx (SUBREG, mode, SUBREG_REG (x), SUBREG_WORD (x) + word));
+ : gen_rtx_SUBREG (mode, SUBREG_REG (x), SUBREG_WORD (x) + word));
else if (GET_CODE (x) == REG)
{
/* If the register is not valid for MODE, return 0. If we don't
@@ -690,9 +690,9 @@ gen_lowpart_common (mode, x)
&& x != arg_pointer_rtx
#endif
&& x != stack_pointer_rtx)
- return gen_rtx (REG, mode, REGNO (x) + word);
+ return gen_rtx_REG (mode, REGNO (x) + word);
else
- return gen_rtx (SUBREG, mode, x, word);
+ return gen_rtx_SUBREG (mode, x, word);
}
/* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
from the low-order part of the constant. */
@@ -984,8 +984,7 @@ gen_highpart (mode, x)
&& GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT
#endif
)
- return gen_rtx (CONST_INT, VOIDmode,
- CONST_DOUBLE_HIGH (x) & GET_MODE_MASK (mode));
+ return GEN_INT (CONST_DOUBLE_HIGH (x) & GET_MODE_MASK (mode));
else if (GET_CODE (x) == CONST_INT)
return const0_rtx;
else if (GET_CODE (x) == MEM)
@@ -1038,9 +1037,9 @@ gen_highpart (mode, x)
&& x != arg_pointer_rtx
#endif
&& x != stack_pointer_rtx)
- return gen_rtx (REG, mode, REGNO (x) + word);
+ return gen_rtx_REG (mode, REGNO (x) + word);
else
- return gen_rtx (SUBREG, mode, x, word);
+ return gen_rtx_SUBREG (mode, x, word);
}
else
abort ();
@@ -1131,12 +1130,12 @@ operand_subword (op, i, validate_address
|| op == arg_pointer_rtx
#endif
|| op == stack_pointer_rtx)
- return gen_rtx (SUBREG, word_mode, op, i);
+ return gen_rtx_SUBREG (word_mode, op, i);
else
- return gen_rtx (REG, word_mode, REGNO (op) + i);
+ return gen_rtx_REG (word_mode, REGNO (op) + i);
}
else if (GET_CODE (op) == SUBREG)
- return gen_rtx (SUBREG, word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
+ return gen_rtx_SUBREG (word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
else if (GET_CODE (op) == CONCAT)
{
int partwords = GET_MODE_UNIT_SIZE (GET_MODE (op)) / UNITS_PER_WORD;
@@ -1163,7 +1162,7 @@ operand_subword (op, i, validate_address
addr = memory_address (word_mode, addr);
}
- new = gen_rtx (MEM, word_mode, addr);
+ new = gen_rtx_MEM (word_mode, addr);
MEM_VOLATILE_P (new) = MEM_VOLATILE_P (op);
MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (op);
@@ -1390,8 +1389,7 @@ reverse_comparison (insn)
}
else
{
- rtx new = gen_rtx (COMPARE, VOIDmode,
- CONST0_RTX (GET_MODE (comp)), comp);
+ rtx new = gen_rtx_COMPARE (VOIDmode, CONST0_RTX (GET_MODE (comp)), comp);
if (GET_CODE (body) == SET)
SET_SRC (body) = new;
else
@@ -1432,7 +1430,7 @@ change_address (memref, mode, addr)
if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
return memref;
- new = gen_rtx (MEM, mode, addr);
+ new = gen_rtx_MEM (mode, addr);
MEM_VOLATILE_P (new) = MEM_VOLATILE_P (memref);
RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (memref);
MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (memref);
@@ -1447,9 +1445,10 @@ gen_label_rtx ()
register rtx label;
label = (output_bytecode
- ? gen_rtx (CODE_LABEL, VOIDmode, NULL, bc_get_bytecode_label ())
- : gen_rtx (CODE_LABEL, VOIDmode, 0, NULL_RTX,
- NULL_RTX, label_num++, NULL_PTR));
+ ? gen_rtx_CODE_LABEL (VOIDmode, 0, bc_get_bytecode_label (),
+ NULL_RTX, 0, NULL_PTR)
+ : gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
+ NULL_RTX, label_num++, NULL_PTR));
LABEL_NUSES (label) = 0;
return label;
@@ -1481,16 +1480,17 @@ gen_inline_header_rtx (first_insn, first
char *regno_align;
rtvec parm_reg_stack_loc;
{
- rtx header = gen_rtx (INLINE_HEADER, VOIDmode,
- cur_insn_uid++, NULL_RTX,
- first_insn, first_parm_insn,
- first_labelno, last_labelno,
- max_parm_regnum, max_regnum, args_size, pops_args,
- stack_slots, forced_labels, function_flags,
- outgoing_args_size, original_arg_vector,
- original_decl_initial,
- regno_rtx, regno_flag, regno_align,
- parm_reg_stack_loc);
+ rtx header = gen_rtx_INLINE_HEADER (VOIDmode,
+ cur_insn_uid++, NULL_RTX,
+ first_insn, first_parm_insn,
+ first_labelno, last_labelno,
+ max_parm_regnum, max_regnum, args_size,
+ pops_args, stack_slots, forced_labels,
+ function_flags, outgoing_args_size,
+ original_arg_vector,
+ original_decl_initial,
+ regno_rtx, regno_flag, regno_align,
+ parm_reg_stack_loc);
return header;
}
@@ -2085,9 +2085,8 @@ link_cc0_insns (insn)
if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
user = XVECEXP (PATTERN (user), 0, 0);
- REG_NOTES (user) = gen_rtx (INSN_LIST, REG_CC_SETTER, insn,
- REG_NOTES (user));
- REG_NOTES (insn) = gen_rtx (INSN_LIST, REG_CC_USER, user, REG_NOTES (insn));
+ REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn, REG_NOTES (user));
+ REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
}
/* Return the next insn that uses CC0 after INSN, which is assumed to
@@ -3232,7 +3231,7 @@ gen_sequence ()
cache it. */
push_obstacks_nochange ();
rtl_in_saveable_obstack ();
- result = gen_rtx (SEQUENCE, VOIDmode, rtvec_alloc (len));
+ result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
pop_obstacks ();
}
@@ -3369,7 +3368,7 @@ init_emit_once (line_numbers)
&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
const_true_rtx = &const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
else
- const_true_rtx = gen_rtx (CONST_INT, VOIDmode, STORE_FLAG_VALUE);
+ const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
dconst0 = REAL_VALUE_ATOF ("0", DFmode);
dconst1 = REAL_VALUE_ATOF ("1", DFmode);
@@ -3434,14 +3433,14 @@ init_emit_once (line_numbers)
PUT_MODE (virtual_outgoing_args_rtx, Pmode);
#ifdef RETURN_ADDRESS_POINTER_REGNUM
- return_address_pointer_rtx = gen_rtx (REG, Pmode,
- RETURN_ADDRESS_POINTER_REGNUM);
+ return_address_pointer_rtx = gen_rtx_REG (Pmode,
+ RETURN_ADDRESS_POINTER_REGNUM);
#endif
#ifdef STRUCT_VALUE
struct_value_rtx = STRUCT_VALUE;
#else
- struct_value_rtx = gen_rtx (REG, Pmode, STRUCT_VALUE_REGNUM);
+ struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
#endif
#ifdef STRUCT_VALUE_INCOMING
@@ -3449,18 +3448,18 @@ init_emit_once (line_numbers)
#else
#ifdef STRUCT_VALUE_INCOMING_REGNUM
struct_value_incoming_rtx
- = gen_rtx (REG, Pmode, STRUCT_VALUE_INCOMING_REGNUM);
+ = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
#else
struct_value_incoming_rtx = struct_value_rtx;
#endif
#endif
#ifdef STATIC_CHAIN_REGNUM
- static_chain_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
+ static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
#ifdef STATIC_CHAIN_INCOMING_REGNUM
if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
- static_chain_incoming_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_INCOMING_REGNUM);
+ static_chain_incoming_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
else
#endif
static_chain_incoming_rtx = static_chain_rtx;
@@ -3477,6 +3476,6 @@ init_emit_once (line_numbers)
#endif
#ifdef PIC_OFFSET_TABLE_REGNUM
- pic_offset_table_rtx = gen_rtx (REG, Pmode, PIC_OFFSET_TABLE_REGNUM);
+ pic_offset_table_rtx = gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
#endif
}
Index: genemit.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/genemit.c,v
retrieving revision 1.2
diff -u -p -r1.2 genemit.c
--- genemit.c 1997/12/20 11:31:39 1.2
+++ genemit.c 1997/12/30 09:40:20
@@ -188,7 +188,7 @@ gen_exp (x)
return;
case MATCH_SCRATCH:
- printf ("gen_rtx (SCRATCH, %smode, 0)", GET_MODE_NAME (GET_MODE (x)));
+ printf ("gen_rtx_SCRATCH (%smode)", GET_MODE_NAME (GET_MODE (x)));
return;
case ADDRESS:
@@ -230,9 +230,9 @@ gen_exp (x)
break;
}
- printf ("gen_rtx (");
+ printf ("gen_rtx_");
print_code (code);
- printf (", %smode", GET_MODE_NAME (GET_MODE (x)));
+ printf (" (%smode", GET_MODE_NAME (GET_MODE (x)));
fmt = GET_RTX_FORMAT (code);
len = GET_RTX_LENGTH (code);
@@ -371,7 +371,7 @@ gen_insn (insn)
}
else
{
- printf (" return gen_rtx (PARALLEL, VOIDmode, gen_rtvec (%d", XVECLEN (insn, 1));
+ printf (" return gen_rtx_PARALLEL (VOIDmode, gen_rtvec (%d", XVECLEN (insn, 1));
for (i = 0; i < XVECLEN (insn, 1); i++)
{
printf (",\n\t\t");
Index: rtl.h
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/rtl.h,v
retrieving revision 1.13
diff -u -p -r1.13 rtl.h
--- rtl.h 1997/12/24 21:39:44 1.13
+++ rtl.h 1997/12/30 09:41:11
@@ -681,8 +681,6 @@ extern int ceil_log2 PROTO((unsigned H
extern rtx plus_constant_wide PROTO((rtx, HOST_WIDE_INT));
extern rtx plus_constant_for_output_wide PROTO((rtx, HOST_WIDE_INT));
-#define GEN_INT(N) gen_rtx (CONST_INT, VOIDmode, (HOST_WIDE_INT) (N))
-
struct bc_label;
extern rtx bc_gen_rtx PROTO ((char *, int,
struct bc_label *));
@@ -934,6 +932,22 @@ extern rtx struct_value_incoming_rtx;
extern rtx static_chain_rtx;
extern rtx static_chain_incoming_rtx;
+
+/* Include the RTL generation functions. */
+
+#ifndef NO_GENRTL_H
+#include "genrtl.h"
+#endif
+
+/* There are two RTL codes that require special attention; the generation
+ functions included above do the raw handling. */
+
+extern rtx gen_rtx_CONST_INT PROTO((enum machine_mode, HOST_WIDE_INT));
+extern rtx gen_rtx_REG PROTO((enum machine_mode, int));
+
+#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (N))
+
+
/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
is used to represent the frame pointer. This is because the
hard frame pointer and the automatic variables are separated by an amount
@@ -1376,4 +1390,3 @@ extern void init_alias_analysis PROTO (
extern void end_alias_analysis PROTO ((void));
#endif /* _RTL_H */
-
--- /dev/null Mon Dec 31 20:00:00 1979
+++ gengenrtl.c Tue Dec 30 01:27:58 1997
@@ -0,0 +1,287 @@
+/* Generate code to allocate RTL structures.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC 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 2, or (at your option)
+any later version.
+
+GNU CC 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 GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+
+#include "hconfig.h"
+#include <stdio.h>
+
+#include "obstack.h"
+#define obstack_chunk_alloc xmalloc
+#define obstack_chunk_free free
+
+#define NO_GENRTL_H
+#include "rtl.h"
+
+
+struct rtx_definition
+{
+ const char *enumname, *name, *format;
+};
+
+#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) { # ENUM, NAME, FORMAT },
+
+struct rtx_definition defs[] =
+{
+#include "rtl.def" /* rtl expressions are documented here */
+};
+
+const char *formats[NUM_RTX_CODE];
+
+static const char *
+type_from_format (char c)
+{
+ switch (c)
+ {
+ case 'i':
+ return "int";
+ case 'w':
+ return "HOST_WIDE_INT";
+ case 's':
+ return "char *";
+ case 'e':
+ case 'u':
+ return "rtx";
+ case 'E':
+ return "rtvec";
+ default:
+ abort ();
+ }
+}
+
+static const char *
+accessor_from_format (char c)
+{
+ switch (c)
+ {
+ case 'i':
+ return "XINT";
+ case 'w':
+ return "XWINT";
+ case 's':
+ return "XSTR";
+ case 'e':
+ case 'u':
+ return "XEXP";
+ case 'E':
+ return "XVEC";
+ default:
+ abort ();
+ }
+}
+
+static int
+special_format (fmt)
+ const char *fmt;
+{
+ return (strchr (fmt, '*') != 0
+ || strchr (fmt, 'V') != 0
+ || strchr (fmt, 'S') != 0
+ || strchr (fmt, 'n') != 0);
+}
+
+static int
+special_rtx (idx)
+ int idx;
+{
+ return (strcmp (defs[idx].enumname, "CONST_INT") == 0
+ || strcmp (defs[idx].enumname, "REG") == 0);
+}
+
+static void
+find_formats ()
+{
+ int i;
+
+ for (i = 0; i < NUM_RTX_CODE; ++i)
+ {
+ const char **f;
+
+ if (special_format (defs[i].format))
+ continue;
+
+ for (f = formats; *f ; ++f)
+ if (!strcmp(*f, defs[i].format))
+ break;
+
+ if (!*f)
+ *f = defs[i].format;
+ }
+}
+
+static void
+gendecl (f, format)
+ FILE *f;
+ const char *format;
+{
+ const char *p;
+ int i;
+
+ fprintf (f, "extern rtx gen_rtx_fmt_%s PROTO((RTX_CODE, enum machine_mode mode",
+ format);
+ for (p = format, i = 0; *p ; ++p)
+ if (*p != '0')
+ fprintf (f, ", %s arg%d", type_from_format (*p), i++);
+ fprintf (f, "));\n");
+}
+
+static void
+genmacro (f, idx)
+ FILE *f;
+ int idx;
+{
+ const char *p;
+ int i;
+
+ fprintf (f, "#define gen_rtx_%s%s(mode",
+ (special_rtx (idx) ? "raw_" : ""), defs[idx].enumname);
+
+ for (p = defs[idx].format, i = 0; *p ; ++p)
+ if (*p != '0')
+ fprintf (f, ", arg%d", i++);
+ fprintf (f, ") ");
+
+ fprintf (f, "gen_rtx_fmt_%s(%s,(mode)", defs[idx].format, defs[idx].enumname);
+ for (p = defs[idx].format, i = 0; *p ; ++p)
+ if (*p != '0')
+ fprintf (f, ",(arg%d)", i++);
+ fprintf (f, ")\n");
+}
+
+static void
+gendef (f, format)
+ FILE *f;
+ const char *format;
+{
+ const char *p;
+ int i, j;
+
+ fprintf (f, "rtx\ngen_rtx_fmt_%s (code, mode", format);
+ for (p = format, i = 0; *p ; ++p)
+ if (*p != '0')
+ fprintf (f, ", arg%d", i++);
+
+ fprintf (f, ")\n RTX_CODE code;\n enum machine_mode mode;\n");
+ for (p = format, i = 0; *p ; ++p)
+ if (*p != '0')
+ fprintf (f, " %s arg%d;\n", type_from_format (*p), i++);
+
+ /* See rtx_alloc in rtl.c for comments. */
+ fprintf (f, "{\n");
+ fprintf (f, " register int length = sizeof (struct rtx_def)");
+ fprintf (f, " + %d * sizeof (rtunion);\n", strlen (format) - 1);
+ fprintf (f, " rtx rt = (rtx)obstack_alloc (rtl_obstack, length);\n");
+
+ fprintf (f, " if (sizeof(struct rtx_def) - sizeof(rtunion) == sizeof(int))\n");
+ fprintf (f, " *(int *)rt = 0;\n");
+ fprintf (f, " else if (sizeof(struct rtx_def) - sizeof(rtunion) == sizeof(HOST_WIDE_INT))\n");
+ fprintf (f, " *(HOST_WIDE_INT *)rt = 0;\n");
+ fprintf (f, " else\n");
+ fprintf (f, " bzero(rt, sizeof(struct rtx_def) - sizeof(rtunion));\n\n");
+
+ fprintf (f, " PUT_CODE (rt, code);\n");
+ fprintf (f, " PUT_MODE (rt, mode);\n");
+
+ for (p = format, i = j = 0; *p ; ++p, ++i)
+ if (*p != '0')
+ {
+ fprintf (f, " %s (rt, %d) = arg%d;\n",
+ accessor_from_format (*p), i, j++);
+ }
+
+ fprintf (f, "\n return rt;\n}\n\n");
+}
+
+static void
+genlegend (f)
+ FILE *f;
+{
+ fprintf (f, "/* Generated automaticaly by the program `gengenrtl'\n");
+ fprintf (f, " from the RTL description file `rtl.def' */\n\n");
+}
+
+static void
+genheader (f)
+ FILE *f;
+{
+ int i;
+ const char **fmt;
+
+ for (fmt = formats; *fmt; ++fmt)
+ gendecl (f, *fmt);
+
+ fprintf(f, "\n");
+
+ for (i = 0; i < NUM_RTX_CODE; i++)
+ {
+ if (special_format (defs[i].format))
+ continue;
+ genmacro (f, i);
+ }
+}
+
+static void
+gencode (f)
+ FILE *f;
+{
+ const char **fmt;
+
+ fprintf(f, "#include \"config.h\"\n");
+ fprintf(f, "#include \"obstack.h\"\n");
+ fprintf(f, "#include \"rtl.h\"\n\n");
+ fprintf(f, "extern struct obstack *rtl_obstack;\n\n");
+
+ for (fmt = formats; *fmt; ++fmt)
+ gendef (f, *fmt);
+}
+
+int
+main(argc, argv)
+ int argc;
+ char **argv;
+{
+ FILE *f;
+
+ if (argc != 3)
+ exit (1);
+
+ find_formats ();
+
+ f = fopen (argv[1], "w");
+ if (f == NULL)
+ {
+ perror(argv[1]);
+ exit (1);
+ }
+ genlegend (f);
+ genheader (f);
+ fclose(f);
+
+ f = fopen (argv[2], "w");
+ if (f == NULL)
+ {
+ perror(argv[2]);
+ exit (1);
+ }
+ genlegend (f);
+ gencode (f);
+ fclose(f);
+
+ exit (0);
+}