OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

decl.c, [...]: Remove redundant enum from machine_mode. 

gcc/ada/
	* gcc-interface/decl.c, gcc-interface/gigi.h, gcc-interface/misc.c,
	gcc-interface/trans.c, gcc-interface/utils.c, gcc-interface/utils2.c:
	Remove redundant enum from machine_mode.

gcc/c-family/
	* c-common.c, c-common.h, c-cppbuiltin.c, c-lex.c: Remove redundant
	enum from machine_mode.

gcc/c/
	* c-decl.c, c-tree.h, c-typeck.c: Remove redundant enum from
	machine_mode.

gcc/cp/
	* constexpr.c: Remove redundant enum from machine_mode.

gcc/fortran/
	* trans-types.c, trans-types.h: Remove redundant enum from
	machine_mode.

gcc/go/
	* go-lang.c: Remove redundant enum from machine_mode.

gcc/java/
	* builtins.c, java-tree.h, typeck.c: Remove redundant enum from
	machine_mode.

gcc/lto/
	* lto-lang.c: Remove redundant enum from machine_mode.

gcc/
	* addresses.h, alias.c, asan.c, auto-inc-dec.c, bt-load.c, builtins.c,
	builtins.h, caller-save.c, calls.c, calls.h, cfgexpand.c, cfgloop.h,
	cfgrtl.c, combine.c, compare-elim.c, config/aarch64/aarch64-builtins.c,
	config/aarch64/aarch64-protos.h, config/aarch64/aarch64-simd.md,
	config/aarch64/aarch64.c, config/aarch64/aarch64.h,
	config/aarch64/aarch64.md, config/alpha/alpha-protos.h,
	config/alpha/alpha.c, config/arc/arc-protos.h, config/arc/arc.c,
	config/arc/arc.h, config/arc/predicates.md,
	config/arm/aarch-common-protos.h, config/arm/aarch-common.c,
	config/arm/arm-protos.h, config/arm/arm.c, config/arm/arm.h,
	config/arm/arm.md, config/arm/neon.md, config/arm/thumb2.md,
	config/avr/avr-log.c, config/avr/avr-protos.h, config/avr/avr.c,
	config/avr/avr.md, config/bfin/bfin-protos.h, config/bfin/bfin.c,
	config/c6x/c6x-protos.h, config/c6x/c6x.c, config/c6x/c6x.md,
	config/cr16/cr16-protos.h, config/cr16/cr16.c,
	config/cris/cris-protos.h, config/cris/cris.c, config/cris/cris.md,
	config/darwin-protos.h, config/darwin.c,
	config/epiphany/epiphany-protos.h, config/epiphany/epiphany.c,
	config/epiphany/epiphany.md, config/fr30/fr30.c,
	config/frv/frv-protos.h, config/frv/frv.c, config/frv/predicates.md,
	config/h8300/h8300-protos.h, config/h8300/h8300.c,
	config/i386/i386-builtin-types.awk, config/i386/i386-protos.h,
	config/i386/i386.c, config/i386/i386.md, config/i386/predicates.md,
	config/i386/sse.md, config/i386/sync.md, config/ia64/ia64-protos.h,
	config/ia64/ia64.c, config/iq2000/iq2000-protos.h,
	config/iq2000/iq2000.c, config/iq2000/iq2000.md,
	config/lm32/lm32-protos.h, config/lm32/lm32.c,
	config/m32c/m32c-protos.h, config/m32c/m32c.c,
	config/m32r/m32r-protos.h, config/m32r/m32r.c,
	config/m68k/m68k-protos.h, config/m68k/m68k.c,
	config/mcore/mcore-protos.h, config/mcore/mcore.c,
	config/mcore/mcore.md, config/mep/mep-protos.h, config/mep/mep.c,
	config/microblaze/microblaze-protos.h, config/microblaze/microblaze.c,
	config/mips/mips-protos.h, config/mips/mips.c,
	config/mmix/mmix-protos.h, config/mmix/mmix.c,
	config/mn10300/mn10300-protos.h, config/mn10300/mn10300.c,
	config/moxie/moxie.c, config/msp430/msp430-protos.h,
	config/msp430/msp430.c, config/nds32/nds32-cost.c,
	config/nds32/nds32-intrinsic.c, config/nds32/nds32-md-auxiliary.c,
	config/nds32/nds32-protos.h, config/nds32/nds32.c,
	config/nios2/nios2-protos.h, config/nios2/nios2.c,
	config/pa/pa-protos.h, config/pa/pa.c, config/pdp11/pdp11-protos.h,
	config/pdp11/pdp11.c, config/rl78/rl78-protos.h, config/rl78/rl78.c,
	config/rs6000/altivec.md, config/rs6000/rs6000-c.c,
	config/rs6000/rs6000-protos.h, config/rs6000/rs6000.c,
	config/rs6000/rs6000.h, config/rx/rx-protos.h, config/rx/rx.c,
	config/s390/predicates.md, config/s390/s390-protos.h,
	config/s390/s390.c, config/s390/s390.h, config/s390/s390.md,
	config/sh/predicates.md, config/sh/sh-protos.h, config/sh/sh.c,
	config/sh/sh.md, config/sparc/predicates.md,
	config/sparc/sparc-protos.h, config/sparc/sparc.c,
	config/sparc/sparc.md, config/spu/spu-protos.h, config/spu/spu.c,
	config/stormy16/stormy16-protos.h, config/stormy16/stormy16.c,
	config/tilegx/tilegx-protos.h, config/tilegx/tilegx.c,
	config/tilegx/tilegx.md, config/tilepro/tilepro-protos.h,
	config/tilepro/tilepro.c, config/v850/v850-protos.h,
	config/v850/v850.c, config/v850/v850.md, config/vax/vax-protos.h,
	config/vax/vax.c, config/vms/vms-c.c, config/xtensa/xtensa-protos.h,
	config/xtensa/xtensa.c, coverage.c, cprop.c, cse.c, cselib.c, cselib.h,
	dbxout.c, ddg.c, df-problems.c, dfp.c, dfp.h, doc/md.texi,
	doc/rtl.texi, doc/tm.texi, doc/tm.texi.in, dojump.c, dse.c,
	dwarf2cfi.c, dwarf2out.c, dwarf2out.h, emit-rtl.c, emit-rtl.h,
	except.c, explow.c, expmed.c, expmed.h, expr.c, expr.h, final.c,
	fixed-value.c, fixed-value.h, fold-const.c, function.c, function.h,
	fwprop.c, gcse.c, gengenrtl.c, genmodes.c, genopinit.c, genoutput.c,
	genpreds.c, genrecog.c, gensupport.c, gimple-ssa-strength-reduction.c,
	graphite-clast-to-gimple.c, haifa-sched.c, hooks.c, hooks.h, ifcvt.c,
	internal-fn.c, ira-build.c, ira-color.c, ira-conflicts.c, ira-costs.c,
	ira-emit.c, ira-int.h, ira-lives.c, ira.c, ira.h, jump.c, langhooks.h,
	libfuncs.h, lists.c, loop-doloop.c, loop-invariant.c, loop-iv.c,
	loop-unroll.c, lower-subreg.c, lower-subreg.h, lra-assigns.c,
	lra-constraints.c, lra-eliminations.c, lra-int.h, lra-lives.c,
	lra-spills.c, lra.c, lra.h, machmode.h, omp-low.c, optabs.c, optabs.h,
	output.h, postreload.c, print-tree.c, read-rtl.c, real.c, real.h,
	recog.c, recog.h, ree.c, reg-stack.c, regcprop.c, reginfo.c,
	regrename.c, regs.h, reload.c, reload.h, reload1.c, rtl.c, rtl.h,
	rtlanal.c, rtlhash.c, rtlhooks-def.h, rtlhooks.c, sched-deps.c,
	sel-sched-dump.c, sel-sched-ir.c, sel-sched-ir.h, sel-sched.c,
	simplify-rtx.c, stmt.c, stor-layout.c, stor-layout.h, target.def,
	targhooks.c, targhooks.h, tree-affine.c, tree-call-cdce.c,
	tree-complex.c, tree-data-ref.c, tree-dfa.c, tree-if-conv.c,
	tree-inline.c, tree-outof-ssa.c, tree-scalar-evolution.c,
	tree-ssa-address.c, tree-ssa-ccp.c, tree-ssa-loop-ivopts.c,
	tree-ssa-loop-ivopts.h, tree-ssa-loop-manip.c,
	tree-ssa-loop-prefetch.c, tree-ssa-math-opts.c, tree-ssa-reassoc.c,
	tree-ssa-sccvn.c, tree-streamer-in.c, tree-switch-conversion.c,
	tree-vect-data-refs.c, tree-vect-generic.c, tree-vect-loop.c,
	tree-vect-patterns.c, tree-vect-slp.c, tree-vect-stmts.c,
	tree-vrp.c, tree.c, tree.h, tsan.c, ubsan.c, valtrack.c,
	var-tracking.c, varasm.c: Remove redundant enum from
	machine_mode.
gcc/
	* gengtype.c (main): Treat machine_mode as a scalar typedef.
	* genmodes.c (emit_insn_modes_h): Hide inline functions if
	USED_FOR_TARGET.

From-SVN: r216834
This commit is contained in:
Richard Sandiford 2014-10-29 12:02:45 +00:00 committed by Richard Sandiford
parent ca557f533a
commit ef4bddc299
326 changed files with 5782 additions and 5646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
gcc/ChangeLog
View File

@ -1,3 +1,100 @@
2014-10-29 Richard Sandiford <richard.sandiford@arm.com>
* addresses.h, alias.c, asan.c, auto-inc-dec.c, bt-load.c, builtins.c,
builtins.h, caller-save.c, calls.c, calls.h, cfgexpand.c, cfgloop.h,
cfgrtl.c, combine.c, compare-elim.c, config/aarch64/aarch64-builtins.c,
config/aarch64/aarch64-protos.h, config/aarch64/aarch64-simd.md,
config/aarch64/aarch64.c, config/aarch64/aarch64.h,
config/aarch64/aarch64.md, config/alpha/alpha-protos.h,
config/alpha/alpha.c, config/arc/arc-protos.h, config/arc/arc.c,
config/arc/arc.h, config/arc/predicates.md,
config/arm/aarch-common-protos.h, config/arm/aarch-common.c,
config/arm/arm-protos.h, config/arm/arm.c, config/arm/arm.h,
config/arm/arm.md, config/arm/neon.md, config/arm/thumb2.md,
config/avr/avr-log.c, config/avr/avr-protos.h, config/avr/avr.c,
config/avr/avr.md, config/bfin/bfin-protos.h, config/bfin/bfin.c,
config/c6x/c6x-protos.h, config/c6x/c6x.c, config/c6x/c6x.md,
config/cr16/cr16-protos.h, config/cr16/cr16.c,
config/cris/cris-protos.h, config/cris/cris.c, config/cris/cris.md,
config/darwin-protos.h, config/darwin.c,
config/epiphany/epiphany-protos.h, config/epiphany/epiphany.c,
config/epiphany/epiphany.md, config/fr30/fr30.c,
config/frv/frv-protos.h, config/frv/frv.c, config/frv/predicates.md,
config/h8300/h8300-protos.h, config/h8300/h8300.c,
config/i386/i386-builtin-types.awk, config/i386/i386-protos.h,
config/i386/i386.c, config/i386/i386.md, config/i386/predicates.md,
config/i386/sse.md, config/i386/sync.md, config/ia64/ia64-protos.h,
config/ia64/ia64.c, config/iq2000/iq2000-protos.h,
config/iq2000/iq2000.c, config/iq2000/iq2000.md,
config/lm32/lm32-protos.h, config/lm32/lm32.c,
config/m32c/m32c-protos.h, config/m32c/m32c.c,
config/m32r/m32r-protos.h, config/m32r/m32r.c,
config/m68k/m68k-protos.h, config/m68k/m68k.c,
config/mcore/mcore-protos.h, config/mcore/mcore.c,
config/mcore/mcore.md, config/mep/mep-protos.h, config/mep/mep.c,
config/microblaze/microblaze-protos.h, config/microblaze/microblaze.c,
config/mips/mips-protos.h, config/mips/mips.c,
config/mmix/mmix-protos.h, config/mmix/mmix.c,
config/mn10300/mn10300-protos.h, config/mn10300/mn10300.c,
config/moxie/moxie.c, config/msp430/msp430-protos.h,
config/msp430/msp430.c, config/nds32/nds32-cost.c,
config/nds32/nds32-intrinsic.c, config/nds32/nds32-md-auxiliary.c,
config/nds32/nds32-protos.h, config/nds32/nds32.c,
config/nios2/nios2-protos.h, config/nios2/nios2.c,
config/pa/pa-protos.h, config/pa/pa.c, config/pdp11/pdp11-protos.h,
config/pdp11/pdp11.c, config/rl78/rl78-protos.h, config/rl78/rl78.c,
config/rs6000/altivec.md, config/rs6000/rs6000-c.c,
config/rs6000/rs6000-protos.h, config/rs6000/rs6000.c,
config/rs6000/rs6000.h, config/rx/rx-protos.h, config/rx/rx.c,
config/s390/predicates.md, config/s390/s390-protos.h,
config/s390/s390.c, config/s390/s390.h, config/s390/s390.md,
config/sh/predicates.md, config/sh/sh-protos.h, config/sh/sh.c,
config/sh/sh.md, config/sparc/predicates.md,
config/sparc/sparc-protos.h, config/sparc/sparc.c,
config/sparc/sparc.md, config/spu/spu-protos.h, config/spu/spu.c,
config/stormy16/stormy16-protos.h, config/stormy16/stormy16.c,
config/tilegx/tilegx-protos.h, config/tilegx/tilegx.c,
config/tilegx/tilegx.md, config/tilepro/tilepro-protos.h,
config/tilepro/tilepro.c, config/v850/v850-protos.h,
config/v850/v850.c, config/v850/v850.md, config/vax/vax-protos.h,
config/vax/vax.c, config/vms/vms-c.c, config/xtensa/xtensa-protos.h,
config/xtensa/xtensa.c, coverage.c, cprop.c, cse.c, cselib.c, cselib.h,
dbxout.c, ddg.c, df-problems.c, dfp.c, dfp.h, doc/md.texi,
doc/rtl.texi, doc/tm.texi, doc/tm.texi.in, dojump.c, dse.c,
dwarf2cfi.c, dwarf2out.c, dwarf2out.h, emit-rtl.c, emit-rtl.h,
except.c, explow.c, expmed.c, expmed.h, expr.c, expr.h, final.c,
fixed-value.c, fixed-value.h, fold-const.c, function.c, function.h,
fwprop.c, gcse.c, gengenrtl.c, genmodes.c, genopinit.c, genoutput.c,
genpreds.c, genrecog.c, gensupport.c, gimple-ssa-strength-reduction.c,
graphite-clast-to-gimple.c, haifa-sched.c, hooks.c, hooks.h, ifcvt.c,
internal-fn.c, ira-build.c, ira-color.c, ira-conflicts.c, ira-costs.c,
ira-emit.c, ira-int.h, ira-lives.c, ira.c, ira.h, jump.c, langhooks.h,
libfuncs.h, lists.c, loop-doloop.c, loop-invariant.c, loop-iv.c,
loop-unroll.c, lower-subreg.c, lower-subreg.h, lra-assigns.c,
lra-constraints.c, lra-eliminations.c, lra-int.h, lra-lives.c,
lra-spills.c, lra.c, lra.h, machmode.h, omp-low.c, optabs.c, optabs.h,
output.h, postreload.c, print-tree.c, read-rtl.c, real.c, real.h,
recog.c, recog.h, ree.c, reg-stack.c, regcprop.c, reginfo.c,
regrename.c, regs.h, reload.c, reload.h, reload1.c, rtl.c, rtl.h,
rtlanal.c, rtlhash.c, rtlhooks-def.h, rtlhooks.c, sched-deps.c,
sel-sched-dump.c, sel-sched-ir.c, sel-sched-ir.h, sel-sched.c,
simplify-rtx.c, stmt.c, stor-layout.c, stor-layout.h, target.def,
targhooks.c, targhooks.h, tree-affine.c, tree-call-cdce.c,
tree-complex.c, tree-data-ref.c, tree-dfa.c, tree-if-conv.c,
tree-inline.c, tree-outof-ssa.c, tree-scalar-evolution.c,
tree-ssa-address.c, tree-ssa-ccp.c, tree-ssa-loop-ivopts.c,
tree-ssa-loop-ivopts.h, tree-ssa-loop-manip.c,
tree-ssa-loop-prefetch.c, tree-ssa-math-opts.c, tree-ssa-reassoc.c,
tree-ssa-sccvn.c, tree-streamer-in.c, tree-switch-conversion.c,
tree-vect-data-refs.c, tree-vect-generic.c, tree-vect-loop.c,
tree-vect-patterns.c, tree-vect-slp.c, tree-vect-stmts.c,
tree-vrp.c, tree.c, tree.h, tsan.c, ubsan.c, valtrack.c,
var-tracking.c, varasm.c: Remove redundant enum from
machine_mode.
* gengtype.c (main): Treat machine_mode as a scalar typedef.
* genmodes.c (emit_insn_modes_h): Hide inline functions if
USED_FOR_TARGET.
2014-10-29 Richard Sandiford <richard.sandiford@arm.com>
PR rtl-optimization/63340 (part 2)

6
gcc/ada/ChangeLog
View File

@ -1,3 +1,9 @@
2014-10-29 Richard Sandiford <richard.sandiford@arm.com>
* gcc-interface/decl.c, gcc-interface/gigi.h, gcc-interface/misc.c,
gcc-interface/trans.c, gcc-interface/utils.c, gcc-interface/utils2.c:
Remove redundant enum from machine_mode.
2014-10-28 Andrew MacLeod <amacleod@redhat.com>
* gcc-interface/trans.c: Adjust include files.

10
gcc/ada/gcc-interface/decl.c
View File

@ -3738,7 +3738,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
/* True if we make a dummy type here. */
bool made_dummy = false;
/* The mode to be used for the pointer type. */
enum machine_mode p_mode = mode_for_size (esize, MODE_INT, 0);
machine_mode p_mode = mode_for_size (esize, MODE_INT, 0);
/* The GCC type used for the designated type. */
tree gnu_desig_type = NULL_TREE;
@ -4470,7 +4470,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
unsigned int size
= TREE_INT_CST_LOW (TYPE_SIZE (gnu_return_type));
unsigned int i = BITS_PER_UNIT;
enum machine_mode mode;
machine_mode mode;
while (i < size)
i <<= 1;
@ -6157,7 +6157,7 @@ elaborate_expression_1 (tree gnu_expr, Entity_Id gnat_entity, tree gnu_name,
{
HOST_WIDE_INT bitsize, bitpos;
tree offset;
enum machine_mode mode;
machine_mode mode;
int unsignedp, volatilep;
inner = get_inner_reference (inner, &bitsize, &bitpos, &offset,
@ -7841,7 +7841,7 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object,
by the smallest integral mode that's valid for pointers. */
if (TREE_CODE (gnu_type) == POINTER_TYPE || TYPE_IS_FAT_POINTER_P (gnu_type))
{
enum machine_mode p_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
machine_mode p_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
while (!targetm.valid_pointer_mode (p_mode))
p_mode = GET_MODE_WIDER_MODE (p_mode);
type_size = bitsize_int (GET_MODE_BITSIZE (p_mode));
@ -8051,7 +8051,7 @@ check_ok_for_atomic (tree object, Entity_Id gnat_entity, bool comp_p)
{
Node_Id gnat_error_point = gnat_entity;
Node_Id gnat_node;
enum machine_mode mode;
machine_mode mode;
unsigned int align;
tree size;

2
gcc/ada/gcc-interface/gigi.h
View File

@ -533,7 +533,7 @@ extern tree gnat_type_for_size (unsigned precision, int unsignedp);
/* Return a data type that has machine mode MODE. UNSIGNEDP selects
an unsigned type; otherwise a signed type is returned. */
extern tree gnat_type_for_mode (enum machine_mode mode, int unsignedp);
extern tree gnat_type_for_mode (machine_mode mode, int unsignedp);
/* Emit debug info for all global variable declarations. */
extern void gnat_write_global_declarations (void);

8
gcc/ada/gcc-interface/misc.c
View File

@ -725,8 +725,8 @@ enumerate_modes (void (*f) (const char *, int, int, int, int, int, int, int))
for (iloop = 0; iloop < NUM_MACHINE_MODES; iloop++)
{
enum machine_mode i = (enum machine_mode) iloop;
enum machine_mode inner_mode = i;
machine_mode i = (machine_mode) iloop;
machine_mode inner_mode = i;
bool float_p = false;
bool complex_p = false;
bool vector_p = false;
@ -821,7 +821,7 @@ enumerate_modes (void (*f) (const char *, int, int, int, int, int, int, int))
int
fp_prec_to_size (int prec)
{
enum machine_mode mode;
machine_mode mode;
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
@ -836,7 +836,7 @@ fp_prec_to_size (int prec)
int
fp_size_to_prec (int size)
{
enum machine_mode mode;
machine_mode mode;
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))

4
gcc/ada/gcc-interface/trans.c
View File

@ -1268,7 +1268,7 @@ Pragma_to_gnu (Node_Id gnat_node)
Node_Id gnat_expr = Expression (gnat_temp);
tree gnu_expr = gnat_to_gnu (gnat_expr);
int use_address;
enum machine_mode mode;
machine_mode mode;
tree asm_constraint = NULL_TREE;
#ifdef ASM_COMMENT_START
char *comment;
@ -2126,7 +2126,7 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
tree gnu_field_bitpos;
tree gnu_field_offset;
tree gnu_inner;
enum machine_mode mode;
machine_mode mode;
int unsignedp, volatilep;
gnu_result_type = get_unpadded_type (Etype (gnat_node));

12
gcc/ada/gcc-interface/utils.c
View File

@ -251,7 +251,7 @@ static GTY ((if_marked ("pad_type_hash_marked_p"),
static tree merge_sizes (tree, tree, tree, bool, bool);
static tree compute_related_constant (tree, tree);
static tree split_plus (tree, tree *);
static tree float_type_for_precision (int, enum machine_mode);
static tree float_type_for_precision (int, machine_mode);
static tree convert_to_fat_pointer (tree, tree);
static unsigned int scale_by_factor_of (tree, unsigned int);
static bool potential_alignment_gap (tree, tree, tree);
@ -1128,7 +1128,7 @@ make_type_from_size (tree type, tree size_tree, bool for_biased)
may need to return the thin pointer. */
if (TYPE_FAT_POINTER_P (type) && size < POINTER_SIZE * 2)
{
enum machine_mode p_mode = mode_for_size (size, MODE_INT, 0);
machine_mode p_mode = mode_for_size (size, MODE_INT, 0);
if (!targetm.valid_pointer_mode (p_mode))
p_mode = ptr_mode;
return
@ -3222,7 +3222,7 @@ gnat_type_for_size (unsigned precision, int unsignedp)
/* Likewise for floating-point types. */
static tree
float_type_for_precision (int precision, enum machine_mode mode)
float_type_for_precision (int precision, machine_mode mode)
{
tree t;
char type_name[20];
@ -3248,7 +3248,7 @@ float_type_for_precision (int precision, enum machine_mode mode)
an unsigned type; otherwise a signed type is returned. */
tree
gnat_type_for_mode (enum machine_mode mode, int unsignedp)
gnat_type_for_mode (machine_mode mode, int unsignedp)
{
if (mode == BLKmode)
return NULL_TREE;
@ -3267,7 +3267,7 @@ gnat_type_for_mode (enum machine_mode mode, int unsignedp)
if (VECTOR_MODE_P (mode))
{
enum machine_mode inner_mode = GET_MODE_INNER (mode);
machine_mode inner_mode = GET_MODE_INNER (mode);
tree inner_type = gnat_type_for_mode (inner_mode, unsignedp);
if (inner_type)
return build_vector_type_for_mode (inner_type, mode);
@ -3580,7 +3580,7 @@ build_template (tree template_type, tree array_type, tree expr)
static bool
type_for_vector_element_p (tree type)
{
enum machine_mode mode;
machine_mode mode;
if (!INTEGRAL_TYPE_P (type)
&& !SCALAR_FLOAT_TYPE_P (type)

2
gcc/ada/gcc-interface/utils2.c
View File

@ -1314,7 +1314,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
HOST_WIDE_INT bitsize;
HOST_WIDE_INT bitpos;
tree offset, inner;
enum machine_mode mode;
machine_mode mode;
int unsignedp, volatilep;
inner = get_inner_reference (operand, &bitsize, &bitpos, &offset,

6
gcc/addresses.h
View File

@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see
#define GCC_ADDRESSES_H
static inline enum reg_class
base_reg_class (enum machine_mode mode ATTRIBUTE_UNUSED,
base_reg_class (machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
enum rtx_code outer_code ATTRIBUTE_UNUSED,
enum rtx_code index_code ATTRIBUTE_UNUSED)
@ -52,7 +52,7 @@ base_reg_class (enum machine_mode mode ATTRIBUTE_UNUSED,
static inline bool
ok_for_base_p_1 (unsigned regno ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
enum rtx_code outer_code ATTRIBUTE_UNUSED,
enum rtx_code index_code ATTRIBUTE_UNUSED)
@ -77,7 +77,7 @@ ok_for_base_p_1 (unsigned regno ATTRIBUTE_UNUSED,
complete. Arguments as for the called function. */
static inline bool
regno_ok_for_base_p (unsigned regno, enum machine_mode mode, addr_space_t as,
regno_ok_for_base_p (unsigned regno, machine_mode mode, addr_space_t as,
enum rtx_code outer_code, enum rtx_code index_code)
{
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] >= 0)

18
gcc/alias.c
View File

@ -161,15 +161,15 @@ typedef struct alias_set_entry_d *alias_set_entry;
static int rtx_equal_for_memref_p (const_rtx, const_rtx);
static int memrefs_conflict_p (int, rtx, int, rtx, HOST_WIDE_INT);
static void record_set (rtx, const_rtx, void *);
static int base_alias_check (rtx, rtx, rtx, rtx, enum machine_mode,
enum machine_mode);
static int base_alias_check (rtx, rtx, rtx, rtx, machine_mode,
machine_mode);
static rtx find_base_value (rtx);
static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx);
static int insert_subset_children (splay_tree_node, void*);
static alias_set_entry get_alias_set_entry (alias_set_type);
static tree decl_for_component_ref (tree);
static int write_dependence_p (const_rtx,
const_rtx, enum machine_mode, rtx,
const_rtx, machine_mode, rtx,
bool, bool, bool);
static void memory_modified_1 (rtx, const_rtx, void *);
@ -1802,7 +1802,7 @@ may_be_sp_based_p (rtx x)
static int
base_alias_check (rtx x, rtx x_base, rtx y, rtx y_base,
enum machine_mode x_mode, enum machine_mode y_mode)
machine_mode x_mode, machine_mode y_mode)
{
/* If the address itself has no known base see if a known equivalent
value has one. If either address still has no known base, nothing
@ -2446,7 +2446,7 @@ nonoverlapping_memrefs_p (const_rtx x, const_rtx y, bool loop_invariant)
Returns 1 if there is a true dependence, 0 otherwise. */
static int
true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
true_dependence_1 (const_rtx mem, machine_mode mem_mode, rtx mem_addr,
const_rtx x, rtx x_addr, bool mem_canonicalized)
{
rtx true_mem_addr;
@ -2528,7 +2528,7 @@ true_dependence_1 (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
/* True dependence: X is read after store in MEM takes place. */
int
true_dependence (const_rtx mem, enum machine_mode mem_mode, const_rtx x)
true_dependence (const_rtx mem, machine_mode mem_mode, const_rtx x)
{
return true_dependence_1 (mem, mem_mode, NULL_RTX,
x, NULL_RTX, /*mem_canonicalized=*/false);
@ -2541,7 +2541,7 @@ true_dependence (const_rtx mem, enum machine_mode mem_mode, const_rtx x)
this value prior to canonicalizing. */
int
canon_true_dependence (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
canon_true_dependence (const_rtx mem, machine_mode mem_mode, rtx mem_addr,
const_rtx x, rtx x_addr)
{
return true_dependence_1 (mem, mem_mode, mem_addr,
@ -2556,7 +2556,7 @@ canon_true_dependence (const_rtx mem, enum machine_mode mem_mode, rtx mem_addr,
static int
write_dependence_p (const_rtx mem,
const_rtx x, enum machine_mode x_mode, rtx x_addr,
const_rtx x, machine_mode x_mode, rtx x_addr,
bool mem_canonicalized, bool x_canonicalized, bool writep)
{
rtx mem_addr;
@ -2651,7 +2651,7 @@ anti_dependence (const_rtx mem, const_rtx x)
int
canon_anti_dependence (const_rtx mem, bool mem_canonicalized,
const_rtx x, enum machine_mode x_mode, rtx x_addr)
const_rtx x, machine_mode x_mode, rtx x_addr)
{
return write_dependence_p (mem, x, x_mode, x_addr,
mem_canonicalized, /*x_canonicalized=*/true,

2
gcc/asan.c
View File

@ -1780,7 +1780,7 @@ instrument_derefs (gimple_stmt_iterator *iter, tree t,
HOST_WIDE_INT bitsize, bitpos;
tree offset;
enum machine_mode mode;
machine_mode mode;
int volatilep = 0, unsignedp = 0;
tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset,
&mode, &unsignedp, &volatilep, false);

4
gcc/auto-inc-dec.c
View File

@ -481,7 +481,7 @@ attempt_change (rtx new_addr, rtx inc_reg)
rtx_insn *mov_insn = NULL;
int regno;
rtx mem = *mem_insn.mem_loc;
enum machine_mode mode = GET_MODE (mem);
machine_mode mode = GET_MODE (mem);
rtx new_mem;
int old_cost = 0;
int new_cost = 0;
@ -621,7 +621,7 @@ try_merge (void)
/* The width of the mem being accessed. */
int size = GET_MODE_SIZE (GET_MODE (mem));
rtx_insn *last_insn = NULL;
enum machine_mode reg_mode = GET_MODE (inc_reg);
machine_mode reg_mode = GET_MODE (inc_reg);
switch (inc_insn.form)
{

2
gcc/bt-load.c
View File

@ -1153,7 +1153,7 @@ move_btr_def (basic_block new_def_bb, int btr, btr_def def, bitmap live_range,
rtx src;
rtx btr_rtx;
rtx_insn *new_insn;
enum machine_mode btr_mode;
machine_mode btr_mode;
btr_user user;
rtx set;

162
gcc/builtins.c
View File

@ -92,7 +92,7 @@ builtin_info_type builtin_info;
/* Non-zero if __builtin_constant_p should be folded right away. */
bool force_folding_builtin_constant_p;
static rtx c_readstr (const char *, enum machine_mode);
static rtx c_readstr (const char *, machine_mode);
static int target_char_cast (tree, char *);
static rtx get_memory_rtx (tree, tree);
static int apply_args_size (void);
@ -122,25 +122,25 @@ static rtx expand_builtin_next_arg (void);
static rtx expand_builtin_va_start (tree);
static rtx expand_builtin_va_end (tree);
static rtx expand_builtin_va_copy (tree);
static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
static rtx expand_builtin_memcmp (tree, rtx, machine_mode);
static rtx expand_builtin_strcmp (tree, rtx);
static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
static rtx expand_builtin_strncmp (tree, rtx, machine_mode);
static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, machine_mode);
static rtx expand_builtin_memcpy (tree, rtx);
static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
static rtx expand_builtin_mempcpy (tree, rtx, machine_mode);
static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
enum machine_mode, int);
machine_mode, int);
static rtx expand_builtin_strcpy (tree, rtx);
static rtx expand_builtin_strcpy_args (tree, tree, rtx);
static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
static rtx expand_builtin_stpcpy (tree, rtx, machine_mode);
static rtx expand_builtin_strncpy (tree, rtx);
static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, machine_mode);
static rtx expand_builtin_memset (tree, rtx, machine_mode);
static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree);
static rtx expand_builtin_bzero (tree);
static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
static rtx expand_builtin_strlen (tree, rtx, machine_mode);
static rtx expand_builtin_alloca (tree, bool);
static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
static rtx expand_builtin_unop (machine_mode, tree, rtx, rtx, optab);
static rtx expand_builtin_frame_address (tree, tree);
static tree stabilize_va_list_loc (location_t, tree, int);
static rtx expand_builtin_expect (tree, rtx);
@ -197,7 +197,7 @@ static tree fold_builtin_strspn (location_t, tree, tree);
static tree fold_builtin_strcspn (location_t, tree, tree);
static rtx expand_builtin_object_size (tree);
static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
static rtx expand_builtin_memory_chk (tree, rtx, machine_mode,
enum built_in_function);
static void maybe_emit_chk_warning (tree, enum built_in_function);
static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
@ -290,7 +290,7 @@ get_object_alignment_2 (tree exp, unsigned int *alignp,
{
HOST_WIDE_INT bitsize, bitpos;
tree offset;
enum machine_mode mode;
machine_mode mode;
int unsignedp, volatilep;
unsigned int align = BITS_PER_UNIT;
bool known_alignment = false;
@ -652,7 +652,7 @@ c_getstr (tree src)
GET_MODE_BITSIZE (MODE) bits from string constant STR. */
static rtx
c_readstr (const char *str, enum machine_mode mode)
c_readstr (const char *str, machine_mode mode)
{
HOST_WIDE_INT ch;
unsigned int i, j;
@ -826,7 +826,7 @@ static alias_set_type setjmp_alias_set = -1;
void
expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
{
enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
rtx stack_save;
rtx mem;
@ -970,7 +970,7 @@ expand_builtin_longjmp (rtx buf_addr, rtx value)
{
rtx fp, lab, stack;
rtx_insn *insn, *last;
enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
/* DRAP is needed for stack realign if longjmp is expanded to current
function */
@ -1197,7 +1197,7 @@ expand_builtin_nonlocal_goto (tree exp)
static void
expand_builtin_update_setjmp_buf (rtx buf_addr)
{
enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
rtx stack_save
= gen_rtx_MEM (sa_mode,
memory_address
@ -1359,7 +1359,7 @@ apply_args_size (void)
static int size = -1;
int align;
unsigned int regno;
enum machine_mode mode;
machine_mode mode;
/* The values computed by this function never change. */
if (size < 0)
@ -1401,7 +1401,7 @@ apply_result_size (void)
{
static int size = -1;
int align, regno;
enum machine_mode mode;
machine_mode mode;
/* The values computed by this function never change. */
if (size < 0)
@ -1442,7 +1442,7 @@ static rtx
result_vector (int savep, rtx result)
{
int regno, size, align, nelts;
enum machine_mode mode;
machine_mode mode;
rtx reg, mem;
rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
@ -1472,7 +1472,7 @@ expand_builtin_apply_args_1 (void)
{
rtx registers, tem;
int size, align, regno;
enum machine_mode mode;
machine_mode mode;
rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
/* Create a block where the arg-pointer, structure value address,
@ -1577,7 +1577,7 @@ static rtx
expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
{
int size, align, regno;
enum machine_mode mode;
machine_mode mode;
rtx incoming_args, result, reg, dest, src;
rtx_call_insn *call_insn;
rtx old_stack_level = 0;
@ -1744,7 +1744,7 @@ static void
expand_builtin_return (rtx result)
{
int size, align, regno;
enum machine_mode mode;
machine_mode mode;
rtx reg;
rtx_insn *call_fusage = 0;
@ -2024,7 +2024,7 @@ expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
rtx op0;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
enum machine_mode mode;
machine_mode mode;
bool errno_set = false;
bool try_widening = false;
tree arg;
@ -2153,7 +2153,7 @@ expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
int op1_type = REAL_TYPE;
tree fndecl = get_callee_fndecl (exp);
tree arg0, arg1;
enum machine_mode mode;
machine_mode mode;
bool errno_set = true;
switch (DECL_FUNCTION_CODE (fndecl))
@ -2262,7 +2262,7 @@ expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
tree arg0, arg1, arg2;
enum machine_mode mode;
machine_mode mode;
if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
return NULL_RTX;
@ -2335,7 +2335,7 @@ expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
rtx op0;
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
enum machine_mode mode;
machine_mode mode;
tree arg;
if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
@ -2431,7 +2431,7 @@ interclass_mathfn_icode (tree arg, tree fndecl)
{
bool errno_set = false;
optab builtin_optab = unknown_optab;
enum machine_mode mode;
machine_mode mode;
switch (DECL_FUNCTION_CODE (fndecl))
{
@ -2479,7 +2479,7 @@ expand_builtin_interclass_mathfn (tree exp, rtx target)
enum insn_code icode = CODE_FOR_nothing;
rtx op0;
tree fndecl = get_callee_fndecl (exp);
enum machine_mode mode;
machine_mode mode;
tree arg;
if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
@ -2526,7 +2526,7 @@ static rtx
expand_builtin_sincos (tree exp)
{
rtx op0, op1, op2, target1, target2;
enum machine_mode mode;
machine_mode mode;
tree arg, sinp, cosp;
int result;
location_t loc = EXPR_LOCATION (exp);
@ -2580,7 +2580,7 @@ expand_builtin_cexpi (tree exp, rtx target)
{
tree fndecl = get_callee_fndecl (exp);
tree arg, type;
enum machine_mode mode;
machine_mode mode;
rtx op0, op1, op2;
location_t loc = EXPR_LOCATION (exp);
@ -2715,7 +2715,7 @@ expand_builtin_int_roundingfn (tree exp, rtx target)
tree fndecl = get_callee_fndecl (exp);
enum built_in_function fallback_fn;
tree fallback_fndecl;
enum machine_mode mode;
machine_mode mode;
tree arg;
if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
@ -2851,7 +2851,7 @@ expand_builtin_int_roundingfn_2 (tree exp, rtx target)
rtx_insn *insns;
tree fndecl = get_callee_fndecl (exp);
tree arg;
enum machine_mode mode;
machine_mode mode;
enum built_in_function fallback_fn = BUILT_IN_NONE;
if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
@ -2949,8 +2949,8 @@ expand_builtin_powi (tree exp, rtx target)
{
tree arg0, arg1;
rtx op0, op1;
enum machine_mode mode;
enum machine_mode mode2;
machine_mode mode;
machine_mode mode2;
if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
return NULL_RTX;
@ -2987,7 +2987,7 @@ expand_builtin_powi (tree exp, rtx target)
static rtx
expand_builtin_strlen (tree exp, rtx target,
enum machine_mode target_mode)
machine_mode target_mode)
{
if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
return NULL_RTX;
@ -2999,7 +2999,7 @@ expand_builtin_strlen (tree exp, rtx target,
tree src = CALL_EXPR_ARG (exp, 0);
rtx src_reg;
rtx_insn *before_strlen;
enum machine_mode insn_mode = target_mode;
machine_mode insn_mode = target_mode;
enum insn_code icode = CODE_FOR_nothing;
unsigned int align;
@ -3092,7 +3092,7 @@ expand_builtin_strlen (tree exp, rtx target,
static rtx
builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
enum machine_mode mode)
machine_mode mode)
{
const char *str = (const char *) data;
@ -3265,7 +3265,7 @@ expand_builtin_memcpy (tree exp, rtx target)
stpcpy. */
static rtx
expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
expand_builtin_mempcpy (tree exp, rtx target, machine_mode mode)
{
if (!validate_arglist (exp,
POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
@ -3288,7 +3288,7 @@ expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
static rtx
expand_builtin_mempcpy_args (tree dest, tree src, tree len,
rtx target, enum machine_mode mode, int endp)
rtx target, machine_mode mode, int endp)
{
/* If return value is ignored, transform mempcpy into memcpy. */
if (target == const0_rtx && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
@ -3444,7 +3444,7 @@ expand_builtin_strcpy_args (tree dest, tree src, rtx target)
mode MODE if that's convenient). */
static rtx
expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode)
{
tree dst, src;
location_t loc = EXPR_LOCATION (exp);
@ -3520,7 +3520,7 @@ expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
rtx
builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
enum machine_mode mode)
machine_mode mode)
{
const char *str = (const char *) data;
@ -3586,7 +3586,7 @@ expand_builtin_strncpy (tree exp, rtx target)
rtx
builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
const char *c = (const char *) data;
char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
@ -3603,7 +3603,7 @@ builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
static rtx
builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
rtx target, coeff;
size_t size;
@ -3628,7 +3628,7 @@ builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
convenient). */
static rtx
expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
expand_builtin_memset (tree exp, rtx target, machine_mode mode)
{
if (!validate_arglist (exp,
POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
@ -3650,11 +3650,11 @@ expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
static rtx
expand_builtin_memset_args (tree dest, tree val, tree len,
rtx target, enum machine_mode mode, tree orig_exp)
rtx target, machine_mode mode, tree orig_exp)
{
tree fndecl, fn;
enum built_in_function fcode;
enum machine_mode val_mode;
machine_mode val_mode;
char c;
unsigned int dest_align;
rtx dest_mem, dest_addr, len_rtx;
@ -3816,7 +3816,7 @@ expand_builtin_bzero (tree exp)
static rtx
expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
ATTRIBUTE_UNUSED enum machine_mode mode)
ATTRIBUTE_UNUSED machine_mode mode)
{
location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
@ -3838,7 +3838,7 @@ expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
enum machine_mode insn_mode;
machine_mode insn_mode;
if (HAVE_cmpmemsi)
insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
@ -3939,7 +3939,7 @@ expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
/* Try to call cmpstrsi. */
if (HAVE_cmpstrsi)
{
enum machine_mode insn_mode
machine_mode insn_mode
= insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
/* Make a place to write the result of the instruction. */
@ -3960,7 +3960,7 @@ expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
tree len;
rtx arg3_rtx;
enum machine_mode insn_mode
machine_mode insn_mode
= insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
tree len1 = c_strlen (arg1, 1);
tree len2 = c_strlen (arg2, 1);
@ -4014,7 +4014,7 @@ expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
if (insn)
{
enum machine_mode mode;
machine_mode mode;
emit_insn (insn);
/* Return the value in the proper mode for this function. */
@ -4048,7 +4048,7 @@ expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
static rtx
expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
ATTRIBUTE_UNUSED enum machine_mode mode)
ATTRIBUTE_UNUSED machine_mode mode)
{
location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
@ -4072,7 +4072,7 @@ expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
enum machine_mode insn_mode
machine_mode insn_mode
= insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
len1 = c_strlen (arg1, 1);
@ -4511,7 +4511,7 @@ expand_builtin_alloca (tree exp, bool cannot_accumulate)
SUBTARGET may be used as the target for computing one of EXP's operands. */
static rtx
expand_builtin_bswap (enum machine_mode target_mode, tree exp, rtx target,
expand_builtin_bswap (machine_mode target_mode, tree exp, rtx target,
rtx subtarget)
{
tree arg;
@ -4541,7 +4541,7 @@ expand_builtin_bswap (enum machine_mode target_mode, tree exp, rtx target,
SUBTARGET may be used as the target for computing one of EXP's operands. */
static rtx
expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
expand_builtin_unop (machine_mode target_mode, tree exp, rtx target,
rtx subtarget, optab op_optab)
{
rtx op0;
@ -4640,7 +4640,7 @@ expand_builtin_unreachable (void)
static rtx
expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
{
enum machine_mode mode;
machine_mode mode;
tree arg;
rtx op0;
@ -4837,7 +4837,7 @@ static rtx
expand_builtin_signbit (tree exp, rtx target)
{
const struct real_format *fmt;
enum machine_mode fmode, imode, rmode;
machine_mode fmode, imode, rmode;
tree arg;
int word, bitpos;
enum insn_code icode;
@ -5010,7 +5010,7 @@ expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
group of builtins. This gives us log2 of the mode size. */
static inline enum machine_mode
static inline machine_mode
get_builtin_sync_mode (int fcode_diff)
{
/* The size is not negotiable, so ask not to get BLKmode in return
@ -5022,7 +5022,7 @@ get_builtin_sync_mode (int fcode_diff)
for the builtin_sync operations. */
static rtx
get_builtin_sync_mem (tree loc, enum machine_mode mode)
get_builtin_sync_mem (tree loc, machine_mode mode)
{
rtx addr, mem;
@ -5048,10 +5048,10 @@ get_builtin_sync_mem (tree loc, enum machine_mode mode)
MODE is the mode it should be in. */
static rtx
expand_expr_force_mode (tree exp, enum machine_mode mode)
expand_expr_force_mode (tree exp, machine_mode mode)
{
rtx val;
enum machine_mode old_mode;
machine_mode old_mode;
val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
/* If VAL is promoted to a wider mode, convert it back to MODE. Take care
@ -5073,7 +5073,7 @@ expand_expr_force_mode (tree exp, enum machine_mode mode)
fetch_and_xxx form. */
static rtx
expand_builtin_sync_operation (enum machine_mode mode, tree exp,
expand_builtin_sync_operation (machine_mode mode, tree exp,
enum rtx_code code, bool after,
rtx target)
{
@ -5134,7 +5134,7 @@ expand_builtin_sync_operation (enum machine_mode mode, tree exp,
results; this is NOT optional if IS_BOOL is true. */
static rtx
expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
expand_builtin_compare_and_swap (machine_mode mode, tree exp,
bool is_bool, rtx target)
{
rtx old_val, new_val, mem;
@ -5168,7 +5168,7 @@ expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
the results. */
static rtx
expand_builtin_sync_lock_test_and_set (enum machine_mode mode, tree exp,
expand_builtin_sync_lock_test_and_set (machine_mode mode, tree exp,
rtx target)
{
rtx val, mem;
@ -5183,7 +5183,7 @@ expand_builtin_sync_lock_test_and_set (enum machine_mode mode, tree exp,
/* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */
static void
expand_builtin_sync_lock_release (enum machine_mode mode, tree exp)
expand_builtin_sync_lock_release (machine_mode mode, tree exp)
{
rtx mem;
@ -5235,7 +5235,7 @@ get_memmodel (tree exp)
TARGET is an optional place for us to store the results. */
static rtx
expand_builtin_atomic_exchange (enum machine_mode mode, tree exp, rtx target)
expand_builtin_atomic_exchange (machine_mode mode, tree exp, rtx target)
{
rtx val, mem;
enum memmodel model;
@ -5266,7 +5266,7 @@ expand_builtin_atomic_exchange (enum machine_mode mode, tree exp, rtx target)
TARGET is an optional place for us to store the results. */
static rtx
expand_builtin_atomic_compare_exchange (enum machine_mode mode, tree exp,
expand_builtin_atomic_compare_exchange (machine_mode mode, tree exp,
rtx target)
{
rtx expect, desired, mem, oldval;
@ -5338,7 +5338,7 @@ expand_builtin_atomic_compare_exchange (enum machine_mode mode, tree exp,
TARGET is an optional place for us to store the results. */
static rtx
expand_builtin_atomic_load (enum machine_mode mode, tree exp, rtx target)
expand_builtin_atomic_load (machine_mode mode, tree exp, rtx target)
{
rtx mem;
enum memmodel model;
@ -5367,7 +5367,7 @@ expand_builtin_atomic_load (enum machine_mode mode, tree exp, rtx target)
TARGET is an optional place for us to store the results. */
static rtx
expand_builtin_atomic_store (enum machine_mode mode, tree exp)
expand_builtin_atomic_store (machine_mode mode, tree exp)
{
rtx mem, val;
enum memmodel model;
@ -5403,7 +5403,7 @@ expand_builtin_atomic_store (enum machine_mode mode, tree exp)
resolved to an instruction sequence. */
static rtx
expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target,
expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target,
enum rtx_code code, bool fetch_after,
bool ignore, enum built_in_function ext_call)
{
@ -5473,7 +5473,7 @@ expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target,
static rtx
expand_builtin_atomic_clear (tree exp)
{
enum machine_mode mode;
machine_mode mode;
rtx mem, ret;
enum memmodel model;
@ -5514,7 +5514,7 @@ expand_builtin_atomic_test_and_set (tree exp, rtx target)
{
rtx mem;
enum memmodel model;
enum machine_mode mode;
machine_mode mode;
mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
@ -5531,7 +5531,7 @@ static tree
fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
{
int size;
enum machine_mode mode;
machine_mode mode;
unsigned int mode_align, type_align;
if (TREE_CODE (arg0) != INTEGER_CST)
@ -5758,12 +5758,12 @@ expand_stack_save (void)
IGNORE is nonzero if the value is to be ignored. */
rtx
expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode,
int ignore)
{
tree fndecl = get_callee_fndecl (exp);
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
int flags;
/* When ASan is enabled, we don't want to expand some memory/string
@ -9359,7 +9359,7 @@ fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
static tree
fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
{
enum machine_mode mode;
machine_mode mode;
if (!validate_arg (arg, REAL_TYPE))
return NULL_TREE;
@ -9547,7 +9547,7 @@ fold_builtin_fpclassify (location_t loc, tree exp)
{
tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
arg, type, res, tmp;
enum machine_mode mode;
machine_mode mode;
REAL_VALUE_TYPE r;
char buf[128];
@ -10691,7 +10691,7 @@ rtx
default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
rtx target ATTRIBUTE_UNUSED,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
return NULL_RTX;
@ -11283,7 +11283,7 @@ expand_builtin_object_size (tree exp)
mode MODE if that's convenient). */
static rtx
expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
expand_builtin_memory_chk (tree exp, rtx target, machine_mode mode,
enum built_in_function fcode)
{
tree dest, src, len, size;

12
gcc/builtins.h
View File

@ -29,14 +29,14 @@ struct target_builtins {
the register is not used for calling a function. If the machine
has register windows, this gives only the outbound registers.
INCOMING_REGNO gives the corresponding inbound register. */
enum machine_mode x_apply_args_mode[FIRST_PSEUDO_REGISTER];
machine_mode x_apply_args_mode[FIRST_PSEUDO_REGISTER];
/* For each register that may be used for returning values, this gives
a mode used to copy the register's value. VOIDmode indicates the
register is not used for returning values. If the machine has
register windows, this gives only the outbound registers.
INCOMING_REGNO gives the corresponding inbound register. */
enum machine_mode x_apply_result_mode[FIRST_PSEUDO_REGISTER];
machine_mode x_apply_result_mode[FIRST_PSEUDO_REGISTER];
};
extern struct target_builtins default_target_builtins;
@ -60,15 +60,15 @@ extern tree c_strlen (tree, int);
extern void expand_builtin_setjmp_setup (rtx, rtx);
extern void expand_builtin_setjmp_receiver (rtx);
extern tree mathfn_built_in (tree, enum built_in_function fn);
extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, machine_mode);
extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, machine_mode);
extern rtx expand_builtin_saveregs (void);
extern tree std_build_builtin_va_list (void);
extern tree std_fn_abi_va_list (tree);
extern tree std_canonical_va_list_type (tree);
extern void std_expand_builtin_va_start (tree, rtx);
extern void expand_builtin_trap (void);
extern rtx expand_builtin (tree, rtx, rtx, enum machine_mode, int);
extern rtx expand_builtin (tree, rtx, rtx, machine_mode, int);
extern enum built_in_function builtin_mathfn_code (const_tree);
extern tree fold_builtin_expect (location_t, tree, tree, tree);
extern tree fold_fma (location_t, tree, tree, tree, tree);
@ -77,7 +77,7 @@ extern tree fold_call_expr (location_t, tree, bool);
extern tree fold_builtin_call_array (location_t, tree, tree, int, tree *);
extern tree fold_builtin_n (location_t, tree, tree *, int, bool);
extern bool validate_gimple_arglist (const_gimple, ...);
extern rtx default_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
extern rtx default_expand_builtin (tree, rtx, rtx, machine_mode, int);
extern bool fold_builtin_next_arg (tree, bool);
extern tree do_mpc_arg2 (tree, tree, tree, int, int (*)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t));
extern tree fold_call_stmt (gimple, bool);

5
gcc/c-family/ChangeLog
View File

@ -1,3 +1,8 @@
2014-10-29 Richard Sandiford <richard.sandiford@arm.com>
* c-common.c, c-common.h, c-cppbuiltin.c, c-lex.c: Remove redundant
enum from machine_mode.
2014-10-28 Andrew MacLeod <amacleod@redhat.com>
* c-family/c-common.c: Adjust include files.

20
gcc/c-family/c-common.c
View File

@ -3507,7 +3507,7 @@ tree
c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
int unsignedp, int satp)
{
enum machine_mode mode;
machine_mode mode;
if (ibit == 0)
mode = unsignedp ? UQQmode : QQmode;
else
@ -3539,7 +3539,7 @@ tree registered_builtin_types;
then UNSIGNEDP selects between saturating and nonsaturating types. */
tree
c_common_type_for_mode (enum machine_mode mode, int unsignedp)
c_common_type_for_mode (machine_mode mode, int unsignedp)
{
tree t;
int i;
@ -3610,7 +3610,7 @@ c_common_type_for_mode (enum machine_mode mode, int unsignedp)
if (COMPLEX_MODE_P (mode))
{
enum machine_mode inner_mode;
machine_mode inner_mode;
tree inner_type;
if (mode == TYPE_MODE (complex_float_type_node))
@ -3630,7 +3630,7 @@ c_common_type_for_mode (enum machine_mode mode, int unsignedp)
}
else if (VECTOR_MODE_P (mode))
{
enum machine_mode inner_mode = GET_MODE_INNER (mode);
machine_mode inner_mode = GET_MODE_INNER (mode);
tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
if (inner_type != NULL_TREE)
return build_vector_type_for_mode (inner_type, mode);
@ -7243,10 +7243,10 @@ handle_destructor_attribute (tree *node, tree name, tree args,
vector mode, but we can emulate with narrower modes. */
static int
vector_mode_valid_p (enum machine_mode mode)
vector_mode_valid_p (machine_mode mode)
{
enum mode_class mclass = GET_MODE_CLASS (mode);
enum machine_mode innermode;
machine_mode innermode;
/* Doh! What's going on? */
if (mclass != MODE_VECTOR_INT
@ -7291,7 +7291,7 @@ handle_mode_attribute (tree *node, tree name, tree args,
int j;
const char *p = IDENTIFIER_POINTER (ident);
int len = strlen (p);
enum machine_mode mode = VOIDmode;
machine_mode mode = VOIDmode;
tree typefm;
bool valid_mode;
@ -7323,7 +7323,7 @@ handle_mode_attribute (tree *node, tree name, tree args,
for (j = 0; j < NUM_MACHINE_MODES; j++)
if (!strcmp (p, GET_MODE_NAME (j)))
{
mode = (enum machine_mode) j;
mode = (machine_mode) j;
break;
}
@ -7377,7 +7377,7 @@ handle_mode_attribute (tree *node, tree name, tree args,
if (POINTER_TYPE_P (type))
{
addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
tree (*fn)(tree, enum machine_mode, bool);
tree (*fn)(tree, machine_mode, bool);
if (!targetm.addr_space.valid_pointer_mode (mode, as))
{
@ -8663,7 +8663,7 @@ handle_vector_size_attribute (tree *node, tree name, tree args,
bool *no_add_attrs)
{
unsigned HOST_WIDE_INT vecsize, nunits;
enum machine_mode orig_mode;
machine_mode orig_mode;
tree type = *node, new_type, size;
*no_add_attrs = true;

2
gcc/c-family/c-common.h
View File

@ -762,7 +762,7 @@ extern bool attribute_takes_identifier_p (const_tree);
extern bool c_common_handle_option (size_t, const char *, int, int, location_t,
const struct cl_option_handlers *);
extern bool default_handle_c_option (size_t, const char *, int);
extern tree c_common_type_for_mode (enum machine_mode, int);
extern tree c_common_type_for_mode (machine_mode, int);
extern tree c_common_type_for_size (unsigned int, int);
extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
int, int);

6
gcc/c-family/c-cppbuiltin.c
View File

@ -72,7 +72,7 @@ static void builtin_define_float_constants (const char *,
point types. */
static bool
mode_has_fma (enum machine_mode mode)
mode_has_fma (machine_mode mode)
{
switch (mode)
{
@ -1006,7 +1006,7 @@ c_cpp_builtins (cpp_reader *pfile)
if (flag_building_libgcc)
{
/* Properties of floating-point modes for libgcc2.c. */
for (enum machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
for (machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
@ -1364,7 +1364,7 @@ struct GTY(()) lazy_hex_fp_value_struct
{
const char *hex_str;
cpp_macro *macro;
enum machine_mode mode;
machine_mode mode;
int digits;
const char *fp_suffix;
};

2
gcc/c-family/c-lex.c
View File

@ -724,7 +724,7 @@ interpret_float (const cpp_token *token, unsigned int flags,
if (flags & CPP_N_WIDTH_MD)
{
char suffix;
enum machine_mode mode;
machine_mode mode;
if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
suffix = 'w';

5
gcc/c/ChangeLog
View File

@ -1,3 +1,8 @@
2014-10-29 Richard Sandiford <richard.sandiford@arm.com>
* c-decl.c, c-tree.h, c-typeck.c: Remove redundant enum from
machine_mode.
2014-10-28 Andrew MacLeod <amacleod@redhat.com>
* c-decl.c: Adjust include files.

4
gcc/c/c-decl.c
View File

@ -161,7 +161,7 @@ static bool undef_nested_function;
/* Mode used to build pointers (VOIDmode means ptr_mode). */
enum machine_mode c_default_pointer_mode = VOIDmode;
machine_mode c_default_pointer_mode = VOIDmode;
/* If non-zero, implicit "omp declare target" attribute is added into the
attribute lists. */
@ -658,7 +658,7 @@ c_build_pointer_type (tree to_type)
{
addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
: TYPE_ADDR_SPACE (to_type);
enum machine_mode pointer_mode;
machine_mode pointer_mode;
if (as != ADDR_SPACE_GENERIC || c_default_pointer_mode == VOIDmode)
pointer_mode = targetm.addr_space.pointer_mode (as);

2
gcc/c/c-tree.h
View File

@ -670,7 +670,7 @@ extern int current_function_returns_abnormally;
/* Mode used to build pointers (VOIDmode means ptr_mode). */
extern enum machine_mode c_default_pointer_mode;
extern machine_mode c_default_pointer_mode;
/* In c-decl.c */

2
gcc/c/c-typeck.c
View File

@ -821,7 +821,7 @@ c_common_type (tree t1, tree t2)
if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
{
unsigned int unsignedp = 0, satp = 0;
enum machine_mode m1, m2;
machine_mode m1, m2;
unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
m1 = TYPE_MODE (t1);

32
gcc/caller-save.c
View File

@ -81,11 +81,11 @@ static int n_regs_saved;
static HARD_REG_SET referenced_regs;
typedef void refmarker_fn (rtx *loc, enum machine_mode mode, int hardregno,
typedef void refmarker_fn (rtx *loc, machine_mode mode, int hardregno,
void *mark_arg);
static int reg_save_code (int, enum machine_mode);
static int reg_restore_code (int, enum machine_mode);
static int reg_save_code (int, machine_mode);
static int reg_restore_code (int, machine_mode);
struct saved_hard_reg;
static void initiate_saved_hard_regs (void);
@ -98,9 +98,9 @@ static void mark_referenced_regs (rtx *, refmarker_fn *mark, void *mark_arg);
static refmarker_fn mark_reg_as_referenced;
static refmarker_fn replace_reg_with_saved_mem;
static int insert_save (struct insn_chain *, int, int, HARD_REG_SET *,
enum machine_mode *);
machine_mode *);
static int insert_restore (struct insn_chain *, int, int, int,
enum machine_mode *);
machine_mode *);
static struct insn_chain *insert_one_insn (struct insn_chain *, int, int,
rtx);
static void add_stored_regs (rtx, const_rtx, void *);
@ -116,7 +116,7 @@ static GTY(()) rtx_insn *restinsn;
/* Return the INSN_CODE used to save register REG in mode MODE. */
static int
reg_save_code (int reg, enum machine_mode mode)
reg_save_code (int reg, machine_mode mode)
{
bool ok;
if (cached_reg_save_code[reg][mode])
@ -170,7 +170,7 @@ reg_save_code (int reg, enum machine_mode mode)
/* Return the INSN_CODE used to restore register REG in mode MODE. */
static int
reg_restore_code (int reg, enum machine_mode mode)
reg_restore_code (int reg, machine_mode mode)
{
if (cached_reg_restore_code[reg][mode])
return cached_reg_restore_code[reg][mode];
@ -755,7 +755,7 @@ void
save_call_clobbered_regs (void)
{
struct insn_chain *chain, *next, *last = NULL;
enum machine_mode save_mode [FIRST_PSEUDO_REGISTER];
machine_mode save_mode [FIRST_PSEUDO_REGISTER];
/* Computed in mark_set_regs, holds all registers set by the current
instruction. */
@ -841,7 +841,7 @@ save_call_clobbered_regs (void)
{
int r = reg_renumber[regno];
int nregs;
enum machine_mode mode;
machine_mode mode;
if (r < 0 || regno_reg_rtx[regno] == cheap)
continue;
@ -994,7 +994,7 @@ static void
add_stored_regs (rtx reg, const_rtx setter, void *data)
{
int regno, endregno, i;
enum machine_mode mode = GET_MODE (reg);
machine_mode mode = GET_MODE (reg);
int offset = 0;
if (GET_CODE (setter) == CLOBBER)
@ -1097,7 +1097,7 @@ mark_referenced_regs (rtx *loc, refmarker_fn *mark, void *arg)
static void
mark_reg_as_referenced (rtx *loc ATTRIBUTE_UNUSED,
enum machine_mode mode,
machine_mode mode,
int hardregno,
void *arg ATTRIBUTE_UNUSED)
{
@ -1110,13 +1110,13 @@ mark_reg_as_referenced (rtx *loc ATTRIBUTE_UNUSED,
static void
replace_reg_with_saved_mem (rtx *loc,
enum machine_mode mode,
machine_mode mode,
int regno,
void *arg)
{
unsigned int i, nregs = hard_regno_nregs [regno][mode];
rtx mem;
enum machine_mode *save_mode = (enum machine_mode *)arg;
machine_mode *save_mode = (machine_mode *)arg;
for (i = 0; i < nregs; i++)
if (TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
@ -1168,7 +1168,7 @@ replace_reg_with_saved_mem (rtx *loc,
}
else
{
enum machine_mode smode = save_mode[regno];
machine_mode smode = save_mode[regno];
gcc_assert (smode != VOIDmode);
if (hard_regno_nregs [regno][smode] > 1)
smode = mode_for_size (GET_MODE_SIZE (mode) / nregs,
@ -1197,7 +1197,7 @@ replace_reg_with_saved_mem (rtx *loc,
static int
insert_restore (struct insn_chain *chain, int before_p, int regno,
int maxrestore, enum machine_mode *save_mode)
int maxrestore, machine_mode *save_mode)
{
int i, k;
rtx pat = NULL_RTX;
@ -1278,7 +1278,7 @@ insert_restore (struct insn_chain *chain, int before_p, int regno,
static int
insert_save (struct insn_chain *chain, int before_p, int regno,
HARD_REG_SET (*to_save), enum machine_mode *save_mode)
HARD_REG_SET (*to_save), machine_mode *save_mode)
{
int i;
unsigned int k;

48
gcc/calls.c
View File

@ -71,7 +71,7 @@ struct arg_data
/* Tree node for this argument. */
tree tree_value;
/* Mode for value; TYPE_MODE unless promoted. */
enum machine_mode mode;
machine_mode mode;
/* Current RTL value for argument, or 0 if it isn't precomputed. */
rtx value;
/* Initially-compute RTL value for argument; only for const functions. */
@ -161,7 +161,7 @@ static rtx rtx_for_function_call (tree, tree);
static void load_register_parameters (struct arg_data *, int, rtx *, int,
int, int *);
static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
enum machine_mode, int, va_list);
machine_mode, int, va_list);
static int special_function_p (const_tree, int);
static int check_sibcall_argument_overlap_1 (rtx);
static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
@ -915,7 +915,7 @@ save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_sa
if (stack_usage_map[low] != 0)
{
int num_to_save;
enum machine_mode save_mode;
machine_mode save_mode;
int delta;
rtx addr;
rtx stack_area;
@ -966,7 +966,7 @@ save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_sa
static void
restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
{
enum machine_mode save_mode = GET_MODE (save_area);
machine_mode save_mode = GET_MODE (save_area);
int delta;
rtx addr, stack_area;
@ -1163,7 +1163,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
{
tree type = TREE_TYPE (args[i].tree_value);
int unsignedp;
enum machine_mode mode;
machine_mode mode;
/* Replace erroneous argument with constant zero. */
if (type == error_mark_node || !COMPLETE_TYPE_P (type))
@ -1466,7 +1466,7 @@ precompute_arguments (int num_actuals, struct arg_data *args)
for (i = 0; i < num_actuals; i++)
{
tree type;
enum machine_mode mode;
machine_mode mode;
if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
continue;
@ -1584,7 +1584,7 @@ compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals
rtx addr;
unsigned int align, boundary;
unsigned int units_on_stack = 0;
enum machine_mode partial_mode = VOIDmode;
machine_mode partial_mode = VOIDmode;
/* Skip this parm if it will not be passed on the stack. */
if (! args[i].pass_on_stack
@ -2138,7 +2138,7 @@ check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
as specified by LEFT_P. Return true if some action was needed. */
bool
shift_return_value (enum machine_mode mode, bool left_p, rtx value)
shift_return_value (machine_mode mode, bool left_p, rtx value)
{
HOST_WIDE_INT shift;
@ -2623,8 +2623,8 @@ expand_call (tree exp, rtx target, int ignore)
return value. */
if (try_tail_call)
{
enum machine_mode caller_mode, caller_promoted_mode;
enum machine_mode callee_mode, callee_promoted_mode;
machine_mode caller_mode, caller_promoted_mode;
machine_mode callee_mode, callee_promoted_mode;
int caller_unsignedp, callee_unsignedp;
tree caller_res = DECL_RESULT (current_function_decl);
@ -3356,7 +3356,7 @@ expand_call (tree exp, rtx target, int ignore)
tree type = rettype;
int unsignedp = TYPE_UNSIGNED (type);
int offset = 0;
enum machine_mode pmode;
machine_mode pmode;
/* Ensure we promote as expected, and get the new unsignedness. */
pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
@ -3411,7 +3411,7 @@ expand_call (tree exp, rtx target, int ignore)
for (i = 0; i < num_actuals; i++)
if (args[i].save_area)
{
enum machine_mode save_mode = GET_MODE (args[i].save_area);
machine_mode save_mode = GET_MODE (args[i].save_area);
rtx stack_area
= gen_rtx_MEM (save_mode,
memory_address (save_mode,
@ -3587,7 +3587,7 @@ split_complex_types (tree types)
static rtx
emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
enum libcall_type fn_type,
enum machine_mode outmode, int nargs, va_list p)
machine_mode outmode, int nargs, va_list p)
{
/* Total size in bytes of all the stack-parms scanned so far. */
struct args_size args_size;
@ -3606,7 +3606,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
struct arg
{
rtx value;
enum machine_mode mode;
machine_mode mode;
rtx reg;
int partial;
struct locate_and_pad_arg_data locate;
@ -3771,7 +3771,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
for (; count < nargs; count++)
{
rtx val = va_arg (p, rtx);
enum machine_mode mode = (enum machine_mode) va_arg (p, int);
machine_mode mode = (machine_mode) va_arg (p, int);
int unsigned_p = 0;
/* We cannot convert the arg value to the mode the library wants here;
@ -3972,7 +3972,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
are to be pushed. */
for (count = 0; count < nargs; count++, argnum--)
{
enum machine_mode mode = argvec[argnum].mode;
machine_mode mode = argvec[argnum].mode;
rtx val = argvec[argnum].value;
rtx reg = argvec[argnum].reg;
int partial = argvec[argnum].partial;
@ -4011,7 +4011,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
/* We need to make a save area. */
unsigned int size
= argvec[argnum].locate.size.constant * BITS_PER_UNIT;
enum machine_mode save_mode
machine_mode save_mode
= mode_for_size (size, MODE_INT, 1);
rtx adr
= plus_constant (Pmode, argblock,
@ -4083,7 +4083,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
are to be pushed. */
for (count = 0; count < nargs; count++, argnum--)
{
enum machine_mode mode = argvec[argnum].mode;
machine_mode mode = argvec[argnum].mode;
rtx val = argvec[argnum].value;
rtx reg = argvec[argnum].reg;
int partial = argvec[argnum].partial;
@ -4294,7 +4294,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
for (count = 0; count < nargs; count++)
if (argvec[count].save_area)
{
enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
machine_mode save_mode = GET_MODE (argvec[count].save_area);
rtx adr = plus_constant (Pmode, argblock,
argvec[count].locate.offset.constant);
rtx stack_area = gen_rtx_MEM (save_mode,
@ -4332,7 +4332,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
void
emit_library_call (rtx orgfun, enum libcall_type fn_type,
enum machine_mode outmode, int nargs, ...)
machine_mode outmode, int nargs, ...)
{
va_list p;
@ -4352,7 +4352,7 @@ emit_library_call (rtx orgfun, enum libcall_type fn_type,
rtx
emit_library_call_value (rtx orgfun, rtx value,
enum libcall_type fn_type,
enum machine_mode outmode, int nargs, ...)
machine_mode outmode, int nargs, ...)
{
rtx result;
va_list p;
@ -4438,7 +4438,7 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
{
/* We need to make a save area. */
unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
rtx stack_area = gen_rtx_MEM (save_mode, adr);
@ -4732,7 +4732,7 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
/* Nonzero if we do not know how to pass TYPE solely in registers. */
bool
must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED,
const_tree type)
{
if (!type)
@ -4755,7 +4755,7 @@ must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
/* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
bool
must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type)
must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
{
if (!type)
return false;

4
gcc/calls.h
View File

@ -25,7 +25,7 @@ extern int call_expr_flags (const_tree);
extern int setjmp_call_p (const_tree);
extern bool gimple_alloca_call_p (const_gimple);
extern bool alloca_call_p (const_tree);
extern bool must_pass_in_stack_var_size (enum machine_mode, const_tree);
extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree);
extern bool must_pass_in_stack_var_size (machine_mode, const_tree);
extern bool must_pass_in_stack_var_size_or_pad (machine_mode, const_tree);
#endif // GCC_CALLS_H

50
gcc/cfgexpand.c
View File

@ -1145,7 +1145,7 @@ expand_one_register_var (tree var)
{
tree decl = SSAVAR (var);
tree type = TREE_TYPE (decl);
enum machine_mode reg_mode = promote_decl_mode (decl, NULL);
machine_mode reg_mode = promote_decl_mode (decl, NULL);
rtx x = gen_reg_rtx (reg_mode);
set_rtl (var, x);
@ -1165,7 +1165,7 @@ expand_one_register_var (tree var)
static void
expand_one_error_var (tree var)
{
enum machine_mode mode = DECL_MODE (var);
machine_mode mode = DECL_MODE (var);
rtx x;
if (mode == BLKmode)
@ -2480,7 +2480,7 @@ expand_asm_operands (tree string, tree outputs, tree inputs,
rtx *output_rtx = XALLOCAVEC (rtx, noutputs);
int *inout_opnum = XALLOCAVEC (int, noutputs);
rtx *real_output_rtx = XALLOCAVEC (rtx, noutputs);
enum machine_mode *inout_mode = XALLOCAVEC (enum machine_mode, noutputs);
machine_mode *inout_mode = XALLOCAVEC (machine_mode, noutputs);
const char **constraints = XALLOCAVEC (const char *, noutputs + ninputs);
int old_generating_concat_p = generating_concat_p;
rtx_code_label *fallthru_label = NULL;
@ -3101,8 +3101,8 @@ expand_value_return (rtx val)
tree funtype = TREE_TYPE (current_function_decl);
tree type = TREE_TYPE (decl);
int unsignedp = TYPE_UNSIGNED (type);
enum machine_mode old_mode = DECL_MODE (decl);
enum machine_mode mode;
machine_mode old_mode = DECL_MODE (decl);
machine_mode mode;
if (DECL_BY_REFERENCE (decl))
mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
else
@ -3518,7 +3518,7 @@ expand_gimple_tailcall (basic_block bb, gimple stmt, bool *can_fallthru)
/* Return the difference between the floor and the truncated result of
a signed division by OP1 with remainder MOD. */
static rtx
floor_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
floor_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
{
/* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
return gen_rtx_IF_THEN_ELSE
@ -3534,7 +3534,7 @@ floor_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
/* Return the difference between the ceil and the truncated result of
a signed division by OP1 with remainder MOD. */
static rtx
ceil_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
ceil_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
{
/* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
return gen_rtx_IF_THEN_ELSE
@ -3550,7 +3550,7 @@ ceil_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
/* Return the difference between the ceil and the truncated result of
an unsigned division by OP1 with remainder MOD. */
static rtx
ceil_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
ceil_udiv_adjust (machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
{
/* (mod != 0 ? 1 : 0) */
return gen_rtx_IF_THEN_ELSE
@ -3562,7 +3562,7 @@ ceil_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1 ATTRIBUTE_UNUSED)
of a signed division by OP1 with remainder MOD. Halfway cases are
rounded away from zero, rather than to the nearest even number. */
static rtx
round_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
round_sdiv_adjust (machine_mode mode, rtx mod, rtx op1)
{
/* (abs (mod) >= abs (op1) - abs (mod)
? (op1 / mod > 0 ? 1 : -1)
@ -3585,7 +3585,7 @@ round_sdiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
are rounded away from zero, rather than to the nearest even
number. */
static rtx
round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
round_udiv_adjust (machine_mode mode, rtx mod, rtx op1)
{
/* (mod >= op1 - mod ? 1 : 0) */
return gen_rtx_IF_THEN_ELSE
@ -3598,10 +3598,10 @@ round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
any rtl. */
static rtx
convert_debug_memory_address (enum machine_mode mode, rtx x,
convert_debug_memory_address (machine_mode mode, rtx x,
addr_space_t as)
{
enum machine_mode xmode = GET_MODE (x);
machine_mode xmode = GET_MODE (x);
#ifndef POINTERS_EXTEND_UNSIGNED
gcc_assert (mode == Pmode
@ -3731,8 +3731,8 @@ static rtx
expand_debug_expr (tree exp)
{
rtx op0 = NULL_RTX, op1 = NULL_RTX, op2 = NULL_RTX;
enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
enum machine_mode inner_mode = VOIDmode;
machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
machine_mode inner_mode = VOIDmode;
int unsignedp = TYPE_UNSIGNED (TREE_TYPE (exp));
addr_space_t as;
@ -4019,7 +4019,7 @@ expand_debug_expr (tree exp)
case IMAGPART_EXPR:
case VIEW_CONVERT_EXPR:
{
enum machine_mode mode1;
machine_mode mode1;
HOST_WIDE_INT bitsize, bitpos;
tree offset;
int volatilep = 0;
@ -4037,7 +4037,7 @@ expand_debug_expr (tree exp)
if (offset)
{
enum machine_mode addrmode, offmode;
machine_mode addrmode, offmode;
if (!MEM_P (op0))
return NULL;
@ -4107,7 +4107,7 @@ expand_debug_expr (tree exp)
if ((bitpos % BITS_PER_UNIT) == 0
&& bitsize == GET_MODE_BITSIZE (mode1))
{
enum machine_mode opmode = GET_MODE (op0);
machine_mode opmode = GET_MODE (op0);
if (opmode == VOIDmode)
opmode = TYPE_MODE (TREE_TYPE (tem));
@ -4402,7 +4402,7 @@ expand_debug_expr (tree exp)
GET_MODE_INNER (mode)));
else
{
enum machine_mode imode = GET_MODE_INNER (mode);
machine_mode imode = GET_MODE_INNER (mode);
rtx re, im;
if (MEM_P (op0))
@ -4412,8 +4412,8 @@ expand_debug_expr (tree exp)
}
else
{
enum machine_mode ifmode = int_mode_for_mode (mode);
enum machine_mode ihmode = int_mode_for_mode (imode);
machine_mode ifmode = int_mode_for_mode (mode);
machine_mode ihmode = int_mode_for_mode (imode);
rtx halfsize;
if (ifmode == BLKmode || ihmode == BLKmode)
return NULL;
@ -4709,7 +4709,7 @@ static rtx
expand_debug_source_expr (tree exp)
{
rtx op0 = NULL_RTX;
enum machine_mode mode = VOIDmode, inner_mode;
machine_mode mode = VOIDmode, inner_mode;
switch (TREE_CODE (exp))
{
@ -4857,7 +4857,7 @@ expand_debug_locations (void)
tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
rtx val;
rtx_insn *prev_insn, *insn2;
enum machine_mode mode;
machine_mode mode;
if (value == NULL_TREE)
val = NULL_RTX;
@ -5046,7 +5046,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
tree value = gimple_assign_rhs_to_tree (def);
tree vexpr = make_node (DEBUG_EXPR_DECL);
rtx val;
enum machine_mode mode;
machine_mode mode;
set_curr_insn_location (gimple_location (def));
@ -5098,7 +5098,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
tree var = gimple_debug_bind_get_var (stmt);
tree value;
rtx val;
enum machine_mode mode;
machine_mode mode;
if (TREE_CODE (var) != DEBUG_EXPR_DECL
&& TREE_CODE (var) != LABEL_DECL
@ -5158,7 +5158,7 @@ expand_gimple_basic_block (basic_block bb, bool disable_tail_calls)
tree var = gimple_debug_source_bind_get_var (stmt);
tree value = gimple_debug_source_bind_get_value (stmt);
rtx val;
enum machine_mode mode;
machine_mode mode;
last = get_last_insn ();

8
gcc/cfgloop.h
View File

@ -355,10 +355,10 @@ struct rtx_iv
rtx delta, mult;
/* The mode it is extended to. */
enum machine_mode extend_mode;
machine_mode extend_mode;
/* The mode the variable iterates in. */
enum machine_mode mode;
machine_mode mode;
/* Whether the first iteration needs to be handled specially. */
unsigned first_special : 1;
@ -399,7 +399,7 @@ struct GTY(()) niter_desc
bool signed_p;
/* The mode in that niter_expr should be computed. */
enum machine_mode mode;
machine_mode mode;
/* The number of iterations of the loop. */
rtx niter_expr;
@ -408,7 +408,7 @@ struct GTY(()) niter_desc
extern void iv_analysis_loop_init (struct loop *);
extern bool iv_analyze (rtx_insn *, rtx, struct rtx_iv *);
extern bool iv_analyze_result (rtx_insn *, rtx, struct rtx_iv *);
extern bool iv_analyze_expr (rtx_insn *, rtx, enum machine_mode,
extern bool iv_analyze_expr (rtx_insn *, rtx, machine_mode,
struct rtx_iv *);
extern rtx get_iv_value (struct rtx_iv *, rtx);
extern bool biv_p (rtx_insn *, rtx);

2
gcc/cfgrtl.c
View File

@ -4921,7 +4921,7 @@ rtl_lv_add_condition_to_bb (basic_block first_head ,
rtx op0 = XEXP ((rtx)comp_rtx, 0);
rtx op1 = XEXP ((rtx)comp_rtx, 1);
enum rtx_code comp = GET_CODE ((rtx)comp_rtx);
enum machine_mode mode;
machine_mode mode;
label = block_label (first_head);

188
gcc/combine.c
View File

@ -367,7 +367,7 @@ static int label_tick_ebb_start;
/* Mode used to compute significance in reg_stat[].nonzero_bits. It is the
largest integer mode that can fit in HOST_BITS_PER_WIDE_INT. */
static enum machine_mode nonzero_bits_mode;
static machine_mode nonzero_bits_mode;
/* Nonzero when reg_stat[].nonzero_bits and reg_stat[].sign_bit_copies can
be safely used. It is zero while computing them and after combine has
@ -387,7 +387,7 @@ struct undo
{
struct undo *next;
enum undo_kind kind;
union { rtx r; int i; enum machine_mode m; struct insn_link *l; } old_contents;
union { rtx r; int i; machine_mode m; struct insn_link *l; } old_contents;
union { rtx *r; int *i; struct insn_link **l; } where;
};
@ -411,12 +411,12 @@ static struct undobuf undobuf;
static int n_occurrences;
static rtx reg_nonzero_bits_for_combine (const_rtx, enum machine_mode, const_rtx,
enum machine_mode,
static rtx reg_nonzero_bits_for_combine (const_rtx, machine_mode, const_rtx,
machine_mode,
unsigned HOST_WIDE_INT,
unsigned HOST_WIDE_INT *);
static rtx reg_num_sign_bit_copies_for_combine (const_rtx, enum machine_mode, const_rtx,
enum machine_mode,
static rtx reg_num_sign_bit_copies_for_combine (const_rtx, machine_mode, const_rtx,
machine_mode,
unsigned int, unsigned int *);
static void do_SUBST (rtx *, rtx);
static void do_SUBST_INT (int *, int);
@ -434,19 +434,19 @@ static void undo_all (void);
static void undo_commit (void);
static rtx *find_split_point (rtx *, rtx_insn *, bool);
static rtx subst (rtx, rtx, rtx, int, int, int);
static rtx combine_simplify_rtx (rtx, enum machine_mode, int, int);
static rtx combine_simplify_rtx (rtx, machine_mode, int, int);
static rtx simplify_if_then_else (rtx);
static rtx simplify_set (rtx);
static rtx simplify_logical (rtx);
static rtx expand_compound_operation (rtx);
static const_rtx expand_field_assignment (const_rtx);
static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,
static rtx make_extraction (machine_mode, rtx, HOST_WIDE_INT,
rtx, unsigned HOST_WIDE_INT, int, int, int);
static rtx extract_left_shift (rtx, int);
static int get_pos_from_mask (unsigned HOST_WIDE_INT,
unsigned HOST_WIDE_INT *);
static rtx canon_reg_for_combine (rtx, rtx);
static rtx force_to_mode (rtx, enum machine_mode,
static rtx force_to_mode (rtx, machine_mode,
unsigned HOST_WIDE_INT, int);
static rtx if_then_else_cond (rtx, rtx *, rtx *);
static rtx known_cond (rtx, enum rtx_code, rtx, rtx);
@ -454,18 +454,18 @@ static int rtx_equal_for_field_assignment_p (rtx, rtx);
static rtx make_field_assignment (rtx);
static rtx apply_distributive_law (rtx);
static rtx distribute_and_simplify_rtx (rtx, int);
static rtx simplify_and_const_int_1 (enum machine_mode, rtx,
static rtx simplify_and_const_int_1 (machine_mode, rtx,
unsigned HOST_WIDE_INT);
static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,
static rtx simplify_and_const_int (rtx, machine_mode, rtx,
unsigned HOST_WIDE_INT);
static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,
HOST_WIDE_INT, enum machine_mode, int *);
static rtx simplify_shift_const_1 (enum rtx_code, enum machine_mode, rtx, int);
static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,
HOST_WIDE_INT, machine_mode, int *);
static rtx simplify_shift_const_1 (enum rtx_code, machine_mode, rtx, int);
static rtx simplify_shift_const (rtx, enum rtx_code, machine_mode, rtx,
int);
static int recog_for_combine (rtx *, rtx_insn *, rtx *);
static rtx gen_lowpart_for_combine (enum machine_mode, rtx);
static enum rtx_code simplify_compare_const (enum rtx_code, enum machine_mode,
static rtx gen_lowpart_for_combine (machine_mode, rtx);
static enum rtx_code simplify_compare_const (enum rtx_code, machine_mode,
rtx, rtx *);
static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);
static void update_table_tick (rtx);
@ -486,8 +486,8 @@ static void mark_used_regs_combine (rtx);
static void record_promoted_value (rtx_insn *, rtx);
static bool unmentioned_reg_p (rtx, rtx);
static void record_truncated_values (rtx *, void *);
static bool reg_truncated_to_mode (enum machine_mode, const_rtx);
static rtx gen_lowpart_or_truncate (enum machine_mode, rtx);
static bool reg_truncated_to_mode (machine_mode, const_rtx);
static rtx gen_lowpart_or_truncate (machine_mode, rtx);
/* It is not safe to use ordinary gen_lowpart in combine.
@ -790,10 +790,10 @@ do_SUBST_INT (int *into, int newval)
well. */
static void
do_SUBST_MODE (rtx *into, enum machine_mode newval)
do_SUBST_MODE (rtx *into, machine_mode newval)
{
struct undo *buf;
enum machine_mode oldval = GET_MODE (*into);
machine_mode oldval = GET_MODE (*into);
if (oldval == newval)
return;
@ -1551,7 +1551,7 @@ setup_incoming_promotions (rtx_insn *first)
{
rtx x, reg = DECL_INCOMING_RTL (arg);
int uns1, uns3;
enum machine_mode mode1, mode2, mode3, mode4;
machine_mode mode1, mode2, mode3, mode4;
/* Only continue if the incoming argument is in a register. */
if (!REG_P (reg))
@ -2368,7 +2368,7 @@ adjust_for_new_dest (rtx_insn *insn)
/* Return TRUE if combine can reuse reg X in mode MODE.
ADDED_SETS is nonzero if the original set is still required. */
static bool
can_change_dest_mode (rtx x, int added_sets, enum machine_mode mode)
can_change_dest_mode (rtx x, int added_sets, machine_mode mode)
{
unsigned int regno;
@ -2975,7 +2975,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
rtx *cc_use_loc = NULL;
rtx_insn *cc_use_insn = NULL;
rtx op0 = i2src, op1 = XEXP (SET_SRC (PATTERN (i3)), 1);
enum machine_mode compare_mode, orig_compare_mode;
machine_mode compare_mode, orig_compare_mode;
enum rtx_code compare_code = UNKNOWN, orig_compare_code = UNKNOWN;
newpat = PATTERN (i3);
@ -3004,7 +3004,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
if (cc_use_loc)
{
#ifdef SELECT_CC_MODE
enum machine_mode new_mode
machine_mode new_mode
= SELECT_CC_MODE (compare_code, op0, op1);
if (new_mode != orig_compare_mode
&& can_change_dest_mode (SET_DEST (newpat),
@ -3361,7 +3361,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
if (m_split_insn == 0 && ! reg_overlap_mentioned_p (i2dest, newpat))
{
enum machine_mode new_mode = GET_MODE (SET_DEST (newpat));
machine_mode new_mode = GET_MODE (SET_DEST (newpat));
/* First try to split using the original register as a
scratch register. */
@ -3378,7 +3378,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
&& new_mode != VOIDmode
&& can_change_dest_mode (i2dest, added_sets_2, new_mode))
{
enum machine_mode old_mode = GET_MODE (i2dest);
machine_mode old_mode = GET_MODE (i2dest);
rtx ni2dest;
if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
@ -3501,7 +3501,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
{
rtx newdest = i2dest;
enum rtx_code split_code = GET_CODE (*split);
enum machine_mode split_mode = GET_MODE (*split);
machine_mode split_mode = GET_MODE (*split);
bool subst_done = false;
newi2pat = NULL_RTX;
@ -3568,7 +3568,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
&& ! side_effects_p (SET_SRC (newpat)))
{
rtx setsrc = SET_SRC (newpat);
enum machine_mode mode = GET_MODE (setsrc);
machine_mode mode = GET_MODE (setsrc);
enum rtx_code code = GET_CODE (setsrc);
rtx src_op0 = XEXP (setsrc, 0);
rtx src_op1 = XEXP (setsrc, 1);
@ -3863,8 +3863,8 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0,
if (undo->kind == UNDO_MODE)
{
rtx reg = *undo->where.r;
enum machine_mode new_mode = GET_MODE (reg);
enum machine_mode old_mode = undo->old_contents.m;
machine_mode new_mode = GET_MODE (reg);
machine_mode old_mode = undo->old_contents.m;
/* Temporarily revert mode back. */
adjust_reg_mode (reg, old_mode);
@ -4524,7 +4524,7 @@ find_split_point (rtx *loc, rtx_insn *insn, bool set_src)
if (GET_CODE (XEXP (x, 0)) == CONST
|| GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
{
enum machine_mode address_mode = get_address_mode (x);
machine_mode address_mode = get_address_mode (x);
SUBST (XEXP (x, 0),
gen_rtx_LO_SUM (address_mode,
@ -4656,7 +4656,7 @@ find_split_point (rtx *loc, rtx_insn *insn, bool set_src)
unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
rtx dest = XEXP (SET_DEST (x), 0);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
unsigned HOST_WIDE_INT mask
= ((unsigned HOST_WIDE_INT) 1 << len) - 1;
rtx or_mask;
@ -4730,7 +4730,7 @@ find_split_point (rtx *loc, rtx_insn *insn, bool set_src)
(nonzero_bits (XEXP (SET_SRC (x), 0),
GET_MODE (XEXP (SET_SRC (x), 0))))))
{
enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
SUBST (SET_SRC (x),
gen_rtx_NEG (mode,
@ -4781,7 +4781,7 @@ find_split_point (rtx *loc, rtx_insn *insn, bool set_src)
if (len && pos >= 0
&& pos + len <= GET_MODE_PRECISION (GET_MODE (inner)))
{
enum machine_mode mode = GET_MODE (SET_SRC (x));
machine_mode mode = GET_MODE (SET_SRC (x));
/* For unsigned, we have a choice of a shift followed by an
AND or two shifts. Use two shifts for field sizes where the
@ -4878,7 +4878,7 @@ find_split_point (rtx *loc, rtx_insn *insn, bool set_src)
&& GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
&& exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1))) < 0)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
unsigned HOST_WIDE_INT this_int = INTVAL (XEXP (XEXP (x, 1), 1));
HOST_WIDE_INT other_int = trunc_int_for_mode (-this_int, mode);
SUBST (*loc, gen_rtx_PLUS (mode,
@ -4959,7 +4959,7 @@ static rtx
subst (rtx x, rtx from, rtx to, int in_dest, int in_cond, int unique_copy)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode op0_mode = VOIDmode;
machine_mode op0_mode = VOIDmode;
const char *fmt;
int len, i;
rtx new_rtx;
@ -5176,7 +5176,7 @@ subst (rtx x, rtx from, rtx to, int in_dest, int in_cond, int unique_copy)
if (GET_CODE (x) == SUBREG && CONST_SCALAR_INT_P (new_rtx))
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
x = simplify_subreg (GET_MODE (x), new_rtx,
GET_MODE (SUBREG_REG (x)),
@ -5242,11 +5242,11 @@ subst (rtx x, rtx from, rtx to, int in_dest, int in_cond, int unique_copy)
of a condition. */
static rtx
combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest,
combine_simplify_rtx (rtx x, machine_mode op0_mode, int in_dest,
int in_cond)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
rtx temp;
int i;
@ -5372,7 +5372,7 @@ combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest,
case RTX_COMPARE:
case RTX_COMM_COMPARE:
{
enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
if (cmp_mode == VOIDmode)
{
cmp_mode = GET_MODE (XEXP (x, 1));
@ -5944,7 +5944,7 @@ combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest,
static rtx
simplify_if_then_else (rtx x)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
rtx cond = XEXP (x, 0);
rtx true_rtx = XEXP (x, 1);
rtx false_rtx = XEXP (x, 2);
@ -6142,7 +6142,7 @@ simplify_if_then_else (rtx x)
rtx cond_op0 = XEXP (cond, 0);
rtx cond_op1 = XEXP (cond, 1);
enum rtx_code op = UNKNOWN, extend_op = UNKNOWN;
enum machine_mode m = mode;
machine_mode m = mode;
rtx z = 0, c1 = NULL_RTX;
if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
@ -6284,7 +6284,7 @@ simplify_set (rtx x)
{
rtx src = SET_SRC (x);
rtx dest = SET_DEST (x);
enum machine_mode mode
machine_mode mode
= GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
rtx_insn *other_insn;
rtx *cc_use;
@ -6319,7 +6319,7 @@ simplify_set (rtx x)
rtx op0, op1, tmp;
int other_changed = 0;
rtx inner_compare = NULL_RTX;
enum machine_mode compare_mode = GET_MODE (dest);
machine_mode compare_mode = GET_MODE (dest);
if (GET_CODE (src) == COMPARE)
{
@ -6530,7 +6530,7 @@ simplify_set (rtx x)
< GET_MODE_PRECISION (GET_MODE (SUBREG_REG (src)))))
{
rtx inner = SUBREG_REG (src);
enum machine_mode inner_mode = GET_MODE (inner);
machine_mode inner_mode = GET_MODE (inner);
/* Here we make sure that we don't have a sign bit on. */
if (val_signbit_known_clear_p (GET_MODE (src),
@ -6635,7 +6635,7 @@ simplify_set (rtx x)
static rtx
simplify_logical (rtx x)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
rtx op0 = XEXP (x, 0);
rtx op1 = XEXP (x, 1);
@ -6889,7 +6889,7 @@ expand_compound_operation (rtx x)
modewidth = GET_MODE_PRECISION (GET_MODE (x));
if (modewidth >= pos + len)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
tem = gen_lowpart (mode, XEXP (x, 0));
if (!tem || GET_CODE (tem) == CLOBBER)
return x;
@ -6931,7 +6931,7 @@ expand_field_assignment (const_rtx x)
rtx pos; /* Always counts from low bit. */
int len;
rtx mask, cleared, masked;
enum machine_mode compute_mode;
machine_mode compute_mode;
/* Loop until we find something we can't simplify. */
while (1)
@ -7004,7 +7004,7 @@ expand_field_assignment (const_rtx x)
/* Don't attempt bitwise arithmetic on non scalar integer modes. */
if (! SCALAR_INT_MODE_P (compute_mode))
{
enum machine_mode imode;
machine_mode imode;
/* Don't do anything for vector or complex integral types. */
if (! FLOAT_MODE_P (compute_mode))
@ -7070,20 +7070,20 @@ expand_field_assignment (const_rtx x)
can't handle it. */
static rtx
make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
make_extraction (machine_mode mode, rtx inner, HOST_WIDE_INT pos,
rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
int in_dest, int in_compare)
{
/* This mode describes the size of the storage area
to fetch the overall value from. Within that, we
ignore the POS lowest bits, etc. */
enum machine_mode is_mode = GET_MODE (inner);
enum machine_mode inner_mode;
enum machine_mode wanted_inner_mode;
enum machine_mode wanted_inner_reg_mode = word_mode;
enum machine_mode pos_mode = word_mode;
enum machine_mode extraction_mode = word_mode;
enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
machine_mode is_mode = GET_MODE (inner);
machine_mode inner_mode;
machine_mode wanted_inner_mode;
machine_mode wanted_inner_reg_mode = word_mode;
machine_mode pos_mode = word_mode;
machine_mode extraction_mode = word_mode;
machine_mode tmode = mode_for_size (len, MODE_INT, 1);
rtx new_rtx = 0;
rtx orig_pos_rtx = pos_rtx;
HOST_WIDE_INT orig_pos;
@ -7463,7 +7463,7 @@ static rtx
extract_left_shift (rtx x, int count)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
rtx tem;
switch (code)
@ -7527,7 +7527,7 @@ rtx
make_compound_operation (rtx x, enum rtx_code in_code)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
int mode_width = GET_MODE_PRECISION (mode);
rtx rhs, lhs;
enum rtx_code next_code;
@ -8036,7 +8036,7 @@ canon_reg_for_combine (rtx x, rtx reg)
would need an explicit truncation. */
static rtx
gen_lowpart_or_truncate (enum machine_mode mode, rtx x)
gen_lowpart_or_truncate (machine_mode mode, rtx x)
{
if (!CONST_INT_P (x)
&& GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x))
@ -8067,12 +8067,12 @@ gen_lowpart_or_truncate (enum machine_mode mode, rtx x)
NOT, NEG, or XOR. */
static rtx
force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
force_to_mode (rtx x, machine_mode mode, unsigned HOST_WIDE_INT mask,
int just_select)
{
enum rtx_code code = GET_CODE (x);
int next_select = just_select || code == XOR || code == NOT || code == NEG;
enum machine_mode op_mode;
machine_mode op_mode;
unsigned HOST_WIDE_INT fuller_mask, nonzero;
rtx op0, op1, temp;
@ -8615,7 +8615,7 @@ force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
static rtx
if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
enum rtx_code code = GET_CODE (x);
rtx cond0, cond1, true0, true1, false0, false1;
unsigned HOST_WIDE_INT nz;
@ -8914,7 +8914,7 @@ known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
}
else if (code == SUBREG)
{
enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
rtx new_rtx, r = known_cond (SUBREG_REG (x), cond, reg, val);
if (SUBREG_REG (x) != r)
@ -8939,7 +8939,7 @@ known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
story is different. */
else if (code == ZERO_EXTEND)
{
enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
machine_mode inner_mode = GET_MODE (XEXP (x, 0));
rtx new_rtx, r = known_cond (XEXP (x, 0), cond, reg, val);
if (XEXP (x, 0) != r)
@ -9022,7 +9022,7 @@ make_field_assignment (rtx x)
HOST_WIDE_INT pos;
unsigned HOST_WIDE_INT len;
rtx other;
enum machine_mode mode;
machine_mode mode;
/* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
a clear of a one-bit field. We will have changed it to
@ -9305,7 +9305,7 @@ apply_distributive_law (rtx x)
static rtx
distribute_and_simplify_rtx (rtx x, int n)
{
enum machine_mode mode;
machine_mode mode;
enum rtx_code outer_code, inner_code;
rtx decomposed, distributed, inner_op0, inner_op1, new_op0, new_op1, tmp;
@ -9363,7 +9363,7 @@ distribute_and_simplify_rtx (rtx x, int n)
(const_int CONSTOP)). Otherwise, return NULL_RTX. */
static rtx
simplify_and_const_int_1 (enum machine_mode mode, rtx varop,
simplify_and_const_int_1 (machine_mode mode, rtx varop,
unsigned HOST_WIDE_INT constop)
{
unsigned HOST_WIDE_INT nonzero;
@ -9478,7 +9478,7 @@ simplify_and_const_int_1 (enum machine_mode mode, rtx varop,
X is zero, we are to always construct the equivalent form. */
static rtx
simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
simplify_and_const_int (rtx x, machine_mode mode, rtx varop,
unsigned HOST_WIDE_INT constop)
{
rtx tem = simplify_and_const_int_1 (mode, varop, constop);
@ -9500,9 +9500,9 @@ simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
a shift, AND, or zero_extract, we can do better. */
static rtx
reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode,
reg_nonzero_bits_for_combine (const_rtx x, machine_mode mode,
const_rtx known_x ATTRIBUTE_UNUSED,
enum machine_mode known_mode ATTRIBUTE_UNUSED,
machine_mode known_mode ATTRIBUTE_UNUSED,
unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
unsigned HOST_WIDE_INT *nonzero)
{
@ -9581,9 +9581,9 @@ reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode,
be between 1 and the number of bits in MODE. */
static rtx
reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
reg_num_sign_bit_copies_for_combine (const_rtx x, machine_mode mode,
const_rtx known_x ATTRIBUTE_UNUSED,
enum machine_mode known_mode
machine_mode known_mode
ATTRIBUTE_UNUSED,
unsigned int known_ret ATTRIBUTE_UNUSED,
unsigned int *result)
@ -9631,7 +9631,7 @@ reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
implies that it must be called from a define_split. */
unsigned int
extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
extended_count (const_rtx x, machine_mode mode, int unsignedp)
{
if (nonzero_sign_valid == 0)
return 0;
@ -9666,7 +9666,7 @@ extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
return 0 and do not change *POP0, *PCONST0, and *PCOMP_P. */
static int
merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, HOST_WIDE_INT const1, enum machine_mode mode, int *pcomp_p)
merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, HOST_WIDE_INT const1, machine_mode mode, int *pcomp_p)
{
enum rtx_code op0 = *pop0;
HOST_WIDE_INT const0 = *pconst0;
@ -9782,9 +9782,9 @@ merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1,
result of the shift is subject to operation OUTER_CODE with operand
OUTER_CONST. */
static enum machine_mode
static machine_mode
try_widen_shift_mode (enum rtx_code code, rtx op, int count,
enum machine_mode orig_mode, enum machine_mode mode,
machine_mode orig_mode, machine_mode mode,
enum rtx_code outer_code, HOST_WIDE_INT outer_const)
{
if (orig_mode == mode)
@ -9841,14 +9841,14 @@ try_widen_shift_mode (enum rtx_code code, rtx op, int count,
are ASHIFTRT and ROTATE, which are always done in their original mode. */
static rtx
simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
simplify_shift_const_1 (enum rtx_code code, machine_mode result_mode,
rtx varop, int orig_count)
{
enum rtx_code orig_code = code;
rtx orig_varop = varop;
int count;
enum machine_mode mode = result_mode;
enum machine_mode shift_mode, tmode;
machine_mode mode = result_mode;
machine_mode shift_mode, tmode;
unsigned int mode_words
= (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
/* We form (outer_op (code varop count) (outer_const)). */
@ -10577,7 +10577,7 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
are ASHIFTRT and ROTATE, which are always done in their original mode. */
static rtx
simplify_shift_const (rtx x, enum rtx_code code, enum machine_mode result_mode,
simplify_shift_const (rtx x, enum rtx_code code, machine_mode result_mode,
rtx varop, int count)
{
rtx tem = simplify_shift_const_1 (code, result_mode, varop, count);
@ -10765,9 +10765,9 @@ recog_for_combine (rtx *pnewpat, rtx_insn *insn, rtx *pnotes)
An insn containing that will not be recognized. */
static rtx
gen_lowpart_for_combine (enum machine_mode omode, rtx x)
gen_lowpart_for_combine (machine_mode omode, rtx x)
{
enum machine_mode imode = GET_MODE (x);
machine_mode imode = GET_MODE (x);
unsigned int osize = GET_MODE_SIZE (omode);
unsigned int isize = GET_MODE_SIZE (imode);
rtx result;
@ -10869,7 +10869,7 @@ gen_lowpart_for_combine (enum machine_mode omode, rtx x)
*POP1 may be updated. */
static enum rtx_code
simplify_compare_const (enum rtx_code code, enum machine_mode mode,
simplify_compare_const (enum rtx_code code, machine_mode mode,
rtx op0, rtx *pop1)
{
unsigned int mode_width = GET_MODE_PRECISION (mode);
@ -11065,7 +11065,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
rtx op1 = *pop1;
rtx tem, tem1;
int i;
enum machine_mode mode, tmode;
machine_mode mode, tmode;
/* Try a few ways of applying the same transformation to both operands. */
while (1)
@ -11112,7 +11112,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
&& INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
&& XEXP (op0, 1) == XEXP (op1, 1))
{
enum machine_mode mode = GET_MODE (op0);
machine_mode mode = GET_MODE (op0);
unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
int shift_count = INTVAL (XEXP (op0, 1));
@ -11217,7 +11217,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
while (CONST_INT_P (op1))
{
enum machine_mode mode = GET_MODE (op0);
machine_mode mode = GET_MODE (op0);
unsigned int mode_width = GET_MODE_PRECISION (mode);
unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
int equality_comparison_p;
@ -11442,7 +11442,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
&& GET_CODE (SUBREG_REG (op0)) == PLUS
&& CONST_INT_P (XEXP (SUBREG_REG (op0), 1)))
{
enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
rtx a = XEXP (SUBREG_REG (op0), 0);
HOST_WIDE_INT c1 = -INTVAL (XEXP (SUBREG_REG (op0), 1));
@ -12325,7 +12325,7 @@ record_value_for_reg (rtx reg, rtx_insn *insn, rtx value)
if (value)
{
enum machine_mode mode = GET_MODE (reg);
machine_mode mode = GET_MODE (reg);
subst_low_luid = DF_INSN_LUID (insn);
rsp->last_set_mode = mode;
if (GET_MODE_CLASS (mode) == MODE_INT
@ -12461,7 +12461,7 @@ record_promoted_value (rtx_insn *insn, rtx subreg)
struct insn_link *links;
rtx set;
unsigned int regno = REGNO (SUBREG_REG (subreg));
enum machine_mode mode = GET_MODE (subreg);
machine_mode mode = GET_MODE (subreg);
if (GET_MODE_PRECISION (mode) > HOST_BITS_PER_WIDE_INT)
return;
@ -12504,10 +12504,10 @@ record_promoted_value (rtx_insn *insn, rtx subreg)
an explicit truncation. */
static bool
reg_truncated_to_mode (enum machine_mode mode, const_rtx x)
reg_truncated_to_mode (machine_mode mode, const_rtx x)
{
reg_stat_type *rsp = &reg_stat[REGNO (x)];
enum machine_mode truncated = rsp->truncated_to_mode;
machine_mode truncated = rsp->truncated_to_mode;
if (truncated == 0
|| rsp->truncation_label < label_tick_ebb_start)
@ -12527,12 +12527,12 @@ reg_truncated_to_mode (enum machine_mode mode, const_rtx x)
static bool
record_truncated_value (rtx x)
{
enum machine_mode truncated_mode;
machine_mode truncated_mode;
reg_stat_type *rsp;
if (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)))
{
enum machine_mode original_mode = GET_MODE (SUBREG_REG (x));
machine_mode original_mode = GET_MODE (SUBREG_REG (x));
truncated_mode = GET_MODE (x);
if (GET_MODE_SIZE (original_mode) <= GET_MODE_SIZE (truncated_mode))

10
gcc/compare-elim.c
View File

@ -118,7 +118,7 @@ struct comparison
struct comparison_use uses[MAX_CMP_USE];
/* The original CC_MODE for this comparison. */
enum machine_mode orig_mode;
machine_mode orig_mode;
/* The number of uses identified for this comparison. */
unsigned short n_uses;
@ -317,7 +317,7 @@ find_comparison_dom_walker::before_dom_children (basic_block bb)
src = conforming_compare (insn);
if (src)
{
enum machine_mode src_mode = GET_MODE (src);
machine_mode src_mode = GET_MODE (src);
rtx eh_note = NULL;
if (flag_non_call_exceptions)
@ -338,7 +338,7 @@ find_comparison_dom_walker::before_dom_children (basic_block bb)
/* New mode must be compatible with the previous compare mode. */
{
enum machine_mode new_mode
machine_mode new_mode
= targetm.cc_modes_compatible (last_cmp->orig_mode, src_mode);
if (new_mode == VOIDmode)
goto dont_delete;
@ -466,7 +466,7 @@ static rtx
maybe_select_cc_mode (struct comparison *cmp, rtx a ATTRIBUTE_UNUSED,
rtx b ATTRIBUTE_UNUSED)
{
enum machine_mode sel_mode;
machine_mode sel_mode;
const int n = cmp->n_uses;
rtx flags = NULL;
@ -498,7 +498,7 @@ maybe_select_cc_mode (struct comparison *cmp, rtx a ATTRIBUTE_UNUSED,
sel_mode = SELECT_CC_MODE (cmp->uses[0].code, a, b);
for (i = 1; i < n; ++i)
{
enum machine_mode new_mode;
machine_mode new_mode;
new_mode = SELECT_CC_MODE (cmp->uses[i].code, a, b);
if (new_mode != sel_mode)
{

32
gcc/config/aarch64/aarch64-builtins.c
View File

@ -119,7 +119,7 @@ enum aarch64_type_qualifiers
typedef struct
{
const char *name;
enum machine_mode mode;
machine_mode mode;
const enum insn_code code;
unsigned int fcode;
enum aarch64_type_qualifiers *qualifiers;
@ -316,7 +316,7 @@ static aarch64_simd_builtin_datum aarch64_simd_builtin_data[] = {
typedef struct
{
const char *name;
enum machine_mode mode;
machine_mode mode;
const enum insn_code icode;
unsigned int fcode;
} aarch64_crc_builtin_datum;
@ -365,7 +365,7 @@ static GTY(()) tree aarch64_builtin_decls[AARCH64_BUILTIN_MAX];
/* Return a tree for a signed or unsigned argument of either
the mode specified by MODE, or the inner mode of MODE. */
tree
aarch64_build_scalar_type (enum machine_mode mode,
aarch64_build_scalar_type (machine_mode mode,
bool unsigned_p,
bool poly_p)
{
@ -444,7 +444,7 @@ aarch64_build_scalar_type (enum machine_mode mode,
}
tree
aarch64_build_vector_type (enum machine_mode mode,
aarch64_build_vector_type (machine_mode mode,
bool unsigned_p,
bool poly_p)
{
@ -511,7 +511,7 @@ aarch64_build_vector_type (enum machine_mode mode,
}
tree
aarch64_build_type (enum machine_mode mode, bool unsigned_p, bool poly_p)
aarch64_build_type (machine_mode mode, bool unsigned_p, bool poly_p)
{
if (VECTOR_MODE_P (mode))
return aarch64_build_vector_type (mode, unsigned_p, poly_p);
@ -520,19 +520,19 @@ aarch64_build_type (enum machine_mode mode, bool unsigned_p, bool poly_p)
}
tree
aarch64_build_signed_type (enum machine_mode mode)
aarch64_build_signed_type (machine_mode mode)
{
return aarch64_build_type (mode, false, false);
}
tree
aarch64_build_unsigned_type (enum machine_mode mode)
aarch64_build_unsigned_type (machine_mode mode)
{
return aarch64_build_type (mode, true, false);
}
tree
aarch64_build_poly_type (enum machine_mode mode)
aarch64_build_poly_type (machine_mode mode)
{
return aarch64_build_type (mode, false, true);
}
@ -646,7 +646,7 @@ aarch64_init_simd_builtins (void)
removing duplicates for us. */
for (; op_num >= 0; arg_num--, op_num--)
{
enum machine_mode op_mode = insn_data[d->code].operand[op_num].mode;
machine_mode op_mode = insn_data[d->code].operand[op_num].mode;
enum aarch64_type_qualifiers qualifiers = d->qualifiers[arg_num];
if (qualifiers & qualifier_unsigned)
@ -781,8 +781,8 @@ aarch64_simd_expand_args (rtx target, int icode, int have_retval,
rtx pat;
tree arg[SIMD_MAX_BUILTIN_ARGS];
rtx op[SIMD_MAX_BUILTIN_ARGS];
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode[SIMD_MAX_BUILTIN_ARGS];
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode[SIMD_MAX_BUILTIN_ARGS];
int argc = 0;
if (have_retval
@ -959,9 +959,9 @@ aarch64_crc32_expand_builtin (int fcode, tree exp, rtx target)
tree arg1 = CALL_EXPR_ARG (exp, 1);
rtx op0 = expand_normal (arg0);
rtx op1 = expand_normal (arg1);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[1].mode;
machine_mode mode1 = insn_data[icode].operand[2].mode;
if (! target
|| GET_MODE (target) != tmode
@ -990,7 +990,7 @@ rtx
aarch64_expand_builtin (tree exp,
rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
@ -1037,7 +1037,7 @@ aarch64_expand_builtin (tree exp,
tree
aarch64_builtin_vectorized_function (tree fndecl, tree type_out, tree type_in)
{
enum machine_mode in_mode, out_mode;
machine_mode in_mode, out_mode;
int in_n, out_n;
if (TREE_CODE (type_out) != VECTOR_TYPE

60
gcc/config/aarch64/aarch64-protos.h
View File

@ -174,9 +174,9 @@ struct tune_params
HOST_WIDE_INT aarch64_initial_elimination_offset (unsigned, unsigned);
int aarch64_get_condition_code (rtx);
bool aarch64_bitmask_imm (HOST_WIDE_INT val, enum machine_mode);
bool aarch64_cannot_change_mode_class (enum machine_mode,
enum machine_mode,
bool aarch64_bitmask_imm (HOST_WIDE_INT val, machine_mode);
bool aarch64_cannot_change_mode_class (machine_mode,
machine_mode,
enum reg_class);
enum aarch64_symbol_type
aarch64_classify_symbolic_expression (rtx, enum aarch64_symbol_context);
@ -187,29 +187,29 @@ bool aarch64_float_const_zero_rtx_p (rtx);
bool aarch64_function_arg_regno_p (unsigned);
bool aarch64_gen_movmemqi (rtx *);
bool aarch64_gimple_fold_builtin (gimple_stmt_iterator *);
bool aarch64_is_extend_from_extract (enum machine_mode, rtx, rtx);
bool aarch64_is_extend_from_extract (machine_mode, rtx, rtx);
bool aarch64_is_long_call_p (rtx);
bool aarch64_label_mentioned_p (rtx);
bool aarch64_legitimate_pic_operand_p (rtx);
bool aarch64_modes_tieable_p (enum machine_mode mode1,
enum machine_mode mode2);
bool aarch64_move_imm (HOST_WIDE_INT, enum machine_mode);
bool aarch64_modes_tieable_p (machine_mode mode1,
machine_mode mode2);
bool aarch64_move_imm (HOST_WIDE_INT, machine_mode);
bool aarch64_mov_operand_p (rtx, enum aarch64_symbol_context,
enum machine_mode);
bool aarch64_offset_7bit_signed_scaled_p (enum machine_mode, HOST_WIDE_INT);
char *aarch64_output_scalar_simd_mov_immediate (rtx, enum machine_mode);
char *aarch64_output_simd_mov_immediate (rtx, enum machine_mode, unsigned);
bool aarch64_pad_arg_upward (enum machine_mode, const_tree);
bool aarch64_pad_reg_upward (enum machine_mode, const_tree, bool);
machine_mode);
bool aarch64_offset_7bit_signed_scaled_p (machine_mode, HOST_WIDE_INT);
char *aarch64_output_scalar_simd_mov_immediate (rtx, machine_mode);
char *aarch64_output_simd_mov_immediate (rtx, machine_mode, unsigned);
bool aarch64_pad_arg_upward (machine_mode, const_tree);
bool aarch64_pad_reg_upward (machine_mode, const_tree, bool);
bool aarch64_regno_ok_for_base_p (int, bool);
bool aarch64_regno_ok_for_index_p (int, bool);
bool aarch64_simd_check_vect_par_cnst_half (rtx op, enum machine_mode mode,
bool aarch64_simd_check_vect_par_cnst_half (rtx op, machine_mode mode,
bool high);
bool aarch64_simd_imm_scalar_p (rtx x, enum machine_mode mode);
bool aarch64_simd_imm_zero_p (rtx, enum machine_mode);
bool aarch64_simd_scalar_immediate_valid_for_move (rtx, enum machine_mode);
bool aarch64_simd_shift_imm_p (rtx, enum machine_mode, bool);
bool aarch64_simd_valid_immediate (rtx, enum machine_mode, bool,
bool aarch64_simd_imm_scalar_p (rtx x, machine_mode mode);
bool aarch64_simd_imm_zero_p (rtx, machine_mode);
bool aarch64_simd_scalar_immediate_valid_for_move (rtx, machine_mode);
bool aarch64_simd_shift_imm_p (rtx, machine_mode, bool);
bool aarch64_simd_valid_immediate (rtx, machine_mode, bool,
struct simd_immediate_info *);
bool aarch64_symbolic_address_p (rtx);
bool aarch64_uimm12_shift (HOST_WIDE_INT);
@ -222,19 +222,19 @@ enum aarch64_symbol_type aarch64_classify_symbol (rtx,
enum aarch64_symbol_type aarch64_classify_tls_symbol (rtx);
enum reg_class aarch64_regno_regclass (unsigned);
int aarch64_asm_preferred_eh_data_format (int, int);
enum machine_mode aarch64_hard_regno_caller_save_mode (unsigned, unsigned,
enum machine_mode);
int aarch64_hard_regno_mode_ok (unsigned, enum machine_mode);
int aarch64_hard_regno_nregs (unsigned, enum machine_mode);
machine_mode aarch64_hard_regno_caller_save_mode (unsigned, unsigned,
machine_mode);
int aarch64_hard_regno_mode_ok (unsigned, machine_mode);
int aarch64_hard_regno_nregs (unsigned, machine_mode);
int aarch64_simd_attr_length_move (rtx_insn *);
int aarch64_uxt_size (int, HOST_WIDE_INT);
rtx aarch64_final_eh_return_addr (void);
rtx aarch64_legitimize_reload_address (rtx *, enum machine_mode, int, int, int);
rtx aarch64_legitimize_reload_address (rtx *, machine_mode, int, int, int);
const char *aarch64_output_move_struct (rtx *operands);
rtx aarch64_return_addr (int, rtx);
rtx aarch64_simd_gen_const_vector_dup (enum machine_mode, int);
rtx aarch64_simd_gen_const_vector_dup (machine_mode, int);
bool aarch64_simd_mem_operand_p (rtx);
rtx aarch64_simd_vect_par_cnst_half (enum machine_mode, bool);
rtx aarch64_simd_vect_par_cnst_half (machine_mode, bool);
rtx aarch64_tls_get_addr (void);
tree aarch64_fold_builtin (tree, int, tree *, bool);
unsigned aarch64_dbx_register_number (unsigned);
@ -260,7 +260,7 @@ void aarch64_simd_disambiguate_copy (rtx *, rtx *, rtx *, unsigned int);
/* Emit code to place a AdvSIMD pair result in memory locations (with equal
registers). */
void aarch64_simd_emit_pair_result_insn (enum machine_mode,
void aarch64_simd_emit_pair_result_insn (machine_mode,
rtx (*intfn) (rtx, rtx, rtx), rtx,
rtx);
@ -282,8 +282,8 @@ bool aarch64_float_const_representable_p (rtx);
#if defined (RTX_CODE)
bool aarch64_legitimate_address_p (enum machine_mode, rtx, RTX_CODE, bool);
enum machine_mode aarch64_select_cc_mode (RTX_CODE, rtx, rtx);
bool aarch64_legitimate_address_p (machine_mode, rtx, RTX_CODE, bool);
machine_mode aarch64_select_cc_mode (RTX_CODE, rtx, rtx);
rtx aarch64_gen_compare_reg (RTX_CODE, rtx, rtx);
rtx aarch64_load_tp (rtx);
@ -297,7 +297,7 @@ void aarch64_init_builtins (void);
rtx aarch64_expand_builtin (tree exp,
rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED);
tree aarch64_builtin_decl (unsigned, bool ATTRIBUTE_UNUSED);

36
gcc/config/aarch64/aarch64-simd.md
View File

@ -3807,7 +3807,7 @@
if (GP_REGNUM_P (REGNO (operands[0]))
&& GP_REGNUM_P (REGNO (operands[1])))
{
enum machine_mode mode = SELECT_CC_MODE (<CMP>, operands[1], operands[2]);
machine_mode mode = SELECT_CC_MODE (<CMP>, operands[1], operands[2]);
rtx cc_reg = aarch64_gen_compare_reg (<CMP>, operands[1], operands[2]);
rtx comparison = gen_rtx_<CMP> (mode, operands[1], operands[2]);
emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
@ -3870,7 +3870,7 @@
if (GP_REGNUM_P (REGNO (operands[0]))
&& GP_REGNUM_P (REGNO (operands[1])))
{
enum machine_mode mode = CCmode;
machine_mode mode = CCmode;
rtx cc_reg = aarch64_gen_compare_reg (<CMP>, operands[1], operands[2]);
rtx comparison = gen_rtx_<CMP> (mode, operands[1], operands[2]);
emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
@ -3943,7 +3943,7 @@
&& GP_REGNUM_P (REGNO (operands[1])))
{
rtx and_tree = gen_rtx_AND (DImode, operands[1], operands[2]);
enum machine_mode mode = SELECT_CC_MODE (NE, and_tree, const0_rtx);
machine_mode mode = SELECT_CC_MODE (NE, and_tree, const0_rtx);
rtx cc_reg = aarch64_gen_compare_reg (NE, and_tree, const0_rtx);
rtx comparison = gen_rtx_NE (mode, and_tree, const0_rtx);
emit_insn (gen_cstoredi_neg (operands[0], comparison, cc_reg));
@ -4319,7 +4319,7 @@
(unspec:VALLDIF [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_TWO_ELEM>mode;
machine_mode mode = <V_TWO_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
emit_insn (gen_aarch64_simd_ld2r<mode> (operands[0], mem));
@ -4332,7 +4332,7 @@
(unspec:VALLDIF [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_THREE_ELEM>mode;
machine_mode mode = <V_THREE_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
emit_insn (gen_aarch64_simd_ld3r<mode> (operands[0], mem));
@ -4345,7 +4345,7 @@
(unspec:VALLDIF [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_FOUR_ELEM>mode;
machine_mode mode = <V_FOUR_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
emit_insn (gen_aarch64_simd_ld4r<mode> (operands[0],mem));
@ -4490,7 +4490,7 @@
(unspec:VDC [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <VSTRUCT:VSTRUCT_DREG>mode;
machine_mode mode = <VSTRUCT:VSTRUCT_DREG>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
emit_insn (gen_aarch64_ld<VSTRUCT:nregs><VDC:mode>_dreg (operands[0], mem));
@ -4502,7 +4502,7 @@
(match_operand:DI 1 "register_operand")]
"TARGET_SIMD"
{
enum machine_mode mode = <VALL:MODE>mode;
machine_mode mode = <VALL:MODE>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
if (BYTES_BIG_ENDIAN)
@ -4518,7 +4518,7 @@
(unspec:VQ [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <VSTRUCT:MODE>mode;
machine_mode mode = <VSTRUCT:MODE>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
emit_insn (gen_vec_load_lanes<VSTRUCT:mode><VQ:mode> (operands[0], mem));
@ -4533,7 +4533,7 @@
(unspec:VQ [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_TWO_ELEM>mode;
machine_mode mode = <V_TWO_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
aarch64_simd_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<VCONQ>mode));
@ -4552,7 +4552,7 @@
(unspec:VQ [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_THREE_ELEM>mode;
machine_mode mode = <V_THREE_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
aarch64_simd_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<VCONQ>mode));
@ -4571,7 +4571,7 @@
(unspec:VQ [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <V_FOUR_ELEM>mode;
machine_mode mode = <V_FOUR_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[1]);
aarch64_simd_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<VCONQ>mode));
@ -4804,7 +4804,7 @@
(unspec:VDC [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <VSTRUCT:VSTRUCT_DREG>mode;
machine_mode mode = <VSTRUCT:VSTRUCT_DREG>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
emit_insn (gen_aarch64_st<VSTRUCT:nregs><VDC:mode>_dreg (mem, operands[1]));
@ -4817,7 +4817,7 @@
(unspec:VQ [(const_int 0)] UNSPEC_VSTRUCTDUMMY)]
"TARGET_SIMD"
{
enum machine_mode mode = <VSTRUCT:MODE>mode;
machine_mode mode = <VSTRUCT:MODE>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
emit_insn (gen_vec_store_lanes<VSTRUCT:mode><VQ:mode> (mem, operands[1]));
@ -4831,7 +4831,7 @@
(match_operand:SI 2 "immediate_operand")]
"TARGET_SIMD"
{
enum machine_mode mode = <V_TWO_ELEM>mode;
machine_mode mode = <V_TWO_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
operands[2] = GEN_INT (ENDIAN_LANE_N (<MODE>mode, INTVAL (operands[2])));
@ -4848,7 +4848,7 @@
(match_operand:SI 2 "immediate_operand")]
"TARGET_SIMD"
{
enum machine_mode mode = <V_THREE_ELEM>mode;
machine_mode mode = <V_THREE_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
operands[2] = GEN_INT (ENDIAN_LANE_N (<MODE>mode, INTVAL (operands[2])));
@ -4865,7 +4865,7 @@
(match_operand:SI 2 "immediate_operand")]
"TARGET_SIMD"
{
enum machine_mode mode = <V_FOUR_ELEM>mode;
machine_mode mode = <V_FOUR_ELEM>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
operands[2] = GEN_INT (ENDIAN_LANE_N (<MODE>mode, INTVAL (operands[2])));
@ -4880,7 +4880,7 @@
(match_operand:VALL 1 "register_operand")]
"TARGET_SIMD"
{
enum machine_mode mode = <VALL:MODE>mode;
machine_mode mode = <VALL:MODE>mode;
rtx mem = gen_rtx_MEM (mode, operands[0]);
if (BYTES_BIG_ENDIAN)

284
gcc/config/aarch64/aarch64.c
View File

File diff suppressed because it is too large Load Diff

4
gcc/config/aarch64/aarch64.h
View File

@ -604,14 +604,14 @@ enum arm_pcs
/* We can't use enum machine_mode inside a generator file because it
/* We can't use machine_mode inside a generator file because it
hasn't been created yet; we shouldn't be using any code that
needs the real definition though, so this ought to be safe. */
#ifdef GENERATOR_FILE
#define MACHMODE int
#else
#include "insn-modes.h"
#define MACHMODE enum machine_mode
#define MACHMODE machine_mode
#endif

8
gcc/config/aarch64/aarch64.md
View File

@ -3831,7 +3831,7 @@
(match_operand 2 "aarch64_valid_symref" "S")))]
""
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
emit_insn ((mode == DImode
? gen_add_losym_di
@ -3942,7 +3942,7 @@
UNSPEC_GOTSMALLTLS))]
""
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
emit_insn ((mode == DImode
? gen_tlsle_small_di
: gen_tlsle_small_si) (operands[0],
@ -4001,7 +4001,7 @@
(match_operand 1 "memory_operand")]
""
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
emit_insn ((mode == DImode
? gen_stack_protect_set_di
@ -4026,7 +4026,7 @@
""
{
rtx result;
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
result = gen_reg_rtx(mode);

28
gcc/config/alpha/alpha-protos.h
View File

@ -30,8 +30,8 @@ extern void alpha_expand_prologue (void);
extern void alpha_expand_epilogue (void);
extern void alpha_output_filename (FILE *, const char *);
extern bool alpha_legitimate_constant_p (enum machine_mode, rtx);
extern rtx alpha_legitimize_reload_address (rtx, enum machine_mode,
extern bool alpha_legitimate_constant_p (machine_mode, rtx);
extern rtx alpha_legitimize_reload_address (rtx, machine_mode,
int, int, int);
extern rtx split_small_symbolic_operand (rtx);
@ -42,13 +42,13 @@ extern rtx get_unaligned_offset (rtx, HOST_WIDE_INT);
extern enum reg_class alpha_preferred_reload_class (rtx, enum reg_class);
extern void alpha_set_memflags (rtx, rtx);
extern bool alpha_split_const_mov (enum machine_mode, rtx *);
extern bool alpha_expand_mov (enum machine_mode, rtx *);
extern bool alpha_expand_mov_nobwx (enum machine_mode, rtx *);
extern void alpha_expand_movmisalign (enum machine_mode, rtx *);
extern bool alpha_split_const_mov (machine_mode, rtx *);
extern bool alpha_expand_mov (machine_mode, rtx *);
extern bool alpha_expand_mov_nobwx (machine_mode, rtx *);
extern void alpha_expand_movmisalign (machine_mode, rtx *);
extern void alpha_emit_floatuns (rtx[]);
extern rtx alpha_emit_conditional_move (rtx, enum machine_mode);
extern void alpha_split_tmode_pair (rtx[], enum machine_mode, bool);
extern rtx alpha_emit_conditional_move (rtx, machine_mode);
extern void alpha_split_tmode_pair (rtx[], machine_mode, bool);
extern void alpha_split_tfmode_frobsign (rtx[], rtx (*)(rtx, rtx, rtx));
extern void alpha_expand_unaligned_load (rtx, rtx, HOST_WIDE_INT,
HOST_WIDE_INT, int);
@ -58,7 +58,7 @@ extern int alpha_expand_block_move (rtx []);
extern int alpha_expand_block_clear (rtx []);
extern rtx alpha_expand_zap_mask (HOST_WIDE_INT);
extern void alpha_expand_builtin_vector_binop (rtx (*)(rtx, rtx, rtx),
enum machine_mode,
machine_mode,
rtx, rtx, rtx);
extern void alpha_expand_builtin_establish_vms_condition_handler (rtx, rtx);
extern void alpha_expand_builtin_revert_vms_condition_handler (rtx);
@ -70,7 +70,7 @@ extern void print_operand_address (FILE *, rtx);
extern void alpha_initialize_trampoline (rtx, rtx, rtx, int, int, int);
extern rtx alpha_va_arg (tree, tree);
extern rtx function_value (const_tree, const_tree, enum machine_mode);
extern rtx function_value (const_tree, const_tree, machine_mode);
extern void alpha_start_function (FILE *, const char *, tree);
extern void alpha_end_function (FILE *, const char *, tree);
@ -78,12 +78,12 @@ extern void alpha_end_function (FILE *, const char *, tree);
extern bool alpha_find_lo_sum_using_gp (rtx);
#ifdef REAL_VALUE_TYPE
extern int check_float_value (enum machine_mode, REAL_VALUE_TYPE *, int);
extern int check_float_value (machine_mode, REAL_VALUE_TYPE *, int);
#endif
#ifdef RTX_CODE
extern void alpha_emit_conditional_branch (rtx[], enum machine_mode);
extern bool alpha_emit_setcc (rtx[], enum machine_mode);
extern void alpha_emit_conditional_branch (rtx[], machine_mode);
extern bool alpha_emit_setcc (rtx[], machine_mode);
extern int alpha_split_conditional_move (enum rtx_code, rtx, rtx, rtx, rtx);
extern void alpha_emit_xfloating_arith (enum rtx_code, rtx[]);
extern void alpha_emit_xfloating_cvt (enum rtx_code, rtx[]);
@ -100,7 +100,7 @@ extern void alpha_split_atomic_exchange_12 (rtx op[]);
extern rtx alpha_use_linkage (rtx, bool, bool);
#if TARGET_ABI_OPEN_VMS
extern enum avms_arg_type alpha_arg_type (enum machine_mode);
extern enum avms_arg_type alpha_arg_type (machine_mode);
extern rtx alpha_arg_info_reg_val (CUMULATIVE_ARGS);
extern void avms_asm_output_external (FILE *, tree, const char *);
extern void vms_output_aligned_decl_common (FILE *, tree, const char *,

108
gcc/config/alpha/alpha.c
View File

@ -229,7 +229,7 @@ static void alpha_align_insns (void);
#if TARGET_ABI_OPEN_VMS
static void alpha_write_linkage (FILE *, const char *);
static bool vms_valid_pointer_mode (enum machine_mode);
static bool vms_valid_pointer_mode (machine_mode);
#else
#define vms_patch_builtins() gcc_unreachable()
#endif
@ -718,7 +718,7 @@ resolve_reload_operand (rtx op)
indicates only DFmode. */
static bool
alpha_scalar_mode_supported_p (enum machine_mode mode)
alpha_scalar_mode_supported_p (machine_mode mode)
{
switch (mode)
{
@ -747,7 +747,7 @@ alpha_scalar_mode_supported_p (enum machine_mode mode)
or when expand_vector_operations can do something useful. */
static bool
alpha_vector_mode_supported_p (enum machine_mode mode)
alpha_vector_mode_supported_p (machine_mode mode)
{
return mode == V8QImode || mode == V4HImode || mode == V2SImode;
}
@ -842,7 +842,7 @@ alpha_in_small_data_p (const_tree exp)
#if TARGET_ABI_OPEN_VMS
static bool
vms_valid_pointer_mode (enum machine_mode mode)
vms_valid_pointer_mode (machine_mode mode)
{
return (mode == SImode || mode == DImode);
}
@ -877,7 +877,7 @@ alpha_linkage_symbol_p (const char *symname)
low-order three bits; this is an "unaligned" access. */
static bool
alpha_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
alpha_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
/* If this is an ldq_u type address, discard the outer AND. */
if (mode == DImode
@ -988,7 +988,7 @@ get_tls_get_addr (void)
to be legitimate. If we find one, return the new, valid address. */
static rtx
alpha_legitimize_address_1 (rtx x, rtx scratch, enum machine_mode mode)
alpha_legitimize_address_1 (rtx x, rtx scratch, machine_mode mode)
{
HOST_WIDE_INT addend;
@ -1188,7 +1188,7 @@ alpha_legitimize_address_1 (rtx x, rtx scratch, enum machine_mode mode)
static rtx
alpha_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
rtx new_x = alpha_legitimize_address_1 (x, NULL_RTX, mode);
return new_x ? new_x : x;
@ -1210,7 +1210,7 @@ alpha_mode_dependent_address_p (const_rtx addr,
should never be spilling symbolic operands to the constant pool, ever. */
static bool
alpha_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
alpha_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
enum rtx_code code = GET_CODE (x);
return code == SYMBOL_REF || code == LABEL_REF || code == CONST;
@ -1301,7 +1301,7 @@ alpha_cannot_copy_insn_p (rtx_insn *insn)
rtx
alpha_legitimize_reload_address (rtx x,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int opnum, int type,
int ind_levels ATTRIBUTE_UNUSED)
{
@ -1360,7 +1360,7 @@ static bool
alpha_rtx_costs (rtx x, int code, int outer_code, int opno, int *total,
bool speed)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
bool float_mode_p = FLOAT_MODE_P (mode);
const struct alpha_rtx_cost_data *cost_data;
@ -1645,7 +1645,7 @@ alpha_preferred_reload_class(rtx x, enum reg_class rclass)
static reg_class_t
alpha_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
enum machine_mode mode, secondary_reload_info *sri)
machine_mode mode, secondary_reload_info *sri)
{
enum reg_class rclass = (enum reg_class) rclass_i;
@ -1725,7 +1725,7 @@ alpha_set_memflags (rtx seq, rtx ref)
gcc_unreachable ();
}
static rtx alpha_emit_set_const (rtx, enum machine_mode, HOST_WIDE_INT,
static rtx alpha_emit_set_const (rtx, machine_mode, HOST_WIDE_INT,
int, bool);
/* Internal routine for alpha_emit_set_const to check for N or below insns.
@ -1733,7 +1733,7 @@ static rtx alpha_emit_set_const (rtx, enum machine_mode, HOST_WIDE_INT,
and return pc_rtx if successful. */
static rtx
alpha_emit_set_const_1 (rtx target, enum machine_mode mode,
alpha_emit_set_const_1 (rtx target, machine_mode mode,
HOST_WIDE_INT c, int n, bool no_output)
{
HOST_WIDE_INT new_const;
@ -1981,10 +1981,10 @@ alpha_emit_set_const_1 (rtx target, enum machine_mode mode,
insns and emitted. */
static rtx
alpha_emit_set_const (rtx target, enum machine_mode mode,
alpha_emit_set_const (rtx target, machine_mode mode,
HOST_WIDE_INT c, int n, bool no_output)
{
enum machine_mode orig_mode = mode;
machine_mode orig_mode = mode;
rtx orig_target = target;
rtx result = 0;
int i;
@ -2132,7 +2132,7 @@ alpha_extract_integer (rtx x, HOST_WIDE_INT *p0, HOST_WIDE_INT *p1)
take three or fewer instructions, and floating-point zero. */
bool
alpha_legitimate_constant_p (enum machine_mode mode, rtx x)
alpha_legitimate_constant_p (machine_mode mode, rtx x)
{
HOST_WIDE_INT i0, i1;
@ -2192,7 +2192,7 @@ alpha_legitimate_constant_p (enum machine_mode mode, rtx x)
instruction to load. Emit that multi-part load. */
bool
alpha_split_const_mov (enum machine_mode mode, rtx *operands)
alpha_split_const_mov (machine_mode mode, rtx *operands)
{
HOST_WIDE_INT i0, i1;
rtx temp = NULL_RTX;
@ -2219,7 +2219,7 @@ alpha_split_const_mov (enum machine_mode mode, rtx *operands)
We don't handle non-bwx subword loads here. */
bool
alpha_expand_mov (enum machine_mode mode, rtx *operands)
alpha_expand_mov (machine_mode mode, rtx *operands)
{
rtx tmp;
@ -2274,7 +2274,7 @@ alpha_expand_mov (enum machine_mode mode, rtx *operands)
return true if all work is done. */
bool
alpha_expand_mov_nobwx (enum machine_mode mode, rtx *operands)
alpha_expand_mov_nobwx (machine_mode mode, rtx *operands)
{
rtx seq;
@ -2396,7 +2396,7 @@ alpha_expand_mov_nobwx (enum machine_mode mode, rtx *operands)
that is not naturally aligned. Emit instructions to load it. */
void
alpha_expand_movmisalign (enum machine_mode mode, rtx *operands)
alpha_expand_movmisalign (machine_mode mode, rtx *operands)
{
/* Honor misaligned loads, for those we promised to do so. */
if (MEM_P (operands[1]))
@ -2476,7 +2476,7 @@ void
alpha_emit_floatuns (rtx operands[2])
{
rtx neglab, donelab, i0, i1, f0, in, out;
enum machine_mode mode;
machine_mode mode;
out = operands[0];
in = force_reg (DImode, operands[1]);
@ -2507,10 +2507,10 @@ alpha_emit_floatuns (rtx operands[2])
/* Generate the comparison for a conditional branch. */
void
alpha_emit_conditional_branch (rtx operands[], enum machine_mode cmp_mode)
alpha_emit_conditional_branch (rtx operands[], machine_mode cmp_mode)
{
enum rtx_code cmp_code, branch_code;
enum machine_mode branch_mode = VOIDmode;
machine_mode branch_mode = VOIDmode;
enum rtx_code code = GET_CODE (operands[0]);
rtx op0 = operands[1], op1 = operands[2];
rtx tem;
@ -2640,7 +2640,7 @@ alpha_emit_conditional_branch (rtx operands[], enum machine_mode cmp_mode)
valid. Return the final comparison, or NULL if we can't work. */
bool
alpha_emit_setcc (rtx operands[], enum machine_mode cmp_mode)
alpha_emit_setcc (rtx operands[], machine_mode cmp_mode)
{
enum rtx_code cmp_code;
enum rtx_code code = GET_CODE (operands[1]);
@ -2729,15 +2729,15 @@ alpha_emit_setcc (rtx operands[], enum machine_mode cmp_mode)
the conditional move). */
rtx
alpha_emit_conditional_move (rtx cmp, enum machine_mode mode)
alpha_emit_conditional_move (rtx cmp, machine_mode mode)
{
enum rtx_code code = GET_CODE (cmp);
enum rtx_code cmov_code = NE;
rtx op0 = XEXP (cmp, 0);
rtx op1 = XEXP (cmp, 1);
enum machine_mode cmp_mode
machine_mode cmp_mode
= (GET_MODE (op0) == VOIDmode ? DImode : GET_MODE (op0));
enum machine_mode cmov_mode = VOIDmode;
machine_mode cmov_mode = VOIDmode;
int local_fast_math = flag_unsafe_math_optimizations;
rtx tem;
@ -2892,7 +2892,7 @@ alpha_split_conditional_move (enum rtx_code code, rtx dest, rtx cond,
rtx t_rtx, rtx f_rtx)
{
HOST_WIDE_INT t, f, diff;
enum machine_mode mode;
machine_mode mode;
rtx target, subtarget, tmp;
mode = GET_MODE (dest);
@ -3274,7 +3274,7 @@ alpha_emit_xfloating_cvt (enum rtx_code orig_code, rtx operands[])
This is used by *movtf_internal and *movti_internal. */
void
alpha_split_tmode_pair (rtx operands[4], enum machine_mode mode,
alpha_split_tmode_pair (rtx operands[4], machine_mode mode,
bool fixup_overlap)
{
switch (GET_CODE (operands[1]))
@ -3399,7 +3399,7 @@ alpha_expand_unaligned_load (rtx tgt, rtx mem, HOST_WIDE_INT size,
HOST_WIDE_INT ofs, int sign)
{
rtx meml, memh, addr, extl, exth, tmp, mema;
enum machine_mode mode;
machine_mode mode;
if (TARGET_BWX && size == 2)
{
@ -4082,7 +4082,7 @@ alpha_expand_block_clear (rtx operands[])
&& align >= 32
&& !(alignofs == 4 && bytes >= 4))
{
enum machine_mode mode = (align >= 64 ? DImode : SImode);
machine_mode mode = (align >= 64 ? DImode : SImode);
int inv_alignofs = (align >= 64 ? 8 : 4) - alignofs;
rtx mem, tmp;
HOST_WIDE_INT mask;
@ -4353,7 +4353,7 @@ alpha_expand_zap_mask (HOST_WIDE_INT value)
void
alpha_expand_builtin_vector_binop (rtx (*gen) (rtx, rtx, rtx),
enum machine_mode mode,
machine_mode mode,
rtx op0, rtx op1, rtx op2)
{
op0 = gen_lowpart (mode, op0);
@ -4389,7 +4389,7 @@ emit_unlikely_jump (rtx cond, rtx label)
instruction in MODE. */
static void
emit_load_locked (enum machine_mode mode, rtx reg, rtx mem)
emit_load_locked (machine_mode mode, rtx reg, rtx mem)
{
rtx (*fn) (rtx, rtx) = NULL;
if (mode == SImode)
@ -4403,7 +4403,7 @@ emit_load_locked (enum machine_mode mode, rtx reg, rtx mem)
instruction in MODE. */
static void
emit_store_conditional (enum machine_mode mode, rtx res, rtx mem, rtx val)
emit_store_conditional (machine_mode mode, rtx res, rtx mem, rtx val)
{
rtx (*fn) (rtx, rtx, rtx) = NULL;
if (mode == SImode)
@ -4434,7 +4434,7 @@ alpha_post_atomic_barrier (enum memmodel model)
instruction in MODE. */
static rtx
emit_insxl (enum machine_mode mode, rtx op1, rtx op2)
emit_insxl (machine_mode mode, rtx op1, rtx op2)
{
rtx ret = gen_reg_rtx (DImode);
rtx (*fn) (rtx, rtx, rtx);
@ -4473,7 +4473,7 @@ void
alpha_split_atomic_op (enum rtx_code code, rtx mem, rtx val, rtx before,
rtx after, rtx scratch, enum memmodel model)
{
enum machine_mode mode = GET_MODE (mem);
machine_mode mode = GET_MODE (mem);
rtx label, x, cond = gen_rtx_REG (DImode, REGNO (scratch));
alpha_pre_atomic_barrier (model);
@ -4515,7 +4515,7 @@ alpha_split_compare_and_swap (rtx operands[])
rtx cond, retval, mem, oldval, newval;
bool is_weak;
enum memmodel mod_s, mod_f;
enum machine_mode mode;
machine_mode mode;
rtx label1, label2, x;
cond = operands[0];
@ -4576,7 +4576,7 @@ void
alpha_expand_compare_and_swap_12 (rtx operands[])
{
rtx cond, dst, mem, oldval, newval, is_weak, mod_s, mod_f;
enum machine_mode mode;
machine_mode mode;
rtx addr, align, wdst;
rtx (*gen) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
@ -4617,7 +4617,7 @@ void
alpha_split_compare_and_swap_12 (rtx operands[])
{
rtx cond, dest, orig_mem, oldval, newval, align, scratch;
enum machine_mode mode;
machine_mode mode;
bool is_weak;
enum memmodel mod_s, mod_f;
rtx label1, label2, mem, addr, width, mask, x;
@ -4698,7 +4698,7 @@ alpha_split_atomic_exchange (rtx operands[])
{
rtx retval, mem, val, scratch;
enum memmodel model;
enum machine_mode mode;
machine_mode mode;
rtx label, x, cond;
retval = operands[0];
@ -4728,7 +4728,7 @@ void
alpha_expand_atomic_exchange_12 (rtx operands[])
{
rtx dst, mem, val, model;
enum machine_mode mode;
machine_mode mode;
rtx addr, align, wdst;
rtx (*gen) (rtx, rtx, rtx, rtx, rtx);
@ -4764,7 +4764,7 @@ alpha_split_atomic_exchange_12 (rtx operands[])
{
rtx dest, orig_mem, addr, val, align, scratch;
rtx label, mem, width, mask, x;
enum machine_mode mode;
machine_mode mode;
enum memmodel model;
dest = operands[0];
@ -5662,7 +5662,7 @@ alpha_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
and the rest are pushed. */
static rtx
alpha_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
alpha_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -5724,7 +5724,7 @@ alpha_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
(TYPE is null for libcalls where that information may not be available.) */
static void
alpha_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
alpha_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -5742,7 +5742,7 @@ alpha_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
static int
alpha_arg_partial_bytes (cumulative_args_t cum_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -5769,7 +5769,7 @@ alpha_arg_partial_bytes (cumulative_args_t cum_v,
static bool
alpha_return_in_memory (const_tree type, const_tree fndecl ATTRIBUTE_UNUSED)
{
enum machine_mode mode = VOIDmode;
machine_mode mode = VOIDmode;
int size;
if (type)
@ -5823,7 +5823,7 @@ alpha_return_in_memory (const_tree type, const_tree fndecl ATTRIBUTE_UNUSED)
static bool
alpha_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
enum machine_mode mode,
machine_mode mode,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -5840,7 +5840,7 @@ alpha_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
rtx
function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
unsigned int regnum, dummy ATTRIBUTE_UNUSED;
enum mode_class mclass;
@ -5871,7 +5871,7 @@ function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED,
case MODE_COMPLEX_FLOAT:
{
enum machine_mode cmode = GET_MODE_INNER (mode);
machine_mode cmode = GET_MODE_INNER (mode);
return gen_rtx_PARALLEL
(VOIDmode,
@ -6160,7 +6160,7 @@ escapes:
variable number of arguments. */
static void
alpha_setup_incoming_varargs (cumulative_args_t pcum, enum machine_mode mode,
alpha_setup_incoming_varargs (cumulative_args_t pcum, machine_mode mode,
tree type, int *pretend_size, int no_rtl)
{
CUMULATIVE_ARGS cum = *get_cumulative_args (pcum);
@ -6683,7 +6683,7 @@ alpha_init_builtins (void)
static rtx
alpha_expand_builtin (tree exp, rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
#define MAX_ARGS 2
@ -6726,7 +6726,7 @@ alpha_expand_builtin (tree exp, rtx target,
if (nonvoid)
{
enum machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode tmode = insn_data[icode].operand[0].mode;
if (!target
|| GET_MODE (target) != tmode
|| !(*insn_data[icode].operand[0].predicate) (target, tmode))
@ -9551,7 +9551,7 @@ alpha_elf_reloc_rw_mask (void)
honor small data. */
static section *
alpha_elf_select_rtx_section (enum machine_mode mode, rtx x,
alpha_elf_select_rtx_section (machine_mode mode, rtx x,
unsigned HOST_WIDE_INT align)
{
if (TARGET_SMALL_DATA && GET_MODE_SIZE (mode) <= g_switch_value)
@ -9599,7 +9599,7 @@ struct GTY(()) alpha_links
/* Return the VMS argument type corresponding to MODE. */
enum avms_arg_type
alpha_arg_type (enum machine_mode mode)
alpha_arg_type (machine_mode mode)
{
switch (mode)
{

22
gcc/config/arc/arc-protos.h
View File

@ -19,15 +19,15 @@ along with GCC; see the file COPYING3. If not see
#ifdef RTX_CODE
extern enum machine_mode arc_select_cc_mode (enum rtx_code, rtx, rtx);
extern machine_mode arc_select_cc_mode (enum rtx_code, rtx, rtx);
/* Define the function that build the compare insn for scc, bcc and mov*cc. */
extern struct rtx_def *gen_compare_reg (rtx, enum machine_mode);
extern struct rtx_def *gen_compare_reg (rtx, machine_mode);
/* Declarations for various fns used in the .md file. */
extern void arc_output_function_epilogue (FILE *, HOST_WIDE_INT, int);
extern const char *output_shift (rtx *);
extern bool compact_sda_memory_operand (rtx op,enum machine_mode mode);
extern bool compact_sda_memory_operand (rtx op,machine_mode mode);
extern bool arc_double_limm_p (rtx);
extern void arc_print_operand (FILE *, rtx, int);
extern void arc_print_operand_address (FILE *, rtx);
@ -35,11 +35,11 @@ extern void arc_final_prescan_insn (rtx_insn *, rtx *, int);
extern void arc_set_default_type_attributes(tree type);
extern const char *arc_output_libcall (const char *);
extern bool prepare_extend_operands (rtx *operands, enum rtx_code code,
enum machine_mode omode);
machine_mode omode);
extern int arc_output_addsi (rtx *operands, bool, bool);
extern int arc_output_commutative_cond_exec (rtx *operands, bool);
extern bool arc_expand_movmem (rtx *operands);
extern bool prepare_move_operands (rtx *operands, enum machine_mode mode);
extern bool prepare_move_operands (rtx *operands, machine_mode mode);
extern void emit_shift (enum rtx_code, rtx, rtx, rtx);
#endif /* RTX_CODE */
@ -61,21 +61,21 @@ void arc_asm_output_aligned_decl_local (FILE *, tree, const char *,
extern rtx arc_return_addr_rtx (int , rtx);
extern bool check_if_valid_regno_const (rtx *, int);
extern bool check_if_valid_sleep_operand (rtx *, int);
extern bool arc_legitimate_constant_p (enum machine_mode, rtx);
extern bool arc_legitimate_constant_p (machine_mode, rtx);
extern bool arc_legitimate_pc_offset_p (rtx);
extern bool arc_legitimate_pic_addr_p (rtx);
extern void emit_pic_move (rtx *, enum machine_mode);
extern void emit_pic_move (rtx *, machine_mode);
extern bool arc_raw_symbolic_reference_mentioned_p (rtx, bool);
extern bool arc_legitimate_pic_operand_p (rtx);
extern bool arc_is_longcall_p (rtx);
extern bool arc_is_shortcall_p (rtx);
extern bool arc_profile_call (rtx callee);
extern bool valid_brcc_with_delay_p (rtx *);
extern bool small_data_pattern (rtx , enum machine_mode);
extern bool small_data_pattern (rtx , machine_mode);
extern rtx arc_rewrite_small_data (rtx);
extern bool arc_ccfsm_cond_exec_p (void);
struct secondary_reload_info;
extern int arc_register_move_cost (enum machine_mode, enum reg_class,
extern int arc_register_move_cost (machine_mode, enum reg_class,
enum reg_class);
extern rtx disi_highpart (rtx);
extern int arc_adjust_insn_length (rtx_insn *, int, bool);
@ -115,6 +115,6 @@ extern int arc_decl_pretend_args (tree decl);
extern bool arc_short_comparison_p (rtx, int);
extern bool arc_epilogue_uses (int regno);
/* insn-attrtab.c doesn't include reload.h, which declares regno_clobbered_p. */
extern int regno_clobbered_p (unsigned int, rtx_insn *, enum machine_mode, int);
extern int regno_clobbered_p (unsigned int, rtx_insn *, machine_mode, int);
extern int arc_return_slot_offset (void);
extern bool arc_legitimize_reload_address (rtx *, enum machine_mode, int, int);
extern bool arc_legitimize_reload_address (rtx *, machine_mode, int, int);

98
gcc/config/arc/arc.c
View File

@ -385,16 +385,16 @@ static void arc_file_start (void);
static void arc_internal_label (FILE *, const char *, unsigned long);
static void arc_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
tree);
static int arc_address_cost (rtx, enum machine_mode, addr_space_t, bool);
static int arc_address_cost (rtx, machine_mode, addr_space_t, bool);
static void arc_encode_section_info (tree decl, rtx rtl, int first);
static void arc_init_builtins (void);
static rtx arc_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
static rtx arc_expand_builtin (tree, rtx, rtx, machine_mode, int);
static int branch_dest (rtx);
static void arc_output_pic_addr_const (FILE *, rtx, int);
void emit_pic_move (rtx *, enum machine_mode);
void emit_pic_move (rtx *, machine_mode);
bool arc_legitimate_pic_operand_p (rtx);
static bool arc_function_ok_for_sibcall (tree, tree);
static rtx arc_function_value (const_tree, const_tree, bool);
@ -405,7 +405,7 @@ static bool arc_in_small_data_p (const_tree);
static void arc_init_reg_tables (void);
static bool arc_return_in_memory (const_tree, const_tree);
static void arc_init_simd_builtins (void);
static bool arc_vector_mode_supported_p (enum machine_mode);
static bool arc_vector_mode_supported_p (machine_mode);
static bool arc_can_use_doloop_p (const widest_int &, const widest_int &,
unsigned int, bool);
@ -418,7 +418,7 @@ static bool arc_frame_pointer_required (void);
/* Implements target hook vector_mode_supported_p. */
static bool
arc_vector_mode_supported_p (enum machine_mode mode)
arc_vector_mode_supported_p (machine_mode mode)
{
if (!TARGET_SIMD_SET)
return false;
@ -438,9 +438,9 @@ static bool arc_can_follow_jump (const rtx_insn *follower,
const rtx_insn *followee);
static rtx frame_insn (rtx);
static void arc_function_arg_advance (cumulative_args_t, enum machine_mode,
static void arc_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx arc_legitimize_address_0 (rtx, rtx, enum machine_mode mode);
static rtx arc_legitimize_address_0 (rtx, rtx, machine_mode mode);
static void arc_finalize_pic (void);
@ -602,7 +602,7 @@ arc_sched_adjust_priority (rtx_insn *insn, int priority)
}
static reg_class_t
arc_secondary_reload (bool in_p, rtx x, reg_class_t cl, enum machine_mode,
arc_secondary_reload (bool in_p, rtx x, reg_class_t cl, machine_mode,
secondary_reload_info *)
{
if (cl == DOUBLE_REGS)
@ -996,10 +996,10 @@ arc_short_comparison_p (rtx comparison, int offset)
/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
return the mode to be used for the comparison. */
enum machine_mode
machine_mode
arc_select_cc_mode (enum rtx_code op, rtx x, rtx y)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
rtx x1;
/* For an operation that sets the condition codes as a side-effect, the
@ -1150,7 +1150,7 @@ arc_init_reg_tables (void)
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
enum machine_mode m = (enum machine_mode) i;
machine_mode m = (machine_mode) i;
switch (GET_MODE_CLASS (m))
{
@ -1490,13 +1490,13 @@ arc_set_default_type_attributes (tree type ATTRIBUTE_UNUSED)
return the rtx for the cc reg in the proper mode. */
rtx
gen_compare_reg (rtx comparison, enum machine_mode omode)
gen_compare_reg (rtx comparison, machine_mode omode)
{
enum rtx_code code = GET_CODE (comparison);
rtx x = XEXP (comparison, 0);
rtx y = XEXP (comparison, 1);
rtx tmp, cc_reg;
enum machine_mode mode, cmode;
machine_mode mode, cmode;
cmode = GET_MODE (x);
@ -1641,7 +1641,7 @@ arc_double_limm_p (rtx value)
static void
arc_setup_incoming_varargs (cumulative_args_t args_so_far,
enum machine_mode mode, tree type,
machine_mode mode, tree type,
int *pretend_size, int no_rtl)
{
int first_anon_arg;
@ -1680,7 +1680,7 @@ arc_setup_incoming_varargs (cumulative_args_t args_so_far,
If ADDR is not a valid address, its cost is irrelevant. */
int
arc_address_cost (rtx addr, enum machine_mode, addr_space_t, bool speed)
arc_address_cost (rtx addr, machine_mode, addr_space_t, bool speed)
{
switch (GET_CODE (addr))
{
@ -2564,7 +2564,7 @@ output_shift (rtx *operands)
{
/* static int loopend_lab;*/
rtx shift = operands[3];
enum machine_mode mode = GET_MODE (shift);
machine_mode mode = GET_MODE (shift);
enum rtx_code code = GET_CODE (shift);
const char *shift_one;
@ -4712,7 +4712,7 @@ arc_output_pic_addr_const (FILE * file, rtx x, int code)
/* Emit insns to move operands[1] into operands[0]. */
void
emit_pic_move (rtx *operands, enum machine_mode)
emit_pic_move (rtx *operands, machine_mode)
{
rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
@ -4754,7 +4754,7 @@ emit_pic_move (rtx *operands, enum machine_mode)
/* Implement TARGET_ARG_PARTIAL_BYTES. */
static int
arc_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
arc_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -4812,7 +4812,7 @@ arc_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
and the rest are pushed. */
static rtx
arc_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
arc_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -4859,7 +4859,7 @@ arc_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
course function_arg_partial_nregs will come into play. */
static void
arc_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
arc_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -4885,7 +4885,7 @@ arc_function_value (const_tree valtype,
const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
bool outgoing ATTRIBUTE_UNUSED)
{
enum machine_mode mode = TYPE_MODE (valtype);
machine_mode mode = TYPE_MODE (valtype);
int unsignedp ATTRIBUTE_UNUSED;
unsignedp = TYPE_UNSIGNED (valtype);
@ -4919,7 +4919,7 @@ arc_legitimate_pic_operand_p (rtx x)
satisfies CONSTANT_P. */
bool
arc_legitimate_constant_p (enum machine_mode, rtx x)
arc_legitimate_constant_p (machine_mode, rtx x)
{
if (!flag_pic)
return true;
@ -4970,7 +4970,7 @@ arc_legitimate_constant_p (enum machine_mode, rtx x)
}
static bool
arc_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
arc_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
if (RTX_OK_FOR_BASE_P (x, strict))
return true;
@ -5026,7 +5026,7 @@ arc_mode_dependent_address_p (const_rtx addr, addr_space_t)
/* Determine if it's legal to put X into the constant pool. */
static bool
arc_cannot_force_const_mem (enum machine_mode mode, rtx x)
arc_cannot_force_const_mem (machine_mode mode, rtx x)
{
return !arc_legitimate_constant_p (mode, x);
}
@ -5115,7 +5115,7 @@ arc_init_builtins (void)
arc_init_simd_builtins ();
}
static rtx arc_expand_simd_builtin (tree, rtx, rtx, enum machine_mode, int);
static rtx arc_expand_simd_builtin (tree, rtx, rtx, machine_mode, int);
/* Expand an expression EXP that calls a built-in function,
with result going to TARGET if that's convenient
@ -5127,7 +5127,7 @@ static rtx
arc_expand_builtin (tree exp,
rtx target,
rtx subtarget,
enum machine_mode mode,
machine_mode mode,
int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
@ -5137,8 +5137,8 @@ arc_expand_builtin (tree exp,
rtx op1;
int fcode = DECL_FUNCTION_CODE (fndecl);
int icode;
enum machine_mode mode0;
enum machine_mode mode1;
machine_mode mode0;
machine_mode mode1;
if (fcode > ARC_SIMD_BUILTIN_BEGIN && fcode < ARC_SIMD_BUILTIN_END)
return arc_expand_simd_builtin (exp, target, subtarget, mode, ignore);
@ -5705,7 +5705,7 @@ walk_stores (rtx x, void (*fun) (rtx, rtx, void *), void *data)
static bool
arc_pass_by_reference (cumulative_args_t ca_v ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type,
bool named ATTRIBUTE_UNUSED)
{
@ -6419,7 +6419,7 @@ small_data_pattern_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
a PLUS. */
bool
small_data_pattern (rtx op, enum machine_mode)
small_data_pattern (rtx op, machine_mode)
{
return (GET_CODE (op) != SEQUENCE
&& for_each_rtx (&op, small_data_pattern_1, 0));
@ -6433,7 +6433,7 @@ small_data_pattern (rtx op, enum machine_mode)
/* volatile cache option still to be handled. */
bool
compact_sda_memory_operand (rtx op, enum machine_mode mode)
compact_sda_memory_operand (rtx op, machine_mode mode)
{
rtx addr;
int size;
@ -6837,7 +6837,7 @@ static rtx
arc_expand_simd_builtin (tree exp,
rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
@ -6854,11 +6854,11 @@ arc_expand_simd_builtin (tree exp,
unsigned int i;
int fcode = DECL_FUNCTION_CODE (fndecl);
int icode;
enum machine_mode mode0;
enum machine_mode mode1;
enum machine_mode mode2;
enum machine_mode mode3;
enum machine_mode mode4;
machine_mode mode0;
machine_mode mode1;
machine_mode mode2;
machine_mode mode3;
machine_mode mode4;
const struct builtin_description * d;
for (i = 0, d = arc_simd_builtin_desc_list;
@ -7298,7 +7298,7 @@ arc_preserve_reload_p (rtx in)
}
int
arc_register_move_cost (enum machine_mode,
arc_register_move_cost (machine_mode,
enum reg_class from_class, enum reg_class to_class)
{
/* The ARC600 has no bypass for extension registers, hence a nop might be
@ -7545,7 +7545,7 @@ arc_expand_movmem (rtx *operands)
for (i = 0; size > 0; i ^= 1, size -= piece)
{
rtx tmp;
enum machine_mode mode;
machine_mode mode;
if (piece > size)
piece = size & -size;
@ -7576,7 +7576,7 @@ arc_expand_movmem (rtx *operands)
been emitted. */
bool
prepare_move_operands (rtx *operands, enum machine_mode mode)
prepare_move_operands (rtx *operands, machine_mode mode)
{
/* We used to do this only for MODE_INT Modes, but addresses to floating
point variables may well be in the small data section. */
@ -7664,7 +7664,7 @@ prepare_move_operands (rtx *operands, enum machine_mode mode)
bool
prepare_extend_operands (rtx *operands, enum rtx_code code,
enum machine_mode omode)
machine_mode omode)
{
if (!TARGET_NO_SDATA_SET && small_data_pattern (operands[1], Pmode))
{
@ -8187,7 +8187,7 @@ arc_get_ccfsm_cond (struct arc_ccfsm *statep, bool reverse)
gcc_assert (ARC_INVERSE_CONDITION_CODE (raw_cc) == statep->cc);
enum machine_mode ccm = GET_MODE (XEXP (cond, 0));
machine_mode ccm = GET_MODE (XEXP (cond, 0));
enum rtx_code code = reverse_condition (GET_CODE (cond));
if (code == UNKNOWN || ccm == CC_FP_GTmode || ccm == CC_FP_GEmode)
code = reverse_condition_maybe_unordered (GET_CODE (cond));
@ -8420,7 +8420,7 @@ arc_predicate_delay_insns (void)
gcc_unreachable ();
if (reverse != !INSN_FROM_TARGET_P (dlay))
{
enum machine_mode ccm = GET_MODE (XEXP (cond, 0));
machine_mode ccm = GET_MODE (XEXP (cond, 0));
enum rtx_code code = reverse_condition (GET_CODE (cond));
if (code == UNKNOWN || ccm == CC_FP_GTmode || ccm == CC_FP_GEmode)
code = reverse_condition_maybe_unordered (GET_CODE (cond));
@ -8484,7 +8484,7 @@ arc_write_ext_corereg (rtx insn)
static rtx
arc_legitimize_address_0 (rtx x, rtx oldx ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
rtx addr, inner;
@ -8515,13 +8515,13 @@ arc_legitimize_address_0 (rtx x, rtx oldx ATTRIBUTE_UNUSED,
}
else if (GET_CODE (addr) == SYMBOL_REF && !SYMBOL_REF_FUNCTION_P (addr))
x = force_reg (Pmode, x);
if (memory_address_p ((enum machine_mode) mode, x))
if (memory_address_p ((machine_mode) mode, x))
return x;
return NULL_RTX;
}
static rtx
arc_legitimize_address (rtx orig_x, rtx oldx, enum machine_mode mode)
arc_legitimize_address (rtx orig_x, rtx oldx, machine_mode mode)
{
rtx new_x = arc_legitimize_address_0 (orig_x, oldx, mode);
@ -8975,7 +8975,7 @@ arc_process_double_reg_moves (rtx *operands)
rtx
arc_split_move (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
int i;
int swap = 0;
rtx xop[4];
@ -9310,13 +9310,13 @@ arc_register_priority (int r)
}
static reg_class_t
arc_spill_class (reg_class_t /* orig_class */, enum machine_mode)
arc_spill_class (reg_class_t /* orig_class */, machine_mode)
{
return GENERAL_REGS;
}
bool
arc_legitimize_reload_address (rtx *p, enum machine_mode mode, int opnum,
arc_legitimize_reload_address (rtx *p, machine_mode mode, int opnum,
int itype)
{
rtx x = *p;

2
gcc/config/arc/arc.h
View File

@ -1057,7 +1057,7 @@ extern int arc_initial_elimination_offset(int from, int to);
/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
return the mode to be used for the comparison. */
/*extern enum machine_mode arc_select_cc_mode ();*/
/*extern machine_mode arc_select_cc_mode ();*/
#define SELECT_CC_MODE(OP, X, Y) \
arc_select_cc_mode (OP, X, Y)

2
gcc/config/arc/predicates.md
View File

@ -585,7 +585,7 @@
(define_special_predicate "cc_set_register"
(match_code "reg")
{
enum machine_mode rmode = GET_MODE (op);
machine_mode rmode = GET_MODE (op);
if (mode == VOIDmode)
{

4
gcc/config/arm/aarch-common-protos.h
View File

@ -25,8 +25,8 @@
extern int aarch_crypto_can_dual_issue (rtx_insn *, rtx_insn *);
extern bool aarch_rev16_p (rtx);
extern bool aarch_rev16_shleft_mask_imm_p (rtx, enum machine_mode);
extern bool aarch_rev16_shright_mask_imm_p (rtx, enum machine_mode);
extern bool aarch_rev16_shleft_mask_imm_p (rtx, machine_mode);
extern bool aarch_rev16_shright_mask_imm_p (rtx, machine_mode);
extern int arm_early_load_addr_dep (rtx, rtx);
extern int arm_early_store_addr_dep (rtx, rtx);
extern int arm_mac_accumulator_is_mul_result (rtx, rtx);

6
gcc/config/arm/aarch-common.c
View File

@ -193,7 +193,7 @@ arm_get_set_operands (rtx producer, rtx consumer,
}
bool
aarch_rev16_shright_mask_imm_p (rtx val, enum machine_mode mode)
aarch_rev16_shright_mask_imm_p (rtx val, machine_mode mode)
{
return CONST_INT_P (val)
&& INTVAL (val)
@ -202,7 +202,7 @@ aarch_rev16_shright_mask_imm_p (rtx val, enum machine_mode mode)
}
bool
aarch_rev16_shleft_mask_imm_p (rtx val, enum machine_mode mode)
aarch_rev16_shleft_mask_imm_p (rtx val, machine_mode mode)
{
return CONST_INT_P (val)
&& INTVAL (val)
@ -212,7 +212,7 @@ aarch_rev16_shleft_mask_imm_p (rtx val, enum machine_mode mode)
static bool
aarch_rev16_p_1 (rtx lhs, rtx rhs, enum machine_mode mode)
aarch_rev16_p_1 (rtx lhs, rtx rhs, machine_mode mode)
{
if (GET_CODE (lhs) == AND
&& GET_CODE (XEXP (lhs, 0)) == ASHIFT

54
gcc/config/arm/arm-protos.h
View File

@ -44,54 +44,54 @@ extern void arm_output_fn_unwind (FILE *, bool);
#ifdef RTX_CODE
extern bool arm_vector_mode_supported_p (enum machine_mode);
extern bool arm_small_register_classes_for_mode_p (enum machine_mode);
extern int arm_hard_regno_mode_ok (unsigned int, enum machine_mode);
extern bool arm_modes_tieable_p (enum machine_mode, enum machine_mode);
extern bool arm_vector_mode_supported_p (machine_mode);
extern bool arm_small_register_classes_for_mode_p (machine_mode);
extern int arm_hard_regno_mode_ok (unsigned int, machine_mode);
extern bool arm_modes_tieable_p (machine_mode, machine_mode);
extern int const_ok_for_arm (HOST_WIDE_INT);
extern int const_ok_for_op (HOST_WIDE_INT, enum rtx_code);
extern int const_ok_for_dimode_op (HOST_WIDE_INT, enum rtx_code);
extern int arm_split_constant (RTX_CODE, enum machine_mode, rtx,
extern int arm_split_constant (RTX_CODE, machine_mode, rtx,
HOST_WIDE_INT, rtx, rtx, int);
extern int legitimate_pic_operand_p (rtx);
extern rtx legitimize_pic_address (rtx, enum machine_mode, rtx);
extern rtx legitimize_pic_address (rtx, machine_mode, rtx);
extern rtx legitimize_tls_address (rtx, rtx);
extern bool arm_legitimate_address_p (enum machine_mode, rtx, bool);
extern int arm_legitimate_address_outer_p (enum machine_mode, rtx, RTX_CODE, int);
extern int thumb_legitimate_offset_p (enum machine_mode, HOST_WIDE_INT);
extern bool arm_legitimize_reload_address (rtx *, enum machine_mode, int, int,
extern bool arm_legitimate_address_p (machine_mode, rtx, bool);
extern int arm_legitimate_address_outer_p (machine_mode, rtx, RTX_CODE, int);
extern int thumb_legitimate_offset_p (machine_mode, HOST_WIDE_INT);
extern bool arm_legitimize_reload_address (rtx *, machine_mode, int, int,
int);
extern rtx thumb_legitimize_reload_address (rtx *, enum machine_mode, int, int,
extern rtx thumb_legitimize_reload_address (rtx *, machine_mode, int, int,
int);
extern int thumb1_legitimate_address_p (enum machine_mode, rtx, int);
extern bool ldm_stm_operation_p (rtx, bool, enum machine_mode mode,
extern int thumb1_legitimate_address_p (machine_mode, rtx, int);
extern bool ldm_stm_operation_p (rtx, bool, machine_mode mode,
bool, bool);
extern int arm_const_double_rtx (rtx);
extern int vfp3_const_double_rtx (rtx);
extern int neon_immediate_valid_for_move (rtx, enum machine_mode, rtx *, int *);
extern int neon_immediate_valid_for_logic (rtx, enum machine_mode, int, rtx *,
extern int neon_immediate_valid_for_move (rtx, machine_mode, rtx *, int *);
extern int neon_immediate_valid_for_logic (rtx, machine_mode, int, rtx *,
int *);
extern int neon_immediate_valid_for_shift (rtx, enum machine_mode, rtx *,
extern int neon_immediate_valid_for_shift (rtx, machine_mode, rtx *,
int *, bool);
extern char *neon_output_logic_immediate (const char *, rtx *,
enum machine_mode, int, int);
machine_mode, int, int);
extern char *neon_output_shift_immediate (const char *, char, rtx *,
enum machine_mode, int, bool);
extern void neon_pairwise_reduce (rtx, rtx, enum machine_mode,
machine_mode, int, bool);
extern void neon_pairwise_reduce (rtx, rtx, machine_mode,
rtx (*) (rtx, rtx, rtx));
extern rtx neon_make_constant (rtx);
extern tree arm_builtin_vectorized_function (tree, tree, tree);
extern void neon_expand_vector_init (rtx, rtx);
extern void neon_lane_bounds (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
extern void neon_const_bounds (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
extern HOST_WIDE_INT neon_element_bits (enum machine_mode);
extern HOST_WIDE_INT neon_element_bits (machine_mode);
extern void neon_reinterpret (rtx, rtx);
extern void neon_emit_pair_result_insn (enum machine_mode,
extern void neon_emit_pair_result_insn (machine_mode,
rtx (*) (rtx, rtx, rtx, rtx),
rtx, rtx, rtx);
extern void neon_disambiguate_copy (rtx *, rtx *, rtx *, unsigned int);
extern void neon_split_vcombine (rtx op[3]);
extern enum reg_class coproc_secondary_reload_class (enum machine_mode, rtx,
extern enum reg_class coproc_secondary_reload_class (machine_mode, rtx,
bool);
extern bool arm_tls_referenced_p (rtx);
@ -115,8 +115,8 @@ extern bool operands_ok_ldrd_strd (rtx, rtx, rtx, HOST_WIDE_INT, bool, bool);
extern bool gen_operands_ldrd_strd (rtx *, bool, bool, bool);
extern int arm_gen_movmemqi (rtx *);
extern bool gen_movmem_ldrd_strd (rtx *);
extern enum machine_mode arm_select_cc_mode (RTX_CODE, rtx, rtx);
extern enum machine_mode arm_select_dominance_cc_mode (rtx, rtx,
extern machine_mode arm_select_cc_mode (RTX_CODE, rtx, rtx);
extern machine_mode arm_select_dominance_cc_mode (rtx, rtx,
HOST_WIDE_INT);
extern rtx arm_gen_compare_reg (RTX_CODE, rtx, rtx, rtx);
extern rtx arm_gen_return_addr_mask (void);
@ -165,8 +165,8 @@ extern rtx arm_load_tp (rtx);
#if defined TREE_CODE
extern void arm_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree);
extern bool arm_pad_arg_upward (enum machine_mode, const_tree);
extern bool arm_pad_reg_upward (enum machine_mode, tree, int);
extern bool arm_pad_arg_upward (machine_mode, const_tree);
extern bool arm_pad_reg_upward (machine_mode, tree, int);
#endif
extern int arm_apply_result_size (void);
@ -297,7 +297,7 @@ extern bool arm_gen_setmem (rtx *);
extern void arm_expand_vec_perm (rtx target, rtx op0, rtx op1, rtx sel);
extern bool arm_expand_vec_perm_const (rtx target, rtx op0, rtx op1, rtx sel);
extern bool arm_autoinc_modes_ok_p (enum machine_mode, enum arm_auto_incmodes);
extern bool arm_autoinc_modes_ok_p (machine_mode, enum arm_auto_incmodes);
extern void arm_emit_eabi_attribute (const char *, int, int);

406
gcc/config/arm/arm.c
View File

File diff suppressed because it is too large Load Diff

6
gcc/config/arm/arm.h
View File

@ -29,14 +29,14 @@
#ifndef GCC_ARM_H
#define GCC_ARM_H
/* We can't use enum machine_mode inside a generator file because it
/* We can't use machine_mode inside a generator file because it
hasn't been created yet; we shouldn't be using any code that
needs the real definition though, so this ought to be safe. */
#ifdef GENERATOR_FILE
#define MACHMODE int
#else
#include "insn-modes.h"
#define MACHMODE enum machine_mode
#define MACHMODE machine_mode
#endif
#include "config/vxworks-dummy.h"
@ -1547,7 +1547,7 @@ typedef struct GTY(()) machine_function
rtx thumb1_cc_op0;
rtx thumb1_cc_op1;
/* Also record the CC mode that is supported. */
enum machine_mode thumb1_cc_mode;
machine_mode thumb1_cc_mode;
/* Set to 1 after arm_reorg has started. */
int after_arm_reorg;
}

24
gcc/config/arm/arm.md
View File

@ -3538,7 +3538,7 @@
(set (match_dup 0)
(match_dup 6)))]
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
enum rtx_code rc = minmax_code (operands[4]);
operands[4] = gen_rtx_fmt_ee (rc, VOIDmode,
@ -4876,7 +4876,7 @@
[(set (match_dup 0) (match_dup 1))]
{
rtx lo_part = gen_lowpart (SImode, operands[0]);
enum machine_mode src_mode = GET_MODE (operands[1]);
machine_mode src_mode = GET_MODE (operands[1]);
if (REG_P (operands[0])
&& !reg_overlap_mentioned_p (operands[0], operands[1]))
@ -4902,7 +4902,7 @@
[(set (match_dup 0) (ashiftrt:SI (match_dup 1) (const_int 31)))]
{
rtx lo_part = gen_lowpart (SImode, operands[0]);
enum machine_mode src_mode = GET_MODE (operands[1]);
machine_mode src_mode = GET_MODE (operands[1]);
if (REG_P (operands[0])
&& !reg_overlap_mentioned_p (operands[0], operands[1]))
@ -7453,7 +7453,7 @@
[(const_int 0)]
{
enum rtx_code rev_code;
enum machine_mode mode;
machine_mode mode;
rtx rev_cond;
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
@ -8383,7 +8383,7 @@
(cond_exec (match_dup 4) (set (match_dup 0)
(and:SI (match_dup 3) (const_int 1))))]
{
enum machine_mode mode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[2]);
enum rtx_code rc = GET_CODE (operands[1]);
/* Note that operands[4] is the same as operands[1],
@ -8417,7 +8417,7 @@
(cond_exec (match_dup 4) (set (match_dup 0)
(ior:SI (match_dup 3) (const_int 1))))]
{
enum machine_mode mode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[2]);
enum rtx_code rc = GET_CODE (operands[1]);
/* Note that operands[4] is the same as operands[1],
@ -8521,7 +8521,7 @@
(cond_exec (match_dup 5) (set (match_dup 0) (const_int 1)))]
{
rtx tmp1;
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
enum rtx_code rc = GET_CODE (operands[1]);
@ -9325,7 +9325,7 @@
(set (match_dup 0) (match_dup 2)))]
"
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[5]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[5]),
operands[3], operands[4]);
enum rtx_code rc = GET_CODE (operands[5]);
operands[6] = gen_rtx_REG (mode, CC_REGNUM);
@ -10221,7 +10221,7 @@
(set (match_dup 0) (match_dup 4)))]
"
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
enum rtx_code rc = GET_CODE (operands[1]);
@ -10249,7 +10249,7 @@
(set (match_dup 0) (match_dup 4)))]
"
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
operands[5] = gen_rtx_REG (mode, CC_REGNUM);
@ -10272,7 +10272,7 @@
(set (match_dup 0) (match_dup 5)))]
"
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
enum rtx_code rc = GET_CODE (operands[1]);
@ -10304,7 +10304,7 @@
(set (match_dup 0) (not:SI (match_dup 5))))]
"
{
enum machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
machine_mode mode = SELECT_CC_MODE (GET_CODE (operands[1]),
operands[2], operands[3]);
enum rtx_code rc = GET_CODE (operands[1]);

4
gcc/config/arm/neon.md
View File

@ -1210,7 +1210,7 @@
rtx zero_reg;
HOST_WIDE_INT num_bits = INTVAL (operands[2]);
const int width = GET_MODE_BITSIZE (<MODE>mode);
const enum machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
const machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
rtx (*gen_ext) (rtx, rtx, rtx, rtx) =
(width == 128) ? gen_neon_vextv16qi : gen_neon_vextv8qi;
@ -1238,7 +1238,7 @@
rtx zero_reg;
HOST_WIDE_INT num_bits = INTVAL (operands[2]);
const int width = GET_MODE_BITSIZE (<MODE>mode);
const enum machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
const machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
rtx (*gen_ext) (rtx, rtx, rtx, rtx) =
(width == 128) ? gen_neon_vextv16qi : gen_neon_vextv8qi;

10
gcc/config/arm/thumb2.md
View File

@ -416,7 +416,7 @@
(const_int 0)))]
{
operands[3] = GEN_INT (~0);
enum machine_mode mode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[2]);
enum rtx_code rc = GET_CODE (operands[1]);
if (mode == CCFPmode || mode == CCFPEmode)
@ -503,7 +503,7 @@
[(const_int 0)]
{
enum rtx_code rev_code;
enum machine_mode mode;
machine_mode mode;
rtx rev_cond;
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
@ -595,7 +595,7 @@
(and:SI (match_dup 3) (const_int 1)))
(cond_exec (match_dup 4) (set (match_dup 0) (const_int 0)))]
{
enum machine_mode mode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[2]);
enum rtx_code rc = GET_CODE (operands[1]);
if (mode == CCFPmode || mode == CCFPEmode)
@ -627,7 +627,7 @@
(cond_exec (match_dup 4) (set (match_dup 0)
(ior:SI (match_dup 3) (const_int 1))))]
{
enum machine_mode mode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[2]);
enum rtx_code rc = GET_CODE (operands[1]);
operands[4] = gen_rtx_fmt_ee (rc, VOIDmode, operands[2], const0_rtx);
@ -891,7 +891,7 @@
{
/* Emit: cmp\\t%1, %2\;mvn\\t%0, #0\;it\\t%D3\;mov%D3\\t%0, #0\;*/
enum rtx_code rc = reverse_condition (GET_CODE (operands[3]));
enum machine_mode mode = SELECT_CC_MODE (rc, operands[1], operands[2]);
machine_mode mode = SELECT_CC_MODE (rc, operands[1], operands[2]);
rtx tmp1 = gen_rtx_REG (mode, CC_REGNUM);
emit_insn (gen_rtx_SET (VOIDmode,

4
gcc/config/avr/avr-log.c
View File

@ -53,7 +53,7 @@
t: tree
T: tree (brief)
C: enum rtx_code
m: enum machine_mode
m: machine_mode
R: enum reg_class
L: insn list
H: location_t
@ -238,7 +238,7 @@ avr_log_vadump (FILE *file, const char *fmt, va_list ap)
break;
case 'm':
fputs (GET_MODE_NAME ((enum machine_mode) va_arg (ap, int)),
fputs (GET_MODE_NAME ((machine_mode) va_arg (ap, int)),
file);
break;

16
gcc/config/avr/avr-protos.h
View File

@ -45,8 +45,8 @@ extern void avr_init_cumulative_args (CUMULATIVE_ARGS*, tree, rtx, tree);
#endif /* TREE_CODE */
#ifdef RTX_CODE
extern int avr_hard_regno_call_part_clobbered (unsigned, enum machine_mode);
extern bool tiny_valid_direct_memory_access_range(rtx, enum machine_mode);
extern int avr_hard_regno_call_part_clobbered (unsigned, machine_mode);
extern bool tiny_valid_direct_memory_access_range(rtx, machine_mode);
extern const char *output_movqi (rtx_insn *insn, rtx operands[], int *l);
extern const char *output_movhi (rtx_insn *insn, rtx operands[], int *l);
extern const char *output_movsisf (rtx_insn *insn, rtx operands[], int *l);
@ -111,22 +111,22 @@ extern int avr_jump_mode (rtx x, rtx_insn *insn);
extern int test_hard_reg_class (enum reg_class rclass, rtx x);
extern int jump_over_one_insn_p (rtx_insn *insn, rtx dest);
extern int avr_hard_regno_mode_ok (int regno, enum machine_mode mode);
extern int avr_hard_regno_mode_ok (int regno, machine_mode mode);
extern void avr_final_prescan_insn (rtx_insn *insn, rtx *operand,
int num_operands);
extern int avr_simplify_comparison_p (enum machine_mode mode,
extern int avr_simplify_comparison_p (machine_mode mode,
RTX_CODE op, rtx x);
extern RTX_CODE avr_normalize_condition (RTX_CODE condition);
extern void out_shift_with_cnt (const char *templ, rtx_insn *insn,
rtx operands[], int *len, int t_len);
extern enum reg_class avr_mode_code_base_reg_class (enum machine_mode, addr_space_t, RTX_CODE, RTX_CODE);
extern bool avr_regno_mode_code_ok_for_base_p (int, enum machine_mode, addr_space_t, RTX_CODE, RTX_CODE);
extern enum reg_class avr_mode_code_base_reg_class (machine_mode, addr_space_t, RTX_CODE, RTX_CODE);
extern bool avr_regno_mode_code_ok_for_base_p (int, machine_mode, addr_space_t, RTX_CODE, RTX_CODE);
extern rtx avr_incoming_return_addr_rtx (void);
extern rtx avr_legitimize_reload_address (rtx*, enum machine_mode, int, int, int, int, rtx (*)(rtx,int));
extern rtx avr_legitimize_reload_address (rtx*, machine_mode, int, int, int, int, rtx (*)(rtx,int));
extern bool avr_mem_flash_p (rtx);
extern bool avr_mem_memx_p (rtx);
extern bool avr_load_libgcc_p (rtx);
extern bool avr_xload_libgcc_p (enum machine_mode);
extern bool avr_xload_libgcc_p (machine_mode);
extern rtx avr_eval_addr_attrib (rtx x);
extern rtx lpm_reg_rtx;

106
gcc/config/avr/avr.c
View File

@ -161,8 +161,8 @@ static int get_sequence_length (rtx_insn *insns);
static int sequent_regs_live (void);
static const char *ptrreg_to_str (int);
static const char *cond_string (enum rtx_code);
static int avr_num_arg_regs (enum machine_mode, const_tree);
static int avr_operand_rtx_cost (rtx, enum machine_mode, enum rtx_code,
static int avr_num_arg_regs (machine_mode, const_tree);
static int avr_operand_rtx_cost (rtx, machine_mode, enum rtx_code,
int, bool);
static void output_reload_in_const (rtx*, rtx, int*, bool);
static struct machine_function * avr_init_machine_status (void);
@ -283,7 +283,7 @@ avr_popcount_each_byte (rtx xval, int n_bytes, int pop_mask)
{
int i;
enum machine_mode mode = GET_MODE (xval);
machine_mode mode = GET_MODE (xval);
if (VOIDmode == mode)
mode = SImode;
@ -307,7 +307,7 @@ avr_popcount_each_byte (rtx xval, int n_bytes, int pop_mask)
rtx
avr_to_int_mode (rtx x)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
return VOIDmode == mode
? x
@ -480,7 +480,7 @@ avr_regno_reg_class (int r)
/* Implement `TARGET_SCALAR_MODE_SUPPORTED_P'. */
static bool
avr_scalar_mode_supported_p (enum machine_mode mode)
avr_scalar_mode_supported_p (machine_mode mode)
{
if (ALL_FIXED_POINT_MODE_P (mode))
return true;
@ -832,7 +832,7 @@ avr_initial_elimination_offset (int from, int to)
/* Helper for the function below. */
static void
avr_adjust_type_node (tree *node, enum machine_mode mode, int sat_p)
avr_adjust_type_node (tree *node, machine_mode mode, int sat_p)
{
*node = make_node (FIXED_POINT_TYPE);
TYPE_SATURATING (*node) = sat_p;
@ -1749,7 +1749,7 @@ avr_reg_ok_for_addr_p (rtx reg, addr_space_t as,
machine for a memory operand of mode MODE. */
static bool
avr_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
avr_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
bool ok = CONSTANT_ADDRESS_P (x);
@ -1839,7 +1839,7 @@ avr_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
memory address for an operand of mode MODE */
static rtx
avr_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
avr_legitimize_address (rtx x, rtx oldx, machine_mode mode)
{
bool big_offset_p = false;
@ -1880,7 +1880,7 @@ avr_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
than 63 bytes or for R++ or --R addressing. */
rtx
avr_legitimize_reload_address (rtx *px, enum machine_mode mode,
avr_legitimize_reload_address (rtx *px, machine_mode mode,
int opnum, int type, int addr_type,
int ind_levels ATTRIBUTE_UNUSED,
rtx (*mk_memloc)(rtx,int))
@ -1962,7 +1962,7 @@ avr_legitimize_reload_address (rtx *px, enum machine_mode mode,
static reg_class_t
avr_secondary_reload (bool in_p, rtx x,
reg_class_t reload_class ATTRIBUTE_UNUSED,
enum machine_mode mode, secondary_reload_info *sri)
machine_mode mode, secondary_reload_info *sri)
{
if (in_p
&& MEM_P (x)
@ -2621,7 +2621,7 @@ avr_final_prescan_insn (rtx_insn *insn, rtx *operand ATTRIBUTE_UNUSED,
/* Return 0 if undefined, 1 if always true or always false. */
int
avr_simplify_comparison_p (enum machine_mode mode, RTX_CODE op, rtx x)
avr_simplify_comparison_p (machine_mode mode, RTX_CODE op, rtx x)
{
unsigned int max = (mode == QImode ? 0xff :
mode == HImode ? 0xffff :
@ -2672,7 +2672,7 @@ avr_init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname,
/* Returns the number of registers to allocate for a function argument. */
static int
avr_num_arg_regs (enum machine_mode mode, const_tree type)
avr_num_arg_regs (machine_mode mode, const_tree type)
{
int size;
@ -2693,7 +2693,7 @@ avr_num_arg_regs (enum machine_mode mode, const_tree type)
in a register, and which register. */
static rtx
avr_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
avr_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -2711,7 +2711,7 @@ avr_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
in the argument list. */
static void
avr_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
avr_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -2827,7 +2827,7 @@ avr_function_ok_for_sibcall (tree decl_callee, tree exp_callee)
bool
avr_load_libgcc_p (rtx op)
{
enum machine_mode mode = GET_MODE (op);
machine_mode mode = GET_MODE (op);
int n_bytes = GET_MODE_SIZE (mode);
return (n_bytes > 2
@ -2838,7 +2838,7 @@ avr_load_libgcc_p (rtx op)
/* Return true if a value of mode MODE is read by __xload_* function. */
bool
avr_xload_libgcc_p (enum machine_mode mode)
avr_xload_libgcc_p (machine_mode mode)
{
int n_bytes = GET_MODE_SIZE (mode);
@ -3204,7 +3204,7 @@ avr_out_xload (rtx_insn *insn ATTRIBUTE_UNUSED, rtx *op, int *plen)
IN / OUT instruction will be generated. */
bool
tiny_valid_direct_memory_access_range (rtx op, enum machine_mode mode)
tiny_valid_direct_memory_access_range (rtx op, machine_mode mode)
{
rtx x;
@ -5218,7 +5218,7 @@ avr_out_compare (rtx_insn *insn, rtx *xop, int *plen)
rtx xval = xop[1];
/* MODE of the comparison. */
enum machine_mode mode;
machine_mode mode;
/* Number of bytes to operate on. */
int i, n_bytes = GET_MODE_SIZE (GET_MODE (xreg));
@ -7007,10 +7007,10 @@ avr_out_plus_1 (rtx *xop, int *plen, enum rtx_code code, int *pcc,
enum rtx_code code_sat, int sign, bool out_label)
{
/* MODE of the operation. */
enum machine_mode mode = GET_MODE (xop[0]);
machine_mode mode = GET_MODE (xop[0]);
/* INT_MODE of the same size. */
enum machine_mode imode = int_mode_for_mode (mode);
machine_mode imode = int_mode_for_mode (mode);
/* Number of bytes to operate on. */
int i, n_bytes = GET_MODE_SIZE (mode);
@ -7461,7 +7461,7 @@ avr_out_plus_1 (rtx *xop, int *plen, enum rtx_code code, int *pcc,
static const char*
avr_out_plus_symbol (rtx *xop, enum rtx_code code, int *plen, int *pcc)
{
enum machine_mode mode = GET_MODE (xop[0]);
machine_mode mode = GET_MODE (xop[0]);
/* Only pointer modes want to add symbols. */
@ -7512,8 +7512,8 @@ avr_out_plus (rtx insn, rtx *xop, int *plen, int *pcc, bool out_label)
rtx op[4];
rtx xpattern = INSN_P (insn) ? single_set (as_a <rtx_insn *> (insn)) : insn;
rtx xdest = SET_DEST (xpattern);
enum machine_mode mode = GET_MODE (xdest);
enum machine_mode imode = int_mode_for_mode (mode);
machine_mode mode = GET_MODE (xdest);
machine_mode imode = int_mode_for_mode (mode);
int n_bytes = GET_MODE_SIZE (mode);
enum rtx_code code_sat = GET_CODE (SET_SRC (xpattern));
enum rtx_code code
@ -7607,7 +7607,7 @@ avr_out_bitop (rtx insn, rtx *xop, int *plen)
/* CODE and MODE of the operation. */
rtx xpattern = INSN_P (insn) ? single_set (as_a <rtx_insn *> (insn)) : insn;
enum rtx_code code = GET_CODE (SET_SRC (xpattern));
enum machine_mode mode = GET_MODE (xop[0]);
machine_mode mode = GET_MODE (xop[0]);
/* Number of bytes to operate on. */
int i, n_bytes = GET_MODE_SIZE (mode);
@ -7884,7 +7884,7 @@ avr_out_fract (rtx_insn *insn, rtx operands[], bool intsigned, int *plen)
for (i = 0; i < sizeof (val) / sizeof (*val); i++)
{
enum machine_mode mode;
machine_mode mode;
xop[i] = operands[i];
@ -8378,8 +8378,8 @@ avr_out_fract (rtx_insn *insn, rtx operands[], bool intsigned, int *plen)
const char*
avr_out_round (rtx_insn *insn ATTRIBUTE_UNUSED, rtx *xop, int *plen)
{
enum machine_mode mode = GET_MODE (xop[0]);
enum machine_mode imode = int_mode_for_mode (mode);
machine_mode mode = GET_MODE (xop[0]);
machine_mode imode = int_mode_for_mode (mode);
// The smallest fractional bit not cleared by the rounding is 2^(-RP).
int fbit = (int) GET_MODE_FBIT (mode);
double_int i_add = double_int_zero.set_bit (fbit-1 - INTVAL (xop[2]));
@ -8440,14 +8440,14 @@ bool
avr_rotate_bytes (rtx operands[])
{
int i, j;
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
bool overlapped = reg_overlap_mentioned_p (operands[0], operands[1]);
bool same_reg = rtx_equal_p (operands[0], operands[1]);
int num = INTVAL (operands[2]);
rtx scratch = operands[3];
/* Work out if byte or word move is needed. Odd byte rotates need QImode.
Word move if no scratch is needed, otherwise use size of scratch. */
enum machine_mode move_mode = QImode;
machine_mode move_mode = QImode;
int move_size, offset, size;
if (num & 0xf)
@ -9803,7 +9803,7 @@ avr_adjust_reg_alloc_order (void)
/* Implement `TARGET_REGISTER_MOVE_COST' */
static int
avr_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
avr_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t from, reg_class_t to)
{
return (from == STACK_REG ? 6
@ -9815,7 +9815,7 @@ avr_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
/* Implement `TARGET_MEMORY_MOVE_COST' */
static int
avr_memory_move_cost (enum machine_mode mode,
avr_memory_move_cost (machine_mode mode,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -9833,7 +9833,7 @@ avr_memory_move_cost (enum machine_mode mode,
operand's parent operator. */
static int
avr_operand_rtx_cost (rtx x, enum machine_mode mode, enum rtx_code outer,
avr_operand_rtx_cost (rtx x, machine_mode mode, enum rtx_code outer,
int opno, bool speed)
{
enum rtx_code code = GET_CODE (x);
@ -9870,7 +9870,7 @@ avr_rtx_costs_1 (rtx x, int codearg, int outer_code ATTRIBUTE_UNUSED,
int opno ATTRIBUTE_UNUSED, int *total, bool speed)
{
enum rtx_code code = (enum rtx_code) codearg;
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
HOST_WIDE_INT val;
switch (code)
@ -10717,7 +10717,7 @@ avr_rtx_costs (rtx x, int codearg, int outer_code,
/* Implement `TARGET_ADDRESS_COST'. */
static int
avr_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
avr_address_cost (rtx x, machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
@ -10809,8 +10809,8 @@ avr_compare_pattern (rtx_insn *insn)
&& SET_DEST (pattern) == cc0_rtx
&& GET_CODE (SET_SRC (pattern)) == COMPARE)
{
enum machine_mode mode0 = GET_MODE (XEXP (SET_SRC (pattern), 0));
enum machine_mode mode1 = GET_MODE (XEXP (SET_SRC (pattern), 1));
machine_mode mode0 = GET_MODE (XEXP (SET_SRC (pattern), 0));
machine_mode mode1 = GET_MODE (XEXP (SET_SRC (pattern), 1));
/* The 64-bit comparisons have fixed operands ACC_A and ACC_B.
They must not be swapped, thus skip them. */
@ -11056,7 +11056,7 @@ avr_reorg (void)
rtx x = XEXP (pattern, 1);
rtx src = SET_SRC (pat);
rtx t = XEXP (src,0);
enum machine_mode mode = GET_MODE (XEXP (pattern, 0));
machine_mode mode = GET_MODE (XEXP (pattern, 0));
if (avr_simplify_comparison_p (mode, GET_CODE (t), x))
{
@ -11093,7 +11093,7 @@ avr_function_value_regno_p (const unsigned int regno)
library function returns a value of mode MODE. */
static rtx
avr_libcall_value (enum machine_mode mode,
avr_libcall_value (machine_mode mode,
const_rtx func ATTRIBUTE_UNUSED)
{
int offs = GET_MODE_SIZE (mode);
@ -11216,7 +11216,7 @@ jump_over_one_insn_p (rtx_insn *insn, rtx dest)
(this way we don't have to check for odd registers everywhere). */
int
avr_hard_regno_mode_ok (int regno, enum machine_mode mode)
avr_hard_regno_mode_ok (int regno, machine_mode mode)
{
/* NOTE: 8-bit values must not be disallowed for R28 or R29.
Disallowing QI et al. in these regs might lead to code like
@ -11249,7 +11249,7 @@ avr_hard_regno_mode_ok (int regno, enum machine_mode mode)
/* Implement `HARD_REGNO_CALL_PART_CLOBBERED'. */
int
avr_hard_regno_call_part_clobbered (unsigned regno, enum machine_mode mode)
avr_hard_regno_call_part_clobbered (unsigned regno, machine_mode mode)
{
/* FIXME: This hook gets called with MODE:REGNO combinations that don't
represent valid hard registers like, e.g. HI:29. Returning TRUE
@ -11271,7 +11271,7 @@ avr_hard_regno_call_part_clobbered (unsigned regno, enum machine_mode mode)
/* Implement `MODE_CODE_BASE_REG_CLASS'. */
enum reg_class
avr_mode_code_base_reg_class (enum machine_mode mode ATTRIBUTE_UNUSED,
avr_mode_code_base_reg_class (machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as, RTX_CODE outer_code,
RTX_CODE index_code ATTRIBUTE_UNUSED)
{
@ -11291,7 +11291,7 @@ avr_mode_code_base_reg_class (enum machine_mode mode ATTRIBUTE_UNUSED,
bool
avr_regno_mode_code_ok_for_base_p (int regno,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
RTX_CODE outer_code,
RTX_CODE index_code ATTRIBUTE_UNUSED)
@ -11376,7 +11376,7 @@ output_reload_in_const (rtx *op, rtx clobber_reg, int *len, bool clear_p)
int clobber_val = 1234;
bool cooked_clobber_p = false;
bool set_p = false;
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
int n, n_bytes = GET_MODE_SIZE (mode);
gcc_assert (REG_P (dest)
@ -11920,7 +11920,7 @@ avr_case_values_threshold (void)
/* Implement `TARGET_ADDR_SPACE_ADDRESS_MODE'. */
static enum machine_mode
static machine_mode
avr_addr_space_address_mode (addr_space_t as)
{
return avr_addrspace[as].pointer_size == 3 ? PSImode : HImode;
@ -11929,7 +11929,7 @@ avr_addr_space_address_mode (addr_space_t as)
/* Implement `TARGET_ADDR_SPACE_POINTER_MODE'. */
static enum machine_mode
static machine_mode
avr_addr_space_pointer_mode (addr_space_t as)
{
return avr_addr_space_address_mode (as);
@ -11963,7 +11963,7 @@ avr_reg_ok_for_pgm_addr (rtx reg, bool strict)
/* Implement `TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P'. */
static bool
avr_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
avr_addr_space_legitimate_address_p (machine_mode mode, rtx x,
bool strict, addr_space_t as)
{
bool ok = false;
@ -12046,7 +12046,7 @@ avr_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
static rtx
avr_addr_space_legitimize_address (rtx x, rtx old_x,
enum machine_mode mode, addr_space_t as)
machine_mode mode, addr_space_t as)
{
if (ADDR_SPACE_GENERIC_P (as))
return avr_legitimize_address (x, old_x, mode);
@ -12213,7 +12213,7 @@ bool
avr_emit_movmemhi (rtx *xop)
{
HOST_WIDE_INT count;
enum machine_mode loop_mode;
machine_mode loop_mode;
addr_space_t as = MEM_ADDR_SPACE (xop[1]);
rtx loop_reg, addr1, a_src, a_dest, insn, xas;
rtx a_hi8 = NULL_RTX;
@ -12319,7 +12319,7 @@ const char*
avr_out_movmem (rtx_insn *insn ATTRIBUTE_UNUSED, rtx *op, int *plen)
{
addr_space_t as = (addr_space_t) INTVAL (op[0]);
enum machine_mode loop_mode = GET_MODE (op[1]);
machine_mode loop_mode = GET_MODE (op[1]);
bool sbiw_p = test_hard_reg_class (ADDW_REGS, op[1]);
rtx xop[3];
@ -13048,7 +13048,7 @@ avr_default_expand_builtin (enum insn_code icode, tree exp, rtx target)
{
rtx pat, xop[3];
int n, n_args = call_expr_nargs (exp);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode tmode = insn_data[icode].operand[0].mode;
gcc_assert (n_args >= 1 && n_args <= 3);
@ -13063,8 +13063,8 @@ avr_default_expand_builtin (enum insn_code icode, tree exp, rtx target)
{
tree arg = CALL_EXPR_ARG (exp, n);
rtx op = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
enum machine_mode opmode = GET_MODE (op);
enum machine_mode mode = insn_data[icode].operand[n+1].mode;
machine_mode opmode = GET_MODE (op);
machine_mode mode = insn_data[icode].operand[n+1].mode;
if ((opmode == SImode || opmode == VOIDmode) && mode == HImode)
{
@ -13112,7 +13112,7 @@ avr_default_expand_builtin (enum insn_code icode, tree exp, rtx target)
static rtx
avr_expand_builtin (tree exp, rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);

2
gcc/config/avr/avr.md
View File

@ -1075,7 +1075,7 @@
""
{
rtx addr0;
enum machine_mode mode;
machine_mode mode;
/* If value to set is not zero, use the library routine. */
if (operands[2] != const0_rtx)

16
gcc/config/bfin/bfin-protos.h
View File

@ -71,24 +71,24 @@ extern char *bfin_asm_long (void);
extern char *bfin_asm_short (void);
extern int log2constp (unsigned HOST_WIDE_INT);
extern int hard_regno_mode_ok (int, enum machine_mode);
extern int hard_regno_mode_ok (int, machine_mode);
extern void init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx);
extern HOST_WIDE_INT bfin_initial_elimination_offset (int, int);
extern int effective_address_32bit_p (rtx, enum machine_mode);
extern int effective_address_32bit_p (rtx, machine_mode);
extern int symbolic_reference_mentioned_p (rtx);
extern rtx bfin_gen_compare (rtx, enum machine_mode);
extern bool expand_move (rtx *, enum machine_mode);
extern rtx bfin_gen_compare (rtx, machine_mode);
extern bool expand_move (rtx *, machine_mode);
extern void bfin_expand_call (rtx, rtx, rtx, rtx, int);
extern bool bfin_longcall_p (rtx, int);
extern bool bfin_dsp_memref_p (rtx);
extern bool bfin_expand_movmem (rtx, rtx, rtx, rtx);
extern enum reg_class secondary_input_reload_class (enum reg_class,
enum machine_mode,
machine_mode,
rtx);
extern enum reg_class secondary_output_reload_class (enum reg_class,
enum machine_mode,
machine_mode,
rtx);
extern char *section_asm_op_1 (SECT_ENUM_T);
extern char *section_asm_op (SECT_ENUM_T);
@ -96,9 +96,9 @@ extern void print_operand (FILE *, rtx, char);
extern void print_address_operand (FILE *, rtx);
extern void split_di (rtx [], int, rtx [], rtx []);
extern int split_load_immediate (rtx []);
extern void emit_pic_move (rtx *, enum machine_mode);
extern void emit_pic_move (rtx *, machine_mode);
extern void asm_conditional_branch (rtx_insn *, rtx *, int, int);
extern rtx bfin_gen_compare (rtx, enum machine_mode);
extern rtx bfin_gen_compare (rtx, machine_mode);
extern unsigned bfin_local_alignment (tree, unsigned);
extern rtx bfin_va_arg (tree, tree);

66
gcc/config/bfin/bfin.c
View File

@ -582,7 +582,7 @@ expand_epilogue_reg_restore (rtx spreg, bool saveall, bool is_inthandler)
static void
setup_incoming_varargs (cumulative_args_t cum,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
tree type ATTRIBUTE_UNUSED, int *pretend_size,
int no_rtl)
{
@ -1256,7 +1256,7 @@ bfin_delegitimize_address (rtx orig_x)
32-bit instruction. */
int
effective_address_32bit_p (rtx op, enum machine_mode mode)
effective_address_32bit_p (rtx op, machine_mode mode)
{
HOST_WIDE_INT offset;
@ -1310,7 +1310,7 @@ bfin_dsp_memref_p (rtx x)
static int
bfin_address_cost (rtx addr ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
@ -1358,7 +1358,7 @@ print_address_operand (FILE *file, rtx x)
void
print_operand (FILE *file, rtx x, char code)
{
enum machine_mode mode;
machine_mode mode;
if (code == '!')
{
@ -1673,7 +1673,7 @@ init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
(TYPE is null for libcalls where that information may not be available.) */
static void
bfin_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
bfin_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1713,7 +1713,7 @@ bfin_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
(otherwise it is an extra parameter matching an ellipsis). */
static rtx
bfin_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
bfin_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1743,7 +1743,7 @@ bfin_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
stack. */
static int
bfin_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
bfin_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1765,7 +1765,7 @@ bfin_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
static bool
bfin_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
return type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST;
@ -1930,7 +1930,7 @@ bfin_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
/* Emit insns to move operands[1] into operands[0]. */
void
emit_pic_move (rtx *operands, enum machine_mode mode ATTRIBUTE_UNUSED)
emit_pic_move (rtx *operands, machine_mode mode ATTRIBUTE_UNUSED)
{
rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
@ -1948,7 +1948,7 @@ emit_pic_move (rtx *operands, enum machine_mode mode ATTRIBUTE_UNUSED)
should generate an insn to move OPERANDS[1] to OPERANDS[0]. */
bool
expand_move (rtx *operands, enum machine_mode mode)
expand_move (rtx *operands, machine_mode mode)
{
rtx op = operands[1];
if ((TARGET_ID_SHARED_LIBRARY || TARGET_FDPIC)
@ -2139,7 +2139,7 @@ bfin_expand_call (rtx retval, rtx fnaddr, rtx callarg1, rtx cookie, int sibcall)
/* Return 1 if hard register REGNO can hold a value of machine-mode MODE. */
int
hard_regno_mode_ok (int regno, enum machine_mode mode)
hard_regno_mode_ok (int regno, machine_mode mode)
{
/* Allow only dregs to store value of mode HI or QI */
enum reg_class rclass = REGNO_REG_CLASS (regno);
@ -2169,7 +2169,7 @@ hard_regno_mode_ok (int regno, enum machine_mode mode)
/* Implements target hook vector_mode_supported_p. */
static bool
bfin_vector_mode_supported_p (enum machine_mode mode)
bfin_vector_mode_supported_p (machine_mode mode)
{
return mode == V2HImode;
}
@ -2177,7 +2177,7 @@ bfin_vector_mode_supported_p (enum machine_mode mode)
/* Worker function for TARGET_REGISTER_MOVE_COST. */
static int
bfin_register_move_cost (enum machine_mode mode,
bfin_register_move_cost (machine_mode mode,
reg_class_t class1, reg_class_t class2)
{
/* These need secondary reloads, so they're more expensive. */
@ -2208,7 +2208,7 @@ bfin_register_move_cost (enum machine_mode mode,
program; it'll make the costs more accurate. */
static int
bfin_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
bfin_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t rclass,
bool in ATTRIBUTE_UNUSED)
{
@ -2227,7 +2227,7 @@ bfin_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
static reg_class_t
bfin_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
enum machine_mode mode, secondary_reload_info *sri)
machine_mode mode, secondary_reload_info *sri)
{
/* If we have HImode or QImode, we can only use DREGS as secondary registers;
in most other cases we can also use PREGS. */
@ -2511,7 +2511,7 @@ asm_conditional_branch (rtx_insn *insn, rtx *operands, int n_nops, int predict_t
stored in bfin_compare_op0 and bfin_compare_op1 already. */
rtx
bfin_gen_compare (rtx cmp, enum machine_mode mode ATTRIBUTE_UNUSED)
bfin_gen_compare (rtx cmp, machine_mode mode ATTRIBUTE_UNUSED)
{
enum rtx_code code1, code2;
rtx op0 = XEXP (cmp, 0), op1 = XEXP (cmp, 1);
@ -2681,7 +2681,7 @@ split_load_immediate (rtx operands[])
MODE. Return false if not. */
static bool
bfin_valid_add (enum machine_mode mode, HOST_WIDE_INT value)
bfin_valid_add (machine_mode mode, HOST_WIDE_INT value)
{
unsigned HOST_WIDE_INT v = value > 0 ? value : -value;
int sz = GET_MODE_SIZE (mode);
@ -2694,7 +2694,7 @@ bfin_valid_add (enum machine_mode mode, HOST_WIDE_INT value)
}
static bool
bfin_valid_reg_p (unsigned int regno, int strict, enum machine_mode mode,
bfin_valid_reg_p (unsigned int regno, int strict, machine_mode mode,
enum rtx_code outer_code)
{
if (strict)
@ -2722,7 +2722,7 @@ bfin_valid_reg_p (unsigned int regno, int strict, enum machine_mode mode,
*/
static bool
bfin_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
bfin_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
switch (GET_CODE (x)) {
case REG:
@ -2761,7 +2761,7 @@ bfin_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
another way. */
static bool
bfin_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED,
bfin_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED,
rtx x ATTRIBUTE_UNUSED)
{
/* We have only one class of non-legitimate constants, and our movsi
@ -2777,7 +2777,7 @@ bfin_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED,
crossing section boundaries. */
static bool
bfin_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
bfin_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
rtx sym;
HOST_WIDE_INT offset;
@ -3196,7 +3196,7 @@ output_pop_multiple (rtx insn, rtx *operands)
/* Adjust DST and SRC by OFFSET bytes, and generate one move in mode MODE. */
static void
single_move_for_movmem (rtx dst, rtx src, enum machine_mode mode, HOST_WIDE_INT offset)
single_move_for_movmem (rtx dst, rtx src, machine_mode mode, HOST_WIDE_INT offset)
{
rtx scratch = gen_reg_rtx (mode);
rtx srcmem, dstmem;
@ -5348,7 +5348,7 @@ static const struct builtin_description bdesc_1arg[] =
where we expect a vector. To avoid crashing, use one of the vector
clear instructions. */
static rtx
safe_vector_operand (rtx x, enum machine_mode mode)
safe_vector_operand (rtx x, machine_mode mode)
{
if (x != const0_rtx)
return x;
@ -5370,11 +5370,11 @@ bfin_expand_binop_builtin (enum insn_code icode, tree exp, rtx target,
tree arg1 = CALL_EXPR_ARG (exp, 1);
rtx op0 = expand_normal (arg0);
rtx op1 = expand_normal (arg1);
enum machine_mode op0mode = GET_MODE (op0);
enum machine_mode op1mode = GET_MODE (op1);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
enum machine_mode mode1 = insn_data[icode].operand[2].mode;
machine_mode op0mode = GET_MODE (op0);
machine_mode op1mode = GET_MODE (op1);
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[1].mode;
machine_mode mode1 = insn_data[icode].operand[2].mode;
if (VECTOR_MODE_P (mode0))
op0 = safe_vector_operand (op0, mode0);
@ -5426,9 +5426,9 @@ bfin_expand_unop_builtin (enum insn_code icode, tree exp,
rtx pat;
tree arg0 = CALL_EXPR_ARG (exp, 0);
rtx op0 = expand_normal (arg0);
enum machine_mode op0mode = GET_MODE (op0);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
machine_mode op0mode = GET_MODE (op0);
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[1].mode;
if (! target
|| GET_MODE (target) != tmode
@ -5464,7 +5464,7 @@ bfin_expand_unop_builtin (enum insn_code icode, tree exp,
static rtx
bfin_expand_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
size_t i;
@ -5474,7 +5474,7 @@ bfin_expand_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
tree arg0, arg1, arg2;
rtx op0, op1, op2, accvec, pat, tmp1, tmp2, a0reg, a1reg;
enum machine_mode tmode, mode0;
machine_mode tmode, mode0;
switch (fcode)
{

8
gcc/config/c6x/c6x-protos.h
View File

@ -25,15 +25,15 @@
#ifdef RTX_CODE
extern void c6x_init_cumulative_args (CUMULATIVE_ARGS *, const_tree, rtx, int);
extern bool c6x_block_reg_pad_upward (enum machine_mode, const_tree, bool);
extern bool c6x_block_reg_pad_upward (machine_mode, const_tree, bool);
extern bool c6x_legitimate_address_p_1 (enum machine_mode, rtx, bool, bool);
extern bool c6x_legitimate_address_p_1 (machine_mode, rtx, bool, bool);
extern bool c6x_mem_operand (rtx, enum reg_class, bool);
extern bool expand_move (rtx *, enum machine_mode);
extern bool expand_move (rtx *, machine_mode);
extern bool c6x_long_call_p (rtx);
extern void c6x_expand_call (rtx, rtx, bool);
extern rtx c6x_expand_compare (rtx, enum machine_mode);
extern rtx c6x_expand_compare (rtx, machine_mode);
extern bool c6x_force_op_for_comparison_p (enum rtx_code, rtx);
extern bool c6x_expand_movmem (rtx, rtx, rtx, rtx, rtx, rtx);

76
gcc/config/c6x/c6x.c
View File

@ -517,7 +517,7 @@ c6x_init_cumulative_args (CUMULATIVE_ARGS *cum, const_tree fntype, rtx libname,
/* Implements the macro FUNCTION_ARG defined in c6x.h. */
static rtx
c6x_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
c6x_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -543,7 +543,7 @@ c6x_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
static void
c6x_function_arg_advance (cumulative_args_t cum_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -556,7 +556,7 @@ c6x_function_arg_advance (cumulative_args_t cum_v,
upward rather than downward. */
bool
c6x_block_reg_pad_upward (enum machine_mode mode ATTRIBUTE_UNUSED,
c6x_block_reg_pad_upward (machine_mode mode ATTRIBUTE_UNUSED,
const_tree type, bool first)
{
HOST_WIDE_INT size;
@ -574,7 +574,7 @@ c6x_block_reg_pad_upward (enum machine_mode mode ATTRIBUTE_UNUSED,
/* Implement TARGET_FUNCTION_ARG_BOUNDARY. */
static unsigned int
c6x_function_arg_boundary (enum machine_mode mode, const_tree type)
c6x_function_arg_boundary (machine_mode mode, const_tree type)
{
unsigned int boundary = type ? TYPE_ALIGN (type) : GET_MODE_BITSIZE (mode);
@ -599,7 +599,7 @@ c6x_function_arg_boundary (enum machine_mode mode, const_tree type)
/* Implement TARGET_FUNCTION_ARG_ROUND_BOUNDARY. */
static unsigned int
c6x_function_arg_round_boundary (enum machine_mode mode, const_tree type)
c6x_function_arg_round_boundary (machine_mode mode, const_tree type)
{
return c6x_function_arg_boundary (mode, type);
}
@ -632,7 +632,7 @@ c6x_function_value (const_tree type, const_tree func ATTRIBUTE_UNUSED,
/* Implement TARGET_LIBCALL_VALUE. */
static rtx
c6x_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
c6x_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, REG_A4);
}
@ -658,7 +658,7 @@ c6x_function_value_regno_p (const unsigned int regno)
static bool
c6x_pass_by_reference (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
enum machine_mode mode, const_tree type,
machine_mode mode, const_tree type,
bool named ATTRIBUTE_UNUSED)
{
int size = -1;
@ -694,7 +694,7 @@ c6x_return_in_msb (const_tree valtype)
static bool
c6x_callee_copies (cumulative_args_t cum_v ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -912,7 +912,7 @@ c6x_in_small_data_p (const_tree exp)
everything sized 8 bytes or smaller into small data. */
static section *
c6x_select_rtx_section (enum machine_mode mode, rtx x,
c6x_select_rtx_section (machine_mode mode, rtx x,
unsigned HOST_WIDE_INT align)
{
if (c6x_sdata_mode == C6X_SDATA_ALL
@ -1110,7 +1110,7 @@ c6x_call_saved_register_used (tree call_expr)
cumulative_args_t cum;
HARD_REG_SET call_saved_regset;
tree parameter;
enum machine_mode mode;
machine_mode mode;
tree type;
rtx parm_rtx;
int i;
@ -1375,7 +1375,7 @@ legitimize_pic_address (rtx orig, rtx reg, rtx picreg)
should generate an insn to move OPERANDS[1] to OPERANDS[0]. */
bool
expand_move (rtx *operands, enum machine_mode mode)
expand_move (rtx *operands, machine_mode mode)
{
rtx dest = operands[0];
rtx op = operands[1];
@ -1438,14 +1438,14 @@ c6x_force_op_for_comparison_p (enum rtx_code code, rtx op)
that should be used in the jump insn. */
rtx
c6x_expand_compare (rtx comparison, enum machine_mode mode)
c6x_expand_compare (rtx comparison, machine_mode mode)
{
enum rtx_code code = GET_CODE (comparison);
rtx op0 = XEXP (comparison, 0);
rtx op1 = XEXP (comparison, 1);
rtx cmp;
enum rtx_code jump_code = code;
enum machine_mode op_mode = GET_MODE (op0);
machine_mode op_mode = GET_MODE (op0);
if (op_mode == DImode && (code == NE || code == EQ) && op1 == const0_rtx)
{
@ -1642,7 +1642,7 @@ rtx
c6x_subword (rtx op, bool high_p)
{
unsigned int byte;
enum machine_mode mode;
machine_mode mode;
mode = GET_MODE (op);
if (mode == VOIDmode)
@ -1762,7 +1762,7 @@ c6x_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
while (count > 0)
{
rtx reg, reg_lowpart;
enum machine_mode srcmode, dstmode;
machine_mode srcmode, dstmode;
unsigned HOST_WIDE_INT src_size, dst_size, src_left;
int shift;
rtx srcmem, dstmem;
@ -1852,7 +1852,7 @@ c6x_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp,
use the scaled form. */
static void
print_address_offset (FILE *file, rtx off, enum machine_mode mem_mode)
print_address_offset (FILE *file, rtx off, machine_mode mem_mode)
{
rtx pat;
@ -1891,7 +1891,7 @@ static void c6x_print_operand (FILE *, rtx, int);
/* Subroutine of c6x_print_operand; used to print a memory reference X to FILE. */
static void
c6x_print_address_operand (FILE *file, rtx x, enum machine_mode mem_mode)
c6x_print_address_operand (FILE *file, rtx x, machine_mode mem_mode)
{
rtx off;
switch (GET_CODE (x))
@ -2107,7 +2107,7 @@ c6x_print_operand (FILE *file, rtx x, int code)
int i;
HOST_WIDE_INT v;
tree t;
enum machine_mode mode;
machine_mode mode;
if (code == '|')
{
@ -2328,7 +2328,7 @@ c6x_print_operand (FILE *file, rtx x, int code)
bool
c6x_mem_operand (rtx op, enum reg_class c, bool small_offset)
{
enum machine_mode mode = GET_MODE (op);
machine_mode mode = GET_MODE (op);
rtx base = XEXP (op, 0);
switch (GET_CODE (base))
{
@ -2372,7 +2372,7 @@ c6x_mem_operand (rtx op, enum reg_class c, bool small_offset)
recursively examining an operand inside a PRE/POST_MODIFY. */
bool
c6x_legitimate_address_p_1 (enum machine_mode mode, rtx x, bool strict,
c6x_legitimate_address_p_1 (machine_mode mode, rtx x, bool strict,
bool no_large_offset)
{
int size, size1;
@ -2480,13 +2480,13 @@ c6x_legitimate_address_p_1 (enum machine_mode mode, rtx x, bool strict,
}
static bool
c6x_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
c6x_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
return c6x_legitimate_address_p_1 (mode, x, strict, false);
}
static bool
c6x_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED,
c6x_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x ATTRIBUTE_UNUSED)
{
return true;
@ -2834,7 +2834,7 @@ c6x_expand_prologue (void)
int idx = N_SAVE_ORDER - i - 1;
unsigned regno = reg_save_order[idx];
rtx reg;
enum machine_mode save_mode = SImode;
machine_mode save_mode = SImode;
if (regno == REG_A15 && frame_pointer_needed)
/* Already saved. */
@ -2926,7 +2926,7 @@ c6x_expand_epilogue (bool sibcall)
{
unsigned regno = reg_save_order[i];
rtx reg;
enum machine_mode save_mode = SImode;
machine_mode save_mode = SImode;
if (!c6x_save_reg (regno))
continue;
@ -6236,7 +6236,7 @@ c6x_rtx_costs (rtx x, int code, int outer_code, int opno, int *total,
/* Implements target hook vector_mode_supported_p. */
static bool
c6x_vector_mode_supported_p (enum machine_mode mode)
c6x_vector_mode_supported_p (machine_mode mode)
{
switch (mode)
{
@ -6252,8 +6252,8 @@ c6x_vector_mode_supported_p (enum machine_mode mode)
}
/* Implements TARGET_VECTORIZE_PREFERRED_SIMD_MODE. */
static enum machine_mode
c6x_preferred_simd_mode (enum machine_mode mode)
static machine_mode
c6x_preferred_simd_mode (machine_mode mode)
{
switch (mode)
{
@ -6270,7 +6270,7 @@ c6x_preferred_simd_mode (enum machine_mode mode)
/* Implement TARGET_SCALAR_MODE_SUPPORTED_P. */
static bool
c6x_scalar_mode_supported_p (enum machine_mode mode)
c6x_scalar_mode_supported_p (machine_mode mode)
{
if (ALL_FIXED_POINT_MODE_P (mode)
&& GET_MODE_PRECISION (mode) <= 2 * BITS_PER_WORD)
@ -6550,7 +6550,7 @@ static const struct builtin_description bdesc_1arg[] =
where we expect a vector. To avoid crashing, use one of the vector
clear instructions. */
static rtx
safe_vector_operand (rtx x, enum machine_mode mode)
safe_vector_operand (rtx x, machine_mode mode)
{
if (x != const0_rtx)
return x;
@ -6573,11 +6573,11 @@ c6x_expand_binop_builtin (enum insn_code icode, tree exp, rtx target,
tree arg1 = CALL_EXPR_ARG (exp, 1);
rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
rtx op1 = expand_expr (arg1, NULL_RTX, VOIDmode, EXPAND_NORMAL);
enum machine_mode op0mode = GET_MODE (op0);
enum machine_mode op1mode = GET_MODE (op1);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode0 = insn_data[icode].operand[1 + offs].mode;
enum machine_mode mode1 = insn_data[icode].operand[2 + offs].mode;
machine_mode op0mode = GET_MODE (op0);
machine_mode op1mode = GET_MODE (op1);
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[1 + offs].mode;
machine_mode mode1 = insn_data[icode].operand[2 + offs].mode;
rtx ret = target;
if (VECTOR_MODE_P (mode0))
@ -6642,9 +6642,9 @@ c6x_expand_unop_builtin (enum insn_code icode, tree exp,
rtx pat;
tree arg0 = CALL_EXPR_ARG (exp, 0);
rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
enum machine_mode op0mode = GET_MODE (op0);
enum machine_mode tmode = insn_data[icode].operand[0].mode;
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
machine_mode op0mode = GET_MODE (op0);
machine_mode tmode = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[1].mode;
if (! target
|| GET_MODE (target) != tmode
@ -6680,7 +6680,7 @@ c6x_expand_unop_builtin (enum insn_code icode, tree exp,
static rtx
c6x_expand_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
size_t i;

4
gcc/config/c6x/c6x.md
View File

@ -469,7 +469,7 @@
[(set (match_dup 2) (match_dup 3))]
{
unsigned HOST_WIDE_INT mask, val;
enum machine_mode inner_mode = GET_MODE_INNER (<MODE>mode);
machine_mode inner_mode = GET_MODE_INNER (<MODE>mode);
int i;
val = 0;
@ -505,7 +505,7 @@
unsigned HOST_WIDE_INT mask;
unsigned HOST_WIDE_INT val[2];
rtx lo_half, hi_half;
enum machine_mode inner_mode = GET_MODE_INNER (<MODE>mode);
machine_mode inner_mode = GET_MODE_INNER (<MODE>mode);
int i, j;
split_di (operands, 1, &lo_half, &hi_half);

4
gcc/config/cr16/cr16-protos.h
View File

@ -23,7 +23,7 @@
/* Register usage. */
extern enum reg_class cr16_regno_reg_class (int);
extern int cr16_hard_regno_mode_ok (int regno, enum machine_mode);
extern int cr16_hard_regno_mode_ok (int regno, machine_mode);
/* Passing function arguments. */
extern int cr16_function_arg_regno_p (int);
@ -79,7 +79,7 @@ extern enum cr16_addrtype cr16_decompose_address (rtx addr,
bool treat_as_const);
extern int cr16_const_double_ok (rtx op);
extern int legitimate_pic_operand_p (rtx);
extern rtx legitimize_pic_address (rtx, enum machine_mode, rtx);
extern rtx legitimize_pic_address (rtx, machine_mode, rtx);
/* Prologue/Epilogue functions. */

28
gcc/config/cr16/cr16.c
View File

@ -479,7 +479,7 @@ cr16_regno_reg_class (int regno)
/* Return 1 if hard register REGNO can hold a value of machine-mode MODE. */
int
cr16_hard_regno_mode_ok (int regno, enum machine_mode mode)
cr16_hard_regno_mode_ok (int regno, machine_mode mode)
{
if ((GET_MODE_SIZE (mode) >= 4) && (regno == 11))
return 0;
@ -528,7 +528,7 @@ cr16_function_value_regno_p (const unsigned int regno)
/* Create an RTX representing the place where a
library function returns a value of mode MODE. */
static rtx
cr16_libcall_value (enum machine_mode mode,
cr16_libcall_value (machine_mode mode,
const_rtx func ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, cr16_ret_register ());
@ -550,7 +550,7 @@ cr16_function_value (const_tree type,
the number of registers needed else 0. */
static int
enough_regs_for_param (CUMULATIVE_ARGS * cum, const_tree type,
enum machine_mode mode)
machine_mode mode)
{
int type_size;
int remaining_size;
@ -574,7 +574,7 @@ enough_regs_for_param (CUMULATIVE_ARGS * cum, const_tree type,
/* Implements the macro FUNCTION_ARG defined in cr16.h. */
static rtx
cr16_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
cr16_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -641,7 +641,7 @@ cr16_init_cumulative_args (CUMULATIVE_ARGS * cum, tree fntype,
/* Implements the macro FUNCTION_ARG_ADVANCE defined in cr16.h. */
static void
cr16_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
cr16_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS * cum = get_cumulative_args (cum_v);
@ -1170,7 +1170,7 @@ legitimate_pic_operand_p (rtx x)
NOTE: @BRO is added using unspec:BRO
NOTE: @GOT is added using unspec:GOT. */
rtx
legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
legitimize_pic_address (rtx orig, machine_mode mode ATTRIBUTE_UNUSED,
rtx reg)
{
/* First handle a simple SYMBOL_REF or LABEL_REF. */
@ -1223,7 +1223,7 @@ legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
/* Implementation of TARGET_LEGITIMATE_ADDRESS_P. */
static bool
cr16_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
cr16_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx addr, bool strict)
{
enum cr16_addrtype addrtype;
@ -1302,7 +1302,7 @@ cr16_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
/* Return cost of the memory address x. */
static int
cr16_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
cr16_address_cost (rtx addr, machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
@ -1354,7 +1354,7 @@ cr16_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
/* Implement `TARGET_REGISTER_MOVE_COST'. */
static int
cr16_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
cr16_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t from ATTRIBUTE_UNUSED, reg_class_t to)
{
return (to != GENERAL_REGS ? 8 : 2);
@ -1367,7 +1367,7 @@ cr16_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
nonzero if it is to be read in. This cost is relative to those in
REGISTER_MOVE_COST. */
static int
cr16_memory_move_cost (enum machine_mode mode,
cr16_memory_move_cost (machine_mode mode,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -1819,7 +1819,7 @@ cr16_create_dwarf_for_multi_push (rtx insn)
{
rtx dwarf, reg, tmp;
int i, j, from, to, word_cnt, dwarf_par_index, inc;
enum machine_mode mode;
machine_mode mode;
int num_regs = 0, offset = 0, split_here = 0, total_push_bytes = 0;
for (i = 0; i <= current_frame_info.last_reg_to_save; ++i)
@ -2061,7 +2061,7 @@ cr16_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
it should assign X (which will always be a C variable) a new value. */
static rtx
cr16_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED)
machine_mode mode ATTRIBUTE_UNUSED)
{
if (flag_pic)
return legitimize_pic_address (orig_x, mode, NULL_RTX);
@ -2075,7 +2075,7 @@ cr16_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
satisfies CONSTANT_P. In cr16c treat legitimize float
constant as an immediate operand. */
static bool
cr16_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED,
cr16_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x ATTRIBUTE_UNUSED)
{
return 1;
@ -2112,7 +2112,7 @@ notice_update_cc (rtx exp)
return;
}
static enum machine_mode
static machine_mode
cr16_unwind_word_mode (void)
{
return SImode;

6
gcc/config/cris/cris-protos.h
View File

@ -24,7 +24,7 @@ extern bool cris_simple_epilogue (void);
#ifdef RTX_CODE
extern const char *cris_op_str (rtx);
extern void cris_notice_update_cc (rtx, rtx_insn *);
extern bool cris_reload_address_legitimized (rtx, enum machine_mode, int, int, int);
extern bool cris_reload_address_legitimized (rtx, machine_mode, int, int, int);
extern int cris_side_effect_mode_ok (enum rtx_code, rtx *, int, int,
int, int, int);
extern bool cris_cc0_user_requires_cmp (rtx);
@ -33,13 +33,13 @@ extern rtx cris_split_movdx (rtx *);
extern int cris_legitimate_pic_operand (rtx);
extern enum cris_symbol_type cris_symbol_type_of (const_rtx);
extern bool cris_valid_pic_const (const_rtx, bool);
extern bool cris_legitimate_constant_p (enum machine_mode, rtx);
extern bool cris_legitimate_constant_p (machine_mode, rtx);
extern bool cris_constant_index_p (const_rtx);
extern bool cris_base_p (const_rtx, bool);
extern bool cris_base_or_autoincr_p (const_rtx, bool);
extern bool cris_bdap_index_p (const_rtx, bool);
extern bool cris_biap_index_p (const_rtx, bool);
extern bool cris_legitimate_address_p (enum machine_mode, rtx, bool);
extern bool cris_legitimate_address_p (machine_mode, rtx, bool);
extern bool cris_store_multiple_op_p (rtx);
extern bool cris_movem_load_rest_p (rtx, int);
extern void cris_asm_output_symbol_ref (FILE *, rtx);

64
gcc/config/cris/cris.c
View File

@ -109,10 +109,10 @@ static int in_code = 0;
/* Fix for reg_overlap_mentioned_p. */
static int cris_reg_overlap_mentioned_p (rtx, rtx);
static enum machine_mode cris_promote_function_mode (const_tree, enum machine_mode,
static machine_mode cris_promote_function_mode (const_tree, machine_mode,
int *, const_tree, int);
static unsigned int cris_atomic_align_for_mode (enum machine_mode);
static unsigned int cris_atomic_align_for_mode (machine_mode);
static void cris_print_base (rtx, FILE *);
@ -124,7 +124,7 @@ static struct machine_function * cris_init_machine_status (void);
static rtx cris_struct_value_rtx (tree, int);
static void cris_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
static void cris_setup_incoming_varargs (cumulative_args_t, machine_mode,
tree type, int *, int);
static int cris_initial_frame_pointer_offset (void);
@ -151,22 +151,22 @@ static void cris_init_libfuncs (void);
static reg_class_t cris_preferred_reload_class (rtx, reg_class_t);
static int cris_register_move_cost (enum machine_mode, reg_class_t, reg_class_t);
static int cris_memory_move_cost (enum machine_mode, reg_class_t, bool);
static int cris_register_move_cost (machine_mode, reg_class_t, reg_class_t);
static int cris_memory_move_cost (machine_mode, reg_class_t, bool);
static bool cris_rtx_costs (rtx, int, int, int, int *, bool);
static int cris_address_cost (rtx, enum machine_mode, addr_space_t, bool);
static bool cris_pass_by_reference (cumulative_args_t, enum machine_mode,
static int cris_address_cost (rtx, machine_mode, addr_space_t, bool);
static bool cris_pass_by_reference (cumulative_args_t, machine_mode,
const_tree, bool);
static int cris_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static int cris_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx cris_function_arg (cumulative_args_t, enum machine_mode,
static rtx cris_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx cris_function_incoming_arg (cumulative_args_t,
enum machine_mode, const_tree, bool);
static void cris_function_arg_advance (cumulative_args_t, enum machine_mode,
machine_mode, const_tree, bool);
static void cris_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static tree cris_md_asm_clobbers (tree, tree, tree);
static bool cris_cannot_force_const_mem (enum machine_mode, rtx);
static bool cris_cannot_force_const_mem (machine_mode, rtx);
static void cris_option_override (void);
@ -176,7 +176,7 @@ static void cris_asm_trampoline_template (FILE *);
static void cris_trampoline_init (rtx, tree, rtx);
static rtx cris_function_value(const_tree, const_tree, bool);
static rtx cris_libcall_value (enum machine_mode, const_rtx);
static rtx cris_libcall_value (machine_mode, const_rtx);
static bool cris_function_value_regno_p (const unsigned int);
static void cris_file_end (void);
@ -538,7 +538,7 @@ cris_cfun_uses_pic_table (void)
can be reached as pc-relative as we can't tell when or how to do that. */
static bool
cris_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
cris_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
enum cris_symbol_type t = cris_symbol_type_of (x);
@ -1466,7 +1466,7 @@ cris_biap_index_p (const_rtx x, bool strict)
symbol is valid for the plain "symbol + offset" case. */
bool
cris_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
cris_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
const_rtx x1, x2;
@ -1517,7 +1517,7 @@ cris_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
so don't bother; fix the documentation instead. */
bool
cris_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
cris_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
enum cris_symbol_type t;
@ -1536,7 +1536,7 @@ cris_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
bool
cris_reload_address_legitimized (rtx x,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int opnum ATTRIBUTE_UNUSED,
int itype,
int ind_levels ATTRIBUTE_UNUSED)
@ -1636,7 +1636,7 @@ cris_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, reg_class_t rclass)
/* Worker function for TARGET_REGISTER_MOVE_COST. */
static int
cris_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
cris_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t from, reg_class_t to)
{
/* Can't move to and from a SPECIAL_REGS register, so we have to say
@ -1674,7 +1674,7 @@ cris_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
suffice. */
static int
cris_memory_move_cost (enum machine_mode mode,
cris_memory_move_cost (machine_mode mode,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -2220,7 +2220,7 @@ cris_rtx_costs (rtx x, int code, int outer_code, int opno, int *total,
/* The ADDRESS_COST worker. */
static int
cris_address_cost (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED,
cris_address_cost (rtx x, machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
@ -2883,7 +2883,7 @@ cris_init_machine_status (void)
rtx
cris_split_movdx (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx dest = operands[0];
rtx src = operands[1];
rtx val;
@ -4055,7 +4055,7 @@ cris_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
static void
cris_setup_incoming_varargs (cumulative_args_t ca_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
tree type ATTRIBUTE_UNUSED,
int *pretend_arg_size,
int second_time)
@ -4080,7 +4080,7 @@ cris_setup_incoming_varargs (cumulative_args_t ca_v,
static bool
cris_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
enum machine_mode mode, const_tree type,
machine_mode mode, const_tree type,
bool named ATTRIBUTE_UNUSED)
{
return (targetm.calls.must_pass_in_stack (mode, type)
@ -4091,9 +4091,9 @@ cris_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
and *not* defining TARGET_PROMOTE_PROTOTYPES or PROMOTE_MODE gives the
best code size and speed for gcc, ipps and products in gcc-2.7.2. */
enum machine_mode
machine_mode
cris_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
enum machine_mode mode,
machine_mode mode,
int *punsignedp ATTRIBUTE_UNUSED,
const_tree fntype ATTRIBUTE_UNUSED,
int for_return)
@ -4109,7 +4109,7 @@ cris_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
/* Atomic types require alignment to be at least their "natural" size. */
static unsigned int
cris_atomic_align_for_mode (enum machine_mode mode)
cris_atomic_align_for_mode (machine_mode mode)
{
return GET_MODE_BITSIZE (mode);
}
@ -4129,7 +4129,7 @@ cris_function_value(const_tree type,
time being. */
static rtx
cris_libcall_value (enum machine_mode mode,
cris_libcall_value (machine_mode mode,
const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, CRIS_FIRST_ARG_REG);
@ -4145,7 +4145,7 @@ cris_function_value_regno_p (const unsigned int regno)
}
static int
cris_arg_partial_bytes (cumulative_args_t ca, enum machine_mode mode,
cris_arg_partial_bytes (cumulative_args_t ca, machine_mode mode,
tree type, bool named ATTRIBUTE_UNUSED)
{
if (get_cumulative_args (ca)->regs == CRIS_MAX_ARGS_IN_REGS - 1
@ -4159,7 +4159,7 @@ cris_arg_partial_bytes (cumulative_args_t ca, enum machine_mode mode,
static rtx
cris_function_arg_1 (cumulative_args_t ca_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named, bool incoming)
{
@ -4175,7 +4175,7 @@ cris_function_arg_1 (cumulative_args_t ca_v,
The void_type_node is sent as a "closing" call. */
static rtx
cris_function_arg (cumulative_args_t ca, enum machine_mode mode,
cris_function_arg (cumulative_args_t ca, machine_mode mode,
const_tree type, bool named)
{
return cris_function_arg_1 (ca, mode, type, named, false);
@ -4189,7 +4189,7 @@ cris_function_arg (cumulative_args_t ca, enum machine_mode mode,
void_type_node TYPE parameter. */
static rtx
cris_function_incoming_arg (cumulative_args_t ca, enum machine_mode mode,
cris_function_incoming_arg (cumulative_args_t ca, machine_mode mode,
const_tree type, bool named)
{
return cris_function_arg_1 (ca, mode, type, named, true);
@ -4198,7 +4198,7 @@ cris_function_incoming_arg (cumulative_args_t ca, enum machine_mode mode,
/* Worker function for TARGET_FUNCTION_ARG_ADVANCE. */
static void
cris_function_arg_advance (cumulative_args_t ca_v, enum machine_mode mode,
cris_function_arg_advance (cumulative_args_t ca_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *ca = get_cumulative_args (ca_v);

6
gcc/config/cris/cris.md
View File

@ -4997,8 +4997,8 @@
[(set (match_dup 0) (match_dup 4))
(set (match_dup 5) (match_dup 6))]
{
enum machine_mode zmode = INTVAL (operands[3]) <= 255 ? QImode : HImode;
enum machine_mode amode
machine_mode zmode = INTVAL (operands[3]) <= 255 ? QImode : HImode;
machine_mode amode
= satisfies_constraint_O (operands[3]) ? SImode : zmode;
rtx op1
= (REG_S_P (operands[1])
@ -5035,7 +5035,7 @@
[(set (match_dup 0) (match_dup 3))
(set (match_dup 0) (and:SI (match_dup 0) (match_dup 4)))]
{
enum machine_mode zmode = INTVAL (operands[2]) <= 255 ? QImode : HImode;
machine_mode zmode = INTVAL (operands[2]) <= 255 ? QImode : HImode;
rtx op1
= (REG_S_P (operands[2])
? gen_rtx_REG (zmode, REGNO (operands[2]))

4
gcc/config/darwin-protos.h
View File

@ -37,11 +37,11 @@ extern enum machopic_addr_class machopic_classify_symbol (rtx);
extern rtx machopic_indirect_data_reference (rtx, rtx);
extern rtx machopic_indirect_call_target (rtx);
extern rtx machopic_legitimize_pic_address (rtx, enum machine_mode, rtx);
extern rtx machopic_legitimize_pic_address (rtx, machine_mode, rtx);
extern void machopic_asm_out_constructor (rtx, int);
extern void machopic_asm_out_destructor (rtx, int);
extern section *machopic_select_rtx_section (enum machine_mode, rtx,
extern section *machopic_select_rtx_section (machine_mode, rtx,
unsigned HOST_WIDE_INT);
#endif /* RTX_CODE */

8
gcc/config/darwin.c
View File

@ -798,7 +798,7 @@ machopic_indirect_call_target (rtx target)
rtx sym_ref = XEXP (target, 0);
const char *stub_name = machopic_indirection_name (sym_ref,
/*stub_p=*/true);
enum machine_mode mode = GET_MODE (sym_ref);
machine_mode mode = GET_MODE (sym_ref);
XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
@ -810,7 +810,7 @@ machopic_indirect_call_target (rtx target)
}
rtx
machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
machopic_legitimize_pic_address (rtx orig, machine_mode mode, rtx reg)
{
rtx pic_ref = orig;
@ -1293,7 +1293,7 @@ darwin_mergeable_constant_section (tree exp,
unsigned HOST_WIDE_INT align,
bool zsize)
{
enum machine_mode mode = DECL_MODE (exp);
machine_mode mode = DECL_MODE (exp);
unsigned int modesize = GET_MODE_BITSIZE (mode);
if (DARWIN_SECTION_ANCHORS
@ -1743,7 +1743,7 @@ machopic_select_section (tree decl,
They must go in "const". */
section *
machopic_select_rtx_section (enum machine_mode mode, rtx x,
machopic_select_rtx_section (machine_mode mode, rtx x,
unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
{
if (GET_MODE_SIZE (mode) == 8

8
gcc/config/epiphany/epiphany-protos.h
View File

@ -19,11 +19,11 @@ along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#ifdef RTX_CODE
extern enum machine_mode epiphany_select_cc_mode (enum rtx_code, rtx, rtx);
extern machine_mode epiphany_select_cc_mode (enum rtx_code, rtx, rtx);
/* Define the function that build the compare insn for scc and bcc. */
extern struct rtx_def *gen_compare_reg (enum machine_mode, enum rtx_code,
enum machine_mode, rtx, rtx);
extern struct rtx_def *gen_compare_reg (machine_mode, enum rtx_code,
machine_mode, rtx, rtx);
#endif
/* Declarations for various fns used in the .md file. */
@ -38,7 +38,7 @@ extern void epiphany_expand_prologue (void);
extern void epiphany_expand_epilogue (int);
extern int epiphany_initial_elimination_offset (int, int);
extern void epiphany_init_expanders (void);
extern int hard_regno_mode_ok (int regno, enum machine_mode mode);
extern int hard_regno_mode_ok (int regno, machine_mode mode);
#ifdef HARD_CONST
extern void emit_set_fp_mode (int entity, int mode, int prev_mode,
HARD_REG_SET regs_live);

58
gcc/config/epiphany/epiphany.c
View File

@ -88,7 +88,7 @@ static int get_epiphany_condition_code (rtx);
static tree epiphany_handle_interrupt_attribute (tree *, tree, tree, int, bool *);
static tree epiphany_handle_forwarder_attribute (tree *, tree, tree, int,
bool *);
static bool epiphany_pass_by_reference (cumulative_args_t, enum machine_mode,
static bool epiphany_pass_by_reference (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx_insn *frame_insn (rtx);
@ -374,7 +374,7 @@ get_epiphany_condition_code (rtx comparison)
/* Return 1 if hard register REGNO can hold a value of machine_mode MODE. */
int
hard_regno_mode_ok (int regno, enum machine_mode mode)
hard_regno_mode_ok (int regno, machine_mode mode)
{
if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
return (regno & 1) == 0 && GPR_P (regno);
@ -385,7 +385,7 @@ hard_regno_mode_ok (int regno, enum machine_mode mode)
/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
return the mode to be used for the comparison. */
enum machine_mode
machine_mode
epiphany_select_cc_mode (enum rtx_code op,
rtx x ATTRIBUTE_UNUSED,
rtx y ATTRIBUTE_UNUSED)
@ -580,10 +580,10 @@ sfunc_symbol (const char *name)
mode, and return the rtx for the cc reg comparison in CMODE. */
rtx
gen_compare_reg (enum machine_mode cmode, enum rtx_code code,
enum machine_mode in_mode, rtx x, rtx y)
gen_compare_reg (machine_mode cmode, enum rtx_code code,
machine_mode in_mode, rtx x, rtx y)
{
enum machine_mode mode = SELECT_CC_MODE (code, x, y);
machine_mode mode = SELECT_CC_MODE (code, x, y);
rtx cc_reg, pat, clob0, clob1, clob2;
if (in_mode == VOIDmode)
@ -703,7 +703,7 @@ gen_compare_reg (enum machine_mode cmode, enum rtx_code code,
: (CUM))
static unsigned int
epiphany_function_arg_boundary (enum machine_mode mode, const_tree type)
epiphany_function_arg_boundary (machine_mode mode, const_tree type)
{
if ((type ? TYPE_ALIGN (type) : GET_MODE_BITSIZE (mode)) <= PARM_BOUNDARY)
return PARM_BOUNDARY;
@ -718,7 +718,7 @@ epiphany_function_arg_boundary (enum machine_mode mode, const_tree type)
static void
epiphany_setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
epiphany_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode,
tree type, int *pretend_size, int no_rtl)
{
int first_anon_arg;
@ -746,7 +746,7 @@ epiphany_setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
}
static int
epiphany_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
epiphany_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
tree type, bool named ATTRIBUTE_UNUSED)
{
int words = 0, rounded_cum;
@ -844,7 +844,7 @@ epiphany_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
If ADDR is not a valid address, its cost is irrelevant. */
static int
epiphany_address_cost (rtx addr, enum machine_mode mode,
epiphany_address_cost (rtx addr, machine_mode mode,
addr_space_t as ATTRIBUTE_UNUSED, bool speed)
{
rtx reg;
@ -905,7 +905,7 @@ epiphany_address_cost (rtx addr, enum machine_mode mode,
but issue pich is the same. For floating point, load latency is three
times as much as a reg-reg move. */
static int
epiphany_memory_move_cost (enum machine_mode mode,
epiphany_memory_move_cost (machine_mode mode,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -1484,7 +1484,7 @@ epiphany_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
static bool
epiphany_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
enum machine_mode mode, const_tree type,
machine_mode mode, const_tree type,
bool named ATTRIBUTE_UNUSED)
{
if (type)
@ -1502,7 +1502,7 @@ epiphany_function_value (const_tree ret_type,
const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
bool outgoing ATTRIBUTE_UNUSED)
{
enum machine_mode mode;
machine_mode mode;
mode = TYPE_MODE (ret_type);
/* We must change the mode like PROMOTE_MODE does.
@ -1520,7 +1520,7 @@ epiphany_function_value (const_tree ret_type,
}
static rtx
epiphany_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
epiphany_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, 0);
}
@ -1615,7 +1615,7 @@ frame_move_insn (rtx to, rtx from)
/* Generate a MEM referring to a varargs argument slot. */
static rtx
gen_varargs_mem (enum machine_mode mode, rtx addr)
gen_varargs_mem (machine_mode mode, rtx addr)
{
rtx mem = gen_rtx_MEM (mode, addr);
MEM_NOTRAP_P (mem) = 1;
@ -1647,10 +1647,10 @@ epiphany_emit_save_restore (int min, int limit, rtx addr, int epilogue_p)
last_saved--;
for (i = 0; i < limit; i++)
{
enum machine_mode mode = word_mode;
machine_mode mode = word_mode;
rtx mem, reg;
int n = i;
rtx (*gen_mem) (enum machine_mode, rtx) = gen_frame_mem;
rtx (*gen_mem) (machine_mode, rtx) = gen_frame_mem;
/* Make sure we push the arguments in the right order. */
if (n < MAX_EPIPHANY_PARM_REGS && crtl->args.pretend_args_size)
@ -1811,7 +1811,7 @@ epiphany_expand_prologue (void)
allocate the entire frame; this is joint with one register save. */
if (current_frame_info.first_slot >= 0)
{
enum machine_mode mode
machine_mode mode
= (current_frame_info.first_slot_size == UNITS_PER_WORD
? word_mode : DImode);
@ -2047,7 +2047,7 @@ epiphany_adjust_cost (rtx_insn *insn, rtx link, rtx_insn *dep_insn, int cost)
|| RTX_OK_FOR_OFFSET_P (MODE, XEXP (X, 1))))
static bool
epiphany_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
epiphany_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
#define REG_OK_FOR_BASE_P(X) \
(strict ? GPR_P (REGNO (X)) : GPR_AP_OR_PSEUDO_P (REGNO (X)))
@ -2082,7 +2082,7 @@ epiphany_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
static reg_class_t
epiphany_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
secondary_reload_info *sri)
{
/* This could give more reload inheritance, but we are missing some
@ -2200,8 +2200,8 @@ epiphany_call_uninterruptible_p (rtx mem)
return epiphany_uninterruptible_p (t);
}
static enum machine_mode
epiphany_promote_function_mode (const_tree type, enum machine_mode mode,
static machine_mode
epiphany_promote_function_mode (const_tree type, machine_mode mode,
int *punsignedp ATTRIBUTE_UNUSED,
const_tree funtype ATTRIBUTE_UNUSED,
int for_return ATTRIBUTE_UNUSED)
@ -2261,7 +2261,7 @@ epiphany_conditional_register_usage (void)
/* On the EPIPHANY the first MAX_EPIPHANY_PARM_REGS args are normally in
registers and the rest are pushed. */
static rtx
epiphany_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
epiphany_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS cum = *get_cumulative_args (cum_v);
@ -2275,7 +2275,7 @@ epiphany_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
of mode MODE and data type TYPE.
(TYPE is null for libcalls where that information may not be available.) */
static void
epiphany_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
epiphany_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -2775,7 +2775,7 @@ epiphany_epilogue_uses (int regno)
}
static unsigned int
epiphany_min_divisions_for_recip_mul (enum machine_mode mode)
epiphany_min_divisions_for_recip_mul (machine_mode mode)
{
if (flag_reciprocal_math && mode == SFmode)
/* We'll expand into a multiply-by-reciprocal anyway, so we might a well do
@ -2784,14 +2784,14 @@ epiphany_min_divisions_for_recip_mul (enum machine_mode mode)
return default_min_divisions_for_recip_mul (mode);
}
static enum machine_mode
epiphany_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
static machine_mode
epiphany_preferred_simd_mode (machine_mode mode ATTRIBUTE_UNUSED)
{
return TARGET_VECT_DOUBLE ? DImode : SImode;
}
static bool
epiphany_vector_mode_supported_p (enum machine_mode mode)
epiphany_vector_mode_supported_p (machine_mode mode)
{
if (mode == V2SFmode)
return true;
@ -2813,7 +2813,7 @@ epiphany_vector_alignment_reachable (const_tree type, bool is_packed)
}
static bool
epiphany_support_vector_misalignment (enum machine_mode mode, const_tree type,
epiphany_support_vector_misalignment (machine_mode mode, const_tree type,
int misalignment, bool is_packed)
{
if (GET_MODE_SIZE (mode) == 8 && misalignment % 4 == 0)

2
gcc/config/epiphany/epiphany.md
View File

@ -1946,7 +1946,7 @@
{
rtx cmp_op0 = XEXP (operands[1], 0);
rtx cmp_op1 = XEXP (operands[1], 1);
enum machine_mode cmp_in_mode;
machine_mode cmp_in_mode;
enum rtx_code code = GET_CODE (operands[1]);
cmp_in_mode = GET_MODE (cmp_op0);

32
gcc/config/fr30/fr30.c
View File

@ -130,23 +130,23 @@ static struct fr30_frame_info current_frame_info;
/* Zero structure to initialize current_frame_info. */
static struct fr30_frame_info zero_frame_info;
static void fr30_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
static void fr30_setup_incoming_varargs (cumulative_args_t, machine_mode,
tree, int *, int);
static bool fr30_must_pass_in_stack (enum machine_mode, const_tree);
static int fr30_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static bool fr30_must_pass_in_stack (machine_mode, const_tree);
static int fr30_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx fr30_function_arg (cumulative_args_t, enum machine_mode,
static rtx fr30_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static void fr30_function_arg_advance (cumulative_args_t, enum machine_mode,
static void fr30_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static bool fr30_frame_pointer_required (void);
static rtx fr30_function_value (const_tree, const_tree, bool);
static rtx fr30_libcall_value (enum machine_mode, const_rtx);
static rtx fr30_libcall_value (machine_mode, const_rtx);
static bool fr30_function_value_regno_p (const unsigned int);
static bool fr30_can_eliminate (const int, const int);
static void fr30_asm_trampoline_template (FILE *);
static void fr30_trampoline_init (rtx, tree, rtx);
static int fr30_num_arg_regs (enum machine_mode, const_tree);
static int fr30_num_arg_regs (machine_mode, const_tree);
#define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
#define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM))
@ -471,7 +471,7 @@ fr30_expand_epilogue (void)
which has type TYPE and mode MODE, and we rely on this fact. */
void
fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v,
enum machine_mode mode,
machine_mode mode,
tree type ATTRIBUTE_UNUSED,
int *pretend_size,
int second_time ATTRIBUTE_UNUSED)
@ -733,7 +733,7 @@ fr30_function_value (const_tree valtype,
/* Implements TARGET_LIBCALL_VALUE. */
static rtx
fr30_libcall_value (enum machine_mode mode,
fr30_libcall_value (machine_mode mode,
const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, RETURN_VALUE_REGNUM);
@ -753,7 +753,7 @@ fr30_function_value_regno_p (const unsigned int regno)
in registers. */
static bool
fr30_must_pass_in_stack (enum machine_mode mode, const_tree type)
fr30_must_pass_in_stack (machine_mode mode, const_tree type)
{
if (mode == BLKmode)
return true;
@ -765,7 +765,7 @@ fr30_must_pass_in_stack (enum machine_mode mode, const_tree type)
/* Compute the number of word sized registers needed to hold a
function argument of mode INT_MODE and tree type TYPE. */
static int
fr30_num_arg_regs (enum machine_mode mode, const_tree type)
fr30_num_arg_regs (machine_mode mode, const_tree type)
{
int size;
@ -788,7 +788,7 @@ fr30_num_arg_regs (enum machine_mode mode, const_tree type)
parameters to the function. */
static int
fr30_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
fr30_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -812,7 +812,7 @@ fr30_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
}
static rtx
fr30_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
fr30_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -834,7 +834,7 @@ fr30_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
the stack. The compiler knows how to track the amount of stack space used
for arguments without any special help. */
static void
fr30_function_arg_advance (cumulative_args_t cum, enum machine_mode mode,
fr30_function_arg_advance (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
*get_cumulative_args (cum) += named * fr30_num_arg_regs (mode, type);
@ -844,7 +844,7 @@ fr30_function_arg_advance (cumulative_args_t cum, enum machine_mode mode,
/*{{{ Operand predicates */
#ifndef Mmode
#define Mmode enum machine_mode
#define Mmode machine_mode
#endif
/* Returns true iff all the registers in the operands array
@ -916,7 +916,7 @@ fr30_move_double (rtx * operands)
rtx dest = operands[0];
enum rtx_code src_code = GET_CODE (src);
enum rtx_code dest_code = GET_CODE (dest);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
rtx val;
start_sequence ();

152
gcc/config/frv/frv-protos.h
View File

@ -27,7 +27,7 @@ extern int frv_initial_elimination_offset (int, int);
extern void frv_ifcvt_machdep_init (void *);
#ifdef RTX_CODE
extern int frv_legitimate_address_p_1 (enum machine_mode, rtx,
extern int frv_legitimate_address_p_1 (machine_mode, rtx,
int, int, int);
extern rtx frv_find_base_term (rtx);
@ -42,11 +42,11 @@ extern int frv_expand_block_move (rtx *);
extern int frv_expand_block_clear (rtx *);
extern rtx frv_dynamic_chain_address (rtx);
extern rtx frv_return_addr_rtx (int, rtx);
extern rtx frv_index_memory (rtx, enum machine_mode, int);
extern rtx frv_index_memory (rtx, machine_mode, int);
extern const char *frv_asm_output_opcode
(FILE *, const char *);
extern void frv_final_prescan_insn (rtx_insn *, rtx *, int);
extern void frv_emit_move (enum machine_mode, rtx, rtx);
extern void frv_emit_move (machine_mode, rtx, rtx);
extern int frv_emit_movsi (rtx, rtx);
extern const char *output_move_single (rtx *, rtx);
extern const char *output_move_double (rtx *, rtx);
@ -73,12 +73,12 @@ extern void frv_ifcvt_modify_cancel (struct ce_if_block *);
#endif
extern enum reg_class frv_secondary_reload_class
(enum reg_class,
enum machine_mode, rtx);
extern int frv_hard_regno_mode_ok (int, enum machine_mode);
extern int frv_hard_regno_nregs (int, enum machine_mode);
machine_mode, rtx);
extern int frv_hard_regno_mode_ok (int, machine_mode);
extern int frv_hard_regno_nregs (int, machine_mode);
extern int frv_class_max_nregs (enum reg_class rclass,
enum machine_mode mode);
extern enum machine_mode frv_select_cc_mode (enum rtx_code, rtx, rtx);
machine_mode mode);
extern machine_mode frv_select_cc_mode (enum rtx_code, rtx, rtx);
#endif /* RTX_CODE */
extern int frv_trampoline_size (void);
@ -91,77 +91,77 @@ extern int frv_adjust_field_align (tree, int);
#endif
#ifdef RTX_CODE
extern int integer_register_operand (rtx, enum machine_mode);
extern int frv_load_operand (rtx, enum machine_mode);
extern int gpr_or_fpr_operand (rtx, enum machine_mode);
extern int gpr_no_subreg_operand (rtx, enum machine_mode);
extern int gpr_or_int6_operand (rtx, enum machine_mode);
extern int fpr_or_int6_operand (rtx, enum machine_mode);
extern int gpr_or_int_operand (rtx, enum machine_mode);
extern int gpr_or_int12_operand (rtx, enum machine_mode);
extern int gpr_fpr_or_int12_operand (rtx, enum machine_mode);
extern int gpr_or_int10_operand (rtx, enum machine_mode);
extern int move_source_operand (rtx, enum machine_mode);
extern int move_destination_operand (rtx, enum machine_mode);
extern int condexec_source_operand (rtx, enum machine_mode);
extern int condexec_dest_operand (rtx, enum machine_mode);
extern int lr_operand (rtx, enum machine_mode);
extern int gpr_or_memory_operand (rtx, enum machine_mode);
extern int fpr_or_memory_operand (rtx, enum machine_mode);
extern int reg_or_0_operand (rtx, enum machine_mode);
extern int fcc_operand (rtx, enum machine_mode);
extern int icc_operand (rtx, enum machine_mode);
extern int cc_operand (rtx, enum machine_mode);
extern int fcr_operand (rtx, enum machine_mode);
extern int icr_operand (rtx, enum machine_mode);
extern int cr_operand (rtx, enum machine_mode);
extern int call_operand (rtx, enum machine_mode);
extern int fpr_operand (rtx, enum machine_mode);
extern int even_reg_operand (rtx, enum machine_mode);
extern int odd_reg_operand (rtx, enum machine_mode);
extern int even_gpr_operand (rtx, enum machine_mode);
extern int odd_gpr_operand (rtx, enum machine_mode);
extern int quad_fpr_operand (rtx, enum machine_mode);
extern int even_fpr_operand (rtx, enum machine_mode);
extern int odd_fpr_operand (rtx, enum machine_mode);
extern int dbl_memory_one_insn_operand (rtx, enum machine_mode);
extern int dbl_memory_two_insn_operand (rtx, enum machine_mode);
extern int int12_operand (rtx, enum machine_mode);
extern int int6_operand (rtx, enum machine_mode);
extern int int5_operand (rtx, enum machine_mode);
extern int uint5_operand (rtx, enum machine_mode);
extern int uint4_operand (rtx, enum machine_mode);
extern int uint1_operand (rtx, enum machine_mode);
extern int int_2word_operand (rtx, enum machine_mode);
extern int pic_register_operand (rtx, enum machine_mode);
extern int pic_symbolic_operand (rtx, enum machine_mode);
extern int small_data_register_operand (rtx, enum machine_mode);
extern int small_data_symbolic_operand (rtx, enum machine_mode);
extern int upper_int16_operand (rtx, enum machine_mode);
extern int uint16_operand (rtx, enum machine_mode);
extern int symbolic_operand (rtx, enum machine_mode);
extern int relational_operator (rtx, enum machine_mode);
extern int signed_relational_operator (rtx, enum machine_mode);
extern int unsigned_relational_operator (rtx, enum machine_mode);
extern int float_relational_operator (rtx, enum machine_mode);
extern int ccr_eqne_operator (rtx, enum machine_mode);
extern int minmax_operator (rtx, enum machine_mode);
extern int condexec_si_binary_operator (rtx, enum machine_mode);
extern int condexec_si_media_operator (rtx, enum machine_mode);
extern int condexec_si_divide_operator (rtx, enum machine_mode);
extern int condexec_si_unary_operator (rtx, enum machine_mode);
extern int condexec_sf_conv_operator (rtx, enum machine_mode);
extern int condexec_sf_add_operator (rtx, enum machine_mode);
extern int condexec_memory_operand (rtx, enum machine_mode);
extern int intop_compare_operator (rtx, enum machine_mode);
extern int acc_operand (rtx, enum machine_mode);
extern int even_acc_operand (rtx, enum machine_mode);
extern int quad_acc_operand (rtx, enum machine_mode);
extern int accg_operand (rtx, enum machine_mode);
extern int integer_register_operand (rtx, machine_mode);
extern int frv_load_operand (rtx, machine_mode);
extern int gpr_or_fpr_operand (rtx, machine_mode);
extern int gpr_no_subreg_operand (rtx, machine_mode);
extern int gpr_or_int6_operand (rtx, machine_mode);
extern int fpr_or_int6_operand (rtx, machine_mode);
extern int gpr_or_int_operand (rtx, machine_mode);
extern int gpr_or_int12_operand (rtx, machine_mode);
extern int gpr_fpr_or_int12_operand (rtx, machine_mode);
extern int gpr_or_int10_operand (rtx, machine_mode);
extern int move_source_operand (rtx, machine_mode);
extern int move_destination_operand (rtx, machine_mode);
extern int condexec_source_operand (rtx, machine_mode);
extern int condexec_dest_operand (rtx, machine_mode);
extern int lr_operand (rtx, machine_mode);
extern int gpr_or_memory_operand (rtx, machine_mode);
extern int fpr_or_memory_operand (rtx, machine_mode);
extern int reg_or_0_operand (rtx, machine_mode);
extern int fcc_operand (rtx, machine_mode);
extern int icc_operand (rtx, machine_mode);
extern int cc_operand (rtx, machine_mode);
extern int fcr_operand (rtx, machine_mode);
extern int icr_operand (rtx, machine_mode);
extern int cr_operand (rtx, machine_mode);
extern int call_operand (rtx, machine_mode);
extern int fpr_operand (rtx, machine_mode);
extern int even_reg_operand (rtx, machine_mode);
extern int odd_reg_operand (rtx, machine_mode);
extern int even_gpr_operand (rtx, machine_mode);
extern int odd_gpr_operand (rtx, machine_mode);
extern int quad_fpr_operand (rtx, machine_mode);
extern int even_fpr_operand (rtx, machine_mode);
extern int odd_fpr_operand (rtx, machine_mode);
extern int dbl_memory_one_insn_operand (rtx, machine_mode);
extern int dbl_memory_two_insn_operand (rtx, machine_mode);
extern int int12_operand (rtx, machine_mode);
extern int int6_operand (rtx, machine_mode);
extern int int5_operand (rtx, machine_mode);
extern int uint5_operand (rtx, machine_mode);
extern int uint4_operand (rtx, machine_mode);
extern int uint1_operand (rtx, machine_mode);
extern int int_2word_operand (rtx, machine_mode);
extern int pic_register_operand (rtx, machine_mode);
extern int pic_symbolic_operand (rtx, machine_mode);
extern int small_data_register_operand (rtx, machine_mode);
extern int small_data_symbolic_operand (rtx, machine_mode);
extern int upper_int16_operand (rtx, machine_mode);
extern int uint16_operand (rtx, machine_mode);
extern int symbolic_operand (rtx, machine_mode);
extern int relational_operator (rtx, machine_mode);
extern int signed_relational_operator (rtx, machine_mode);
extern int unsigned_relational_operator (rtx, machine_mode);
extern int float_relational_operator (rtx, machine_mode);
extern int ccr_eqne_operator (rtx, machine_mode);
extern int minmax_operator (rtx, machine_mode);
extern int condexec_si_binary_operator (rtx, machine_mode);
extern int condexec_si_media_operator (rtx, machine_mode);
extern int condexec_si_divide_operator (rtx, machine_mode);
extern int condexec_si_unary_operator (rtx, machine_mode);
extern int condexec_sf_conv_operator (rtx, machine_mode);
extern int condexec_sf_add_operator (rtx, machine_mode);
extern int condexec_memory_operand (rtx, machine_mode);
extern int intop_compare_operator (rtx, machine_mode);
extern int acc_operand (rtx, machine_mode);
extern int even_acc_operand (rtx, machine_mode);
extern int quad_acc_operand (rtx, machine_mode);
extern int accg_operand (rtx, machine_mode);
extern rtx frv_matching_accg_for_acc (rtx);
extern void frv_expand_fdpic_call (rtx *, bool, bool);
extern rtx frv_gen_GPsym2reg (rtx, rtx);
extern int frv_legitimate_memory_operand (rtx, enum machine_mode, int);
extern int frv_legitimate_memory_operand (rtx, machine_mode, int);
/* Information about a relocation unspec. SYMBOL is the relocation symbol
(a SYMBOL_REF or LABEL_REF), RELOC is the type of relocation and OFFSET

162
gcc/config/frv/frv.c
View File

@ -275,7 +275,7 @@ static frv_stack_t *frv_stack_cache = (frv_stack_t *)0;
/* Forward references */
static void frv_option_override (void);
static bool frv_legitimate_address_p (enum machine_mode, rtx, bool);
static bool frv_legitimate_address_p (machine_mode, rtx, bool);
static int frv_default_flags_for_cpu (void);
static int frv_string_begins_with (const char *, const char *);
static FRV_INLINE bool frv_small_data_reloc_p (rtx, int);
@ -289,17 +289,17 @@ static int frv_print_operand_jump_hint (rtx_insn *);
static const char *comparison_string (enum rtx_code, rtx);
static rtx frv_function_value (const_tree, const_tree,
bool);
static rtx frv_libcall_value (enum machine_mode,
static rtx frv_libcall_value (machine_mode,
const_rtx);
static FRV_INLINE int frv_regno_ok_for_base_p (int, int);
static rtx single_set_pattern (rtx);
static int frv_function_contains_far_jump (void);
static rtx frv_alloc_temp_reg (frv_tmp_reg_t *,
enum reg_class,
enum machine_mode,
machine_mode,
int, int);
static rtx frv_frame_offset_rtx (int);
static rtx frv_frame_mem (enum machine_mode, rtx, int);
static rtx frv_frame_mem (machine_mode, rtx, int);
static rtx frv_dwarf_store (rtx, int);
static void frv_frame_insn (rtx, rtx);
static void frv_frame_access (frv_frame_accessor_t*,
@ -310,14 +310,14 @@ static void frv_frame_access_standard_regs (enum frv_stack_op,
frv_stack_t *);
static struct machine_function *frv_init_machine_status (void);
static rtx frv_int_to_acc (enum insn_code, int, rtx);
static enum machine_mode frv_matching_accg_mode (enum machine_mode);
static machine_mode frv_matching_accg_mode (machine_mode);
static rtx frv_read_argument (tree, unsigned int);
static rtx frv_read_iacc_argument (enum machine_mode, tree, unsigned int);
static rtx frv_read_iacc_argument (machine_mode, tree, unsigned int);
static int frv_check_constant_argument (enum insn_code, int, rtx);
static rtx frv_legitimize_target (enum insn_code, rtx);
static rtx frv_legitimize_argument (enum insn_code, int, rtx);
static rtx frv_legitimize_tls_address (rtx, enum tls_model);
static rtx frv_legitimize_address (rtx, rtx, enum machine_mode);
static rtx frv_legitimize_address (rtx, rtx, machine_mode);
static rtx frv_expand_set_builtin (enum insn_code, tree, rtx);
static rtx frv_expand_unop_builtin (enum insn_code, tree, rtx);
static rtx frv_expand_binop_builtin (enum insn_code, tree, rtx);
@ -336,7 +336,7 @@ static void frv_split_iacc_move (rtx, rtx);
static rtx frv_emit_comparison (enum rtx_code, rtx, rtx);
static int frv_clear_registers_used (rtx *, void *);
static void frv_ifcvt_add_insn (rtx, rtx, int);
static rtx frv_ifcvt_rewrite_mem (rtx, enum machine_mode, rtx);
static rtx frv_ifcvt_rewrite_mem (rtx, machine_mode, rtx);
static rtx frv_ifcvt_load_value (rtx, rtx);
static int frv_acc_group_1 (rtx *, void *);
static unsigned int frv_insn_unit (rtx_insn *);
@ -371,47 +371,47 @@ static void frv_function_prologue (FILE *, HOST_WIDE_INT);
static void frv_function_epilogue (FILE *, HOST_WIDE_INT);
static bool frv_assemble_integer (rtx, unsigned, int);
static void frv_init_builtins (void);
static rtx frv_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
static rtx frv_expand_builtin (tree, rtx, rtx, machine_mode, int);
static void frv_init_libfuncs (void);
static bool frv_in_small_data_p (const_tree);
static void frv_asm_output_mi_thunk
(FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
static void frv_setup_incoming_varargs (cumulative_args_t,
enum machine_mode,
machine_mode,
tree, int *, int);
static rtx frv_expand_builtin_saveregs (void);
static void frv_expand_builtin_va_start (tree, rtx);
static bool frv_rtx_costs (rtx, int, int, int, int*,
bool);
static int frv_register_move_cost (enum machine_mode,
static int frv_register_move_cost (machine_mode,
reg_class_t, reg_class_t);
static int frv_memory_move_cost (enum machine_mode,
static int frv_memory_move_cost (machine_mode,
reg_class_t, bool);
static void frv_asm_out_constructor (rtx, int);
static void frv_asm_out_destructor (rtx, int);
static bool frv_function_symbol_referenced_p (rtx);
static bool frv_legitimate_constant_p (enum machine_mode, rtx);
static bool frv_cannot_force_const_mem (enum machine_mode, rtx);
static bool frv_legitimate_constant_p (machine_mode, rtx);
static bool frv_cannot_force_const_mem (machine_mode, rtx);
static const char *unspec_got_name (int);
static void frv_output_const_unspec (FILE *,
const struct frv_unspec *);
static bool frv_function_ok_for_sibcall (tree, tree);
static rtx frv_struct_value_rtx (tree, int);
static bool frv_must_pass_in_stack (enum machine_mode mode, const_tree type);
static int frv_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static bool frv_must_pass_in_stack (machine_mode mode, const_tree type);
static int frv_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx frv_function_arg (cumulative_args_t, enum machine_mode,
static rtx frv_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx frv_function_incoming_arg (cumulative_args_t, enum machine_mode,
static rtx frv_function_incoming_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static void frv_function_arg_advance (cumulative_args_t, enum machine_mode,
static void frv_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static unsigned int frv_function_arg_boundary (enum machine_mode,
static unsigned int frv_function_arg_boundary (machine_mode,
const_tree);
static void frv_output_dwarf_dtprel (FILE *, int, rtx)
ATTRIBUTE_UNUSED;
static reg_class_t frv_secondary_reload (bool, rtx, reg_class_t,
enum machine_mode,
machine_mode,
secondary_reload_info *);
static bool frv_frame_pointer_required (void);
static bool frv_can_eliminate (const int, const int);
@ -612,7 +612,7 @@ frv_const_unspec_p (rtx x, struct frv_unspec *unspec)
4. In many cases, it's more efficient to calculate the constant in-line. */
static bool
frv_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED,
frv_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED,
rtx x ATTRIBUTE_UNUSED)
{
return TARGET_FDPIC;
@ -1496,7 +1496,7 @@ static rtx
frv_alloc_temp_reg (
frv_tmp_reg_t *info, /* which registers are available */
enum reg_class rclass, /* register class desired */
enum machine_mode mode, /* mode to allocate register with */
machine_mode mode, /* mode to allocate register with */
int mark_as_used, /* register not available after allocation */
int no_abort) /* return NULL instead of aborting */
{
@ -1560,7 +1560,7 @@ frv_frame_offset_rtx (int offset)
/* Generate (mem:MODE (plus:Pmode BASE (frv_frame_offset OFFSET)))). The
prologue and epilogue uses such expressions to access the stack. */
static rtx
frv_frame_mem (enum machine_mode mode, rtx base, int offset)
frv_frame_mem (machine_mode mode, rtx base, int offset)
{
return gen_rtx_MEM (mode, gen_rtx_PLUS (Pmode,
base,
@ -1623,7 +1623,7 @@ frv_frame_insn (rtx pattern, rtx dwarf_pattern)
static void
frv_frame_access (frv_frame_accessor_t *accessor, rtx reg, int stack_offset)
{
enum machine_mode mode = GET_MODE (reg);
machine_mode mode = GET_MODE (reg);
rtx mem = frv_frame_mem (mode,
accessor->base,
stack_offset - accessor->base_offset);
@ -2138,7 +2138,7 @@ frv_initial_elimination_offset (int from, int to)
static void
frv_setup_incoming_varargs (cumulative_args_t cum_v,
enum machine_mode mode,
machine_mode mode,
tree type ATTRIBUTE_UNUSED,
int *pretend_size,
int second_time)
@ -2235,7 +2235,7 @@ frv_expand_block_move (rtx operands[])
rtx tmp_reg;
rtx stores[MAX_MOVE_REG];
int move_bytes;
enum machine_mode mode;
machine_mode mode;
/* If this is not a fixed size move, just call memcpy. */
if (! constp)
@ -2326,7 +2326,7 @@ frv_expand_block_clear (rtx operands[])
rtx dest_addr;
rtx dest_mem;
int clear_bytes;
enum machine_mode mode;
machine_mode mode;
/* If this is not a fixed size move, just call memcpy. */
if (! constp)
@ -2481,7 +2481,7 @@ frv_return_addr_rtx (int count, rtx frame)
frv_legitimate_address_p forbids register+register addresses, which
this function cannot handle. */
rtx
frv_index_memory (rtx memref, enum machine_mode mode, int index)
frv_index_memory (rtx memref, machine_mode mode, int index)
{
rtx base = XEXP (memref, 0);
if (GET_CODE (base) == PRE_MODIFY)
@ -3111,7 +3111,7 @@ frv_init_cumulative_args (CUMULATIVE_ARGS *cum,
in registers. */
static bool
frv_must_pass_in_stack (enum machine_mode mode, const_tree type)
frv_must_pass_in_stack (machine_mode mode, const_tree type)
{
if (mode == BLKmode)
return true;
@ -3125,20 +3125,20 @@ frv_must_pass_in_stack (enum machine_mode mode, const_tree type)
`PARM_BOUNDARY' is used for all arguments. */
static unsigned int
frv_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
frv_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED)
{
return BITS_PER_WORD;
}
static rtx
frv_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
frv_function_arg_1 (cumulative_args_t cum_v, machine_mode mode,
const_tree type ATTRIBUTE_UNUSED, bool named,
bool incoming ATTRIBUTE_UNUSED)
{
const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
machine_mode xmode = (mode == BLKmode) ? SImode : mode;
int arg_num = *cum;
rtx ret;
const char *debstr;
@ -3171,14 +3171,14 @@ frv_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
}
static rtx
frv_function_arg (cumulative_args_t cum, enum machine_mode mode,
frv_function_arg (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
return frv_function_arg_1 (cum, mode, type, named, false);
}
static rtx
frv_function_incoming_arg (cumulative_args_t cum, enum machine_mode mode,
frv_function_incoming_arg (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
return frv_function_arg_1 (cum, mode, type, named, true);
@ -3196,13 +3196,13 @@ frv_function_incoming_arg (cumulative_args_t cum, enum machine_mode mode,
static void
frv_function_arg_advance (cumulative_args_t cum_v,
enum machine_mode mode,
machine_mode mode,
const_tree type ATTRIBUTE_UNUSED,
bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
machine_mode xmode = (mode == BLKmode) ? SImode : mode;
int bytes = GET_MODE_SIZE (xmode);
int words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
int arg_num = *cum;
@ -3233,11 +3233,11 @@ frv_function_arg_advance (cumulative_args_t cum_v,
the called function. */
static int
frv_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
frv_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
{
enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
machine_mode xmode = (mode == BLKmode) ? SImode : mode;
int bytes = GET_MODE_SIZE (xmode);
int words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
int arg_num = *get_cumulative_args (cum);
@ -3269,7 +3269,7 @@ frv_function_value (const_tree valtype,
/* Implements TARGET_LIBCALL_VALUE. */
static rtx
frv_libcall_value (enum machine_mode mode,
frv_libcall_value (machine_mode mode,
const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, RETURN_VALUE_REGNUM);
@ -3337,7 +3337,7 @@ frv_regno_ok_for_base_p (int regno, int strict_p)
will be given to `TARGET_PRINT_OPERAND_ADDRESS'. */
int
frv_legitimate_address_p_1 (enum machine_mode mode,
frv_legitimate_address_p_1 (machine_mode mode,
rtx x,
int strict_p,
int condexec_p,
@ -3469,7 +3469,7 @@ frv_legitimate_address_p_1 (enum machine_mode mode,
}
bool
frv_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
frv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
{
return frv_legitimate_address_p_1 (mode, x, strict_p, FALSE, FALSE);
}
@ -3636,7 +3636,7 @@ frv_legitimize_tls_address (rtx addr, enum tls_model model)
rtx
frv_legitimize_address (rtx x,
rtx oldx ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED)
machine_mode mode ATTRIBUTE_UNUSED)
{
if (GET_CODE (x) == SYMBOL_REF)
{
@ -3765,7 +3765,7 @@ frv_find_base_term (rtx x)
the operand is used by a predicated instruction. */
int
frv_legitimate_memory_operand (rtx op, enum machine_mode mode, int condexec_p)
frv_legitimate_memory_operand (rtx op, machine_mode mode, int condexec_p)
{
return ((GET_MODE (op) == mode || mode == VOIDmode)
&& GET_CODE (op) == MEM
@ -3906,9 +3906,9 @@ frv_function_symbol_referenced_p (rtx x)
executed. */
int
condexec_memory_operand (rtx op, enum machine_mode mode)
condexec_memory_operand (rtx op, machine_mode mode)
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
rtx addr;
if (mode != VOIDmode && op_mode != mode)
@ -3950,7 +3950,7 @@ direct_return_p (void)
void
frv_emit_move (enum machine_mode mode, rtx dest, rtx src)
frv_emit_move (machine_mode mode, rtx dest, rtx src)
{
if (GET_CODE (src) == SYMBOL_REF)
{
@ -4248,7 +4248,7 @@ output_move_single (rtx operands[], rtx insn)
if (GET_CODE (dest) == REG)
{
int dest_regno = REGNO (dest);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
if (GPR_P (dest_regno))
{
@ -4386,7 +4386,7 @@ output_move_single (rtx operands[], rtx insn)
if (GET_CODE (src) == REG)
{
int src_regno = REGNO (src);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
if (GPR_P (src_regno))
{
@ -4459,7 +4459,7 @@ output_move_double (rtx operands[], rtx insn)
{
rtx dest = operands[0];
rtx src = operands[1];
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
if (GET_CODE (dest) == REG)
{
@ -4594,7 +4594,7 @@ output_condmove_single (rtx operands[], rtx insn)
if (GET_CODE (dest) == REG)
{
int dest_regno = REGNO (dest);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
if (GPR_P (dest_regno))
{
@ -4670,7 +4670,7 @@ output_condmove_single (rtx operands[], rtx insn)
if (GET_CODE (src) == REG)
{
int src_regno = REGNO (src);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
if (GPR_P (src_regno))
{
@ -4697,7 +4697,7 @@ output_condmove_single (rtx operands[], rtx insn)
else if (ZERO_P (src))
{
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
switch (mode)
{
default:
@ -4727,7 +4727,7 @@ output_condmove_single (rtx operands[], rtx insn)
static rtx
frv_emit_comparison (enum rtx_code test, rtx op0, rtx op1)
{
enum machine_mode cc_mode;
machine_mode cc_mode;
rtx cc_reg;
/* Floating point doesn't have comparison against a constant. */
@ -4761,7 +4761,7 @@ frv_emit_cond_branch (rtx operands[])
rtx if_else;
enum rtx_code test = GET_CODE (operands[0]);
rtx cc_reg = frv_emit_comparison (test, operands[1], operands[2]);
enum machine_mode cc_mode = GET_MODE (cc_reg);
machine_mode cc_mode = GET_MODE (cc_reg);
/* Branches generate:
(set (pc)
@ -4856,7 +4856,7 @@ frv_emit_cond_move (rtx dest, rtx test_rtx, rtx src1, rtx src2)
enum rtx_code test = GET_CODE (test_rtx);
rtx cc_reg = frv_emit_comparison (test,
XEXP (test_rtx, 0), XEXP (test_rtx, 1));
enum machine_mode cc_mode = GET_MODE (cc_reg);
machine_mode cc_mode = GET_MODE (cc_reg);
/* Conditional move instructions generate:
(parallel [(set <target>
@ -4933,7 +4933,7 @@ frv_split_cond_move (rtx operands[])
rtx src2 = operands[4];
rtx cr_reg = operands[5];
rtx ret;
enum machine_mode cr_mode = GET_MODE (cr_reg);
machine_mode cr_mode = GET_MODE (cr_reg);
start_sequence ();
@ -5086,7 +5086,7 @@ frv_split_minmax (rtx operands[])
rtx cr_reg = operands[5];
rtx ret;
enum rtx_code test_code;
enum machine_mode cr_mode = GET_MODE (cr_reg);
machine_mode cr_mode = GET_MODE (cr_reg);
start_sequence ();
@ -5278,7 +5278,7 @@ frv_ifcvt_modify_tests (ce_if_block *ce_info, rtx *p_true, rtx *p_false)
rtx cr;
rtx cc;
rtx nested_cc;
enum machine_mode mode = GET_MODE (true_expr);
machine_mode mode = GET_MODE (true_expr);
int j;
basic_block *bb;
int num_bb;
@ -5644,7 +5644,7 @@ frv_ifcvt_modify_multiple_tests (ce_if_block *ce_info,
rtx compare;
rtx cc;
enum reg_class cr_class;
enum machine_mode mode = GET_MODE (true_expr);
machine_mode mode = GET_MODE (true_expr);
rtx (*logical_func)(rtx, rtx, rtx);
if (TARGET_DEBUG_COND_EXEC)
@ -5827,7 +5827,7 @@ frv_ifcvt_load_value (rtx value, rtx insn ATTRIBUTE_UNUSED)
into a temporary register, or the new MEM if we were successful. */
static rtx
frv_ifcvt_rewrite_mem (rtx mem, enum machine_mode mode, rtx insn)
frv_ifcvt_rewrite_mem (rtx mem, machine_mode mode, rtx insn)
{
rtx addr = XEXP (mem, 0);
@ -5980,7 +5980,7 @@ frv_ifcvt_modify_insn (ce_if_block *ce_info,
{
rtx dest = SET_DEST (set);
rtx src = SET_SRC (set);
enum machine_mode mode = GET_MODE (dest);
machine_mode mode = GET_MODE (dest);
/* Check for normal binary operators. */
if (mode == SImode && ARITHMETIC_P (src))
@ -6367,7 +6367,7 @@ frv_trampoline_init (rtx m_tramp, tree fndecl, rtx static_chain)
enum reg_class
frv_secondary_reload_class (enum reg_class rclass,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
rtx x)
{
enum reg_class ret;
@ -6428,7 +6428,7 @@ frv_secondary_reload_class (enum reg_class rclass,
static reg_class_t
frv_secondary_reload (bool in_p, rtx x, reg_class_t reload_class_i,
enum machine_mode reload_mode,
machine_mode reload_mode,
secondary_reload_info * sri)
{
enum reg_class rclass = NO_REGS;
@ -6635,7 +6635,7 @@ frv_adjust_field_align (tree field, int computed)
pattern's constraint asks for one. */
int
frv_hard_regno_mode_ok (int regno, enum machine_mode mode)
frv_hard_regno_mode_ok (int regno, machine_mode mode)
{
int base;
int mask;
@ -6718,7 +6718,7 @@ frv_hard_regno_mode_ok (int regno, enum machine_mode mode)
for each byte. */
int
frv_hard_regno_nregs (int regno, enum machine_mode mode)
frv_hard_regno_nregs (int regno, machine_mode mode)
{
if (ACCG_P (regno))
return GET_MODE_SIZE (mode);
@ -6740,7 +6740,7 @@ frv_hard_regno_nregs (int regno, enum machine_mode mode)
This declaration is required. */
int
frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode)
frv_class_max_nregs (enum reg_class rclass, machine_mode mode)
{
if (rclass == ACCG_REGS)
/* An N-byte value requires N accumulator guards. */
@ -6756,7 +6756,7 @@ frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode)
definition for this macro on machines where anything `CONSTANT_P' is valid. */
static bool
frv_legitimate_constant_p (enum machine_mode mode, rtx x)
frv_legitimate_constant_p (machine_mode mode, rtx x)
{
/* frv_cannot_force_const_mem always returns true for FDPIC. This
means that the move expanders will be expected to deal with most
@ -6803,7 +6803,7 @@ frv_legitimate_constant_p (enum machine_mode mode, rtx x)
is enough, CC_UNS for other unsigned comparisons, and CC for other
signed comparisons. */
enum machine_mode
machine_mode
frv_select_cc_mode (enum rtx_code code, rtx x, rtx y)
{
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
@ -6836,7 +6836,7 @@ frv_select_cc_mode (enum rtx_code code, rtx x, rtx y)
#define LOW_COST 1
static int
frv_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
frv_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t from, reg_class_t to)
{
switch (from)
@ -6940,7 +6940,7 @@ frv_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
/* Worker function for TARGET_MEMORY_MOVE_COST. */
static int
frv_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
frv_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -8701,8 +8701,8 @@ frv_int_to_acc (enum insn_code icode, int opnum, rtx opval)
/* If an ACC rtx has mode MODE, return the mode that the matching ACCG
should have. */
static enum machine_mode
frv_matching_accg_mode (enum machine_mode mode)
static machine_mode
frv_matching_accg_mode (machine_mode mode)
{
switch (mode)
{
@ -8756,7 +8756,7 @@ frv_read_argument (tree exp, unsigned int index)
of an IACC register and return a (reg:MODE ...) rtx for it. */
static rtx
frv_read_iacc_argument (enum machine_mode mode, tree call,
frv_read_iacc_argument (machine_mode mode, tree call,
unsigned int index)
{
int i, regno;
@ -8809,7 +8809,7 @@ frv_check_constant_argument (enum insn_code icode, int opnum, rtx opval)
static rtx
frv_legitimize_target (enum insn_code icode, rtx target)
{
enum machine_mode mode = insn_data[icode].operand[0].mode;
machine_mode mode = insn_data[icode].operand[0].mode;
if (! target
|| GET_MODE (target) != mode
@ -8827,7 +8827,7 @@ frv_legitimize_target (enum insn_code icode, rtx target)
static rtx
frv_legitimize_argument (enum insn_code icode, int opnum, rtx arg)
{
enum machine_mode mode = insn_data[icode].operand[opnum].mode;
machine_mode mode = insn_data[icode].operand[opnum].mode;
if ((*insn_data[icode].operand[opnum].predicate) (arg, mode))
return arg;
@ -8838,7 +8838,7 @@ frv_legitimize_argument (enum insn_code icode, int opnum, rtx arg)
/* Return a volatile memory reference of mode MODE whose address is ARG. */
static rtx
frv_volatile_memref (enum machine_mode mode, rtx arg)
frv_volatile_memref (machine_mode mode, rtx arg)
{
rtx mem;
@ -8970,7 +8970,7 @@ frv_expand_voidbinop_builtin (enum insn_code icode, tree call)
rtx pat;
rtx op0 = frv_read_argument (call, 0);
rtx op1 = frv_read_argument (call, 1);
enum machine_mode mode0 = insn_data[icode].operand[0].mode;
machine_mode mode0 = insn_data[icode].operand[0].mode;
rtx addr;
if (GET_CODE (op0) != MEM)
@ -9099,7 +9099,7 @@ frv_expand_voidaccop_builtin (enum insn_code icode, tree call)
membar and TARGET_MODE is the mode that the loaded value should have. */
static rtx
frv_expand_load_builtin (enum insn_code icode, enum machine_mode target_mode,
frv_expand_load_builtin (enum insn_code icode, machine_mode target_mode,
tree call, rtx target)
{
rtx op0 = frv_read_argument (call, 0);
@ -9252,7 +9252,7 @@ frv_expand_mwtacc_builtin (enum insn_code icode, tree call)
static void
frv_split_iacc_move (rtx dest, rtx src)
{
enum machine_mode inner;
machine_mode inner;
int i;
inner = GET_MODE (dest);
@ -9267,7 +9267,7 @@ static rtx
frv_expand_builtin (tree exp,
rtx target,
rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);

14
gcc/config/frv/predicates.md
View File

@ -1216,7 +1216,7 @@
(define_predicate "ccr_eqne_operator"
(match_code "eq,ne")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
rtx op0;
rtx op1;
int regno;
@ -1279,7 +1279,7 @@
(define_predicate "condexec_si_binary_operator"
(match_code "plus,minus,and,ior,xor,ashift,ashiftrt,lshiftrt")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;
@ -1307,7 +1307,7 @@
(define_predicate "condexec_si_media_operator"
(match_code "and,ior,xor")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;
@ -1330,7 +1330,7 @@
(define_predicate "condexec_si_divide_operator"
(match_code "div,udiv")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;
@ -1352,7 +1352,7 @@
(define_predicate "condexec_si_unary_operator"
(match_code "not,neg")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;
@ -1375,7 +1375,7 @@
(define_predicate "condexec_sf_add_operator"
(match_code "plus,minus")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;
@ -1397,7 +1397,7 @@
(define_predicate "condexec_sf_conv_operator"
(match_code "abs,neg")
{
enum machine_mode op_mode = GET_MODE (op);
machine_mode op_mode = GET_MODE (op);
if (mode != VOIDmode && op_mode != mode)
return FALSE;

18
gcc/config/h8300/h8300-protos.h
View File

@ -36,22 +36,22 @@ extern const char *output_simode_bld (int, rtx[]);
extern void final_prescan_insn (rtx_insn *, rtx *, int);
extern int h8300_expand_movsi (rtx[]);
extern void notice_update_cc (rtx, rtx_insn *);
extern const char *output_logical_op (enum machine_mode, rtx *);
extern unsigned int compute_logical_op_length (enum machine_mode,
extern const char *output_logical_op (machine_mode, rtx *);
extern unsigned int compute_logical_op_length (machine_mode,
rtx *);
#ifdef HAVE_ATTR_cc
extern enum attr_cc compute_plussi_cc (rtx *);
extern enum attr_cc compute_a_shift_cc (rtx, rtx *);
extern enum attr_cc compute_logical_op_cc (enum machine_mode, rtx *);
extern enum attr_cc compute_logical_op_cc (machine_mode, rtx *);
#endif
extern void h8300_expand_branch (rtx[]);
extern void h8300_expand_store (rtx[]);
extern bool expand_a_shift (enum machine_mode, enum rtx_code, rtx[]);
extern int h8300_shift_needs_scratch_p (int, enum machine_mode);
extern bool expand_a_shift (machine_mode, enum rtx_code, rtx[]);
extern int h8300_shift_needs_scratch_p (int, machine_mode);
extern int expand_a_rotate (rtx[]);
extern int fix_bit_operand (rtx *, enum rtx_code);
extern int h8300_adjust_insn_length (rtx, int);
extern void split_adds_subs (enum machine_mode, rtx[]);
extern void split_adds_subs (machine_mode, rtx[]);
extern int h8300_eightbit_constant_address_p (rtx);
extern int h8300_tiny_constant_address_p (rtx);
@ -81,7 +81,7 @@ enum h8sx_shift_type {
H8SX_SHIFT_BINARY
};
extern enum h8sx_shift_type h8sx_classify_shift (enum machine_mode, enum rtx_code, rtx);
extern enum h8sx_shift_type h8sx_classify_shift (machine_mode, enum rtx_code, rtx);
extern int h8300_ldm_stm_parallel (rtvec, int, int);
#endif /* RTX_CODE */
@ -99,8 +99,8 @@ extern int h8300_current_function_monitor_function_p (void);
extern int h8300_initial_elimination_offset (int, int);
extern int h8300_regs_ok_for_stm (int, rtx[]);
extern int h8300_hard_regno_rename_ok (unsigned int, unsigned int);
extern int h8300_hard_regno_nregs (int, enum machine_mode);
extern int h8300_hard_regno_mode_ok (int, enum machine_mode);
extern int h8300_hard_regno_nregs (int, machine_mode);
extern int h8300_hard_regno_mode_ok (int, machine_mode);
extern bool h8300_move_ok (rtx, rtx);
struct cpp_reader;

54
gcc/config/h8300/h8300.c
View File

@ -115,7 +115,7 @@ static bool h8300_print_operand_punct_valid_p (unsigned char code);
#ifndef OBJECT_FORMAT_ELF
static void h8300_asm_named_section (const char *, unsigned int, tree);
#endif
static int h8300_register_move_cost (enum machine_mode, reg_class_t, reg_class_t);
static int h8300_register_move_cost (machine_mode, reg_class_t, reg_class_t);
static int h8300_and_costs (rtx);
static int h8300_shift_costs (rtx);
static void h8300_push_pop (int, int, bool, bool);
@ -133,7 +133,7 @@ static unsigned int h8300_binary_length (rtx_insn *, const h8300_lengt
static bool h8300_short_move_mem_p (rtx, enum rtx_code);
static unsigned int h8300_move_length (rtx *, const h8300_length_table *);
static bool h8300_hard_regno_scratch_ok (unsigned int);
static rtx h8300_get_index (rtx, enum machine_mode mode, int *);
static rtx h8300_get_index (rtx, machine_mode mode, int *);
/* CPU_TYPE, says what cpu we're compiling for. */
int cpu_type;
@ -1014,7 +1014,7 @@ h8300_file_end (void)
instead of adds/subs. */
void
split_adds_subs (enum machine_mode mode, rtx *operands)
split_adds_subs (machine_mode mode, rtx *operands)
{
HOST_WIDE_INT val = INTVAL (operands[1]);
rtx reg = operands[0];
@ -1087,7 +1087,7 @@ h8300_pr_saveall (struct cpp_reader *pfile ATTRIBUTE_UNUSED)
case the first 3 arguments are passed in registers. */
static rtx
h8300_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
h8300_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1160,7 +1160,7 @@ h8300_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
(TYPE is null for libcalls where that information may not be available.) */
static void
h8300_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
h8300_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1178,7 +1178,7 @@ h8300_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
shortcuts. */
static int
h8300_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
h8300_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t from, reg_class_t to)
{
if (from == MAC_REGS || to == MAC_REG)
@ -2117,7 +2117,7 @@ notice_update_cc (rtx body, rtx_insn *insn)
if the address is known to be valid, but its mode is unknown. */
static rtx
h8300_get_index (rtx x, enum machine_mode mode, int *size)
h8300_get_index (rtx x, machine_mode mode, int *size)
{
int dummy, factor;
@ -2792,7 +2792,7 @@ compute_mov_length (rtx *operands)
length, assuming the largest addressing mode is used, and then
adjust later in the function. Otherwise, we compute and return
the exact length in one step. */
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx dest = operands[0];
rtx src = operands[1];
rtx addr;
@ -3042,7 +3042,7 @@ compute_mov_length (rtx *operands)
const char *
output_plussi (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
gcc_assert (mode == SImode);
@ -3126,7 +3126,7 @@ output_plussi (rtx *operands)
unsigned int
compute_plussi_length (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
gcc_assert (mode == SImode);
@ -3205,7 +3205,7 @@ compute_plussi_length (rtx *operands)
enum attr_cc
compute_plussi_cc (rtx *operands)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
gcc_assert (mode == SImode);
@ -3260,7 +3260,7 @@ compute_plussi_cc (rtx *operands)
/* Output a logical insn. */
const char *
output_logical_op (enum machine_mode mode, rtx *operands)
output_logical_op (machine_mode mode, rtx *operands)
{
/* Figure out the logical op that we need to perform. */
enum rtx_code code = GET_CODE (operands[3]);
@ -3441,7 +3441,7 @@ output_logical_op (enum machine_mode mode, rtx *operands)
/* Compute the length of a logical insn. */
unsigned int
compute_logical_op_length (enum machine_mode mode, rtx *operands)
compute_logical_op_length (machine_mode mode, rtx *operands)
{
/* Figure out the logical op that we need to perform. */
enum rtx_code code = GET_CODE (operands[3]);
@ -3587,7 +3587,7 @@ compute_logical_op_length (enum machine_mode mode, rtx *operands)
/* Compute which flag bits are valid after a logical insn. */
enum attr_cc
compute_logical_op_cc (enum machine_mode mode, rtx *operands)
compute_logical_op_cc (machine_mode mode, rtx *operands)
{
/* Figure out the logical op that we need to perform. */
enum rtx_code code = GET_CODE (operands[3]);
@ -3745,7 +3745,7 @@ h8300_expand_store (rtx operands[])
/* Classify a shift with the given mode and code. OP is the shift amount. */
enum h8sx_shift_type
h8sx_classify_shift (enum machine_mode mode, enum rtx_code code, rtx op)
h8sx_classify_shift (machine_mode mode, enum rtx_code code, rtx op)
{
if (!TARGET_H8300SX)
return H8SX_SHIFT_NONE;
@ -3837,7 +3837,7 @@ output_h8sx_shift (rtx *operands, int suffix, int optype)
/* Emit code to do shifts. */
bool
expand_a_shift (enum machine_mode mode, enum rtx_code code, rtx operands[])
expand_a_shift (machine_mode mode, enum rtx_code code, rtx operands[])
{
switch (h8sx_classify_shift (mode, code, operands[2]))
{
@ -4516,7 +4516,7 @@ get_shift_alg (enum shift_type shift_type, enum shift_mode shift_mode,
needed for some shift with COUNT and MODE. Return 0 otherwise. */
int
h8300_shift_needs_scratch_p (int count, enum machine_mode mode)
h8300_shift_needs_scratch_p (int count, machine_mode mode)
{
enum h8_cpu cpu;
int a, lr, ar;
@ -4569,7 +4569,7 @@ output_a_shift (rtx *operands)
{
static int loopend_lab;
rtx shift = operands[3];
enum machine_mode mode = GET_MODE (shift);
machine_mode mode = GET_MODE (shift);
enum rtx_code code = GET_CODE (shift);
enum shift_type shift_type;
enum shift_mode shift_mode;
@ -4739,7 +4739,7 @@ unsigned int
compute_a_shift_length (rtx insn ATTRIBUTE_UNUSED, rtx *operands)
{
rtx shift = operands[3];
enum machine_mode mode = GET_MODE (shift);
machine_mode mode = GET_MODE (shift);
enum rtx_code code = GET_CODE (shift);
enum shift_type shift_type;
enum shift_mode shift_mode;
@ -4887,7 +4887,7 @@ enum attr_cc
compute_a_shift_cc (rtx insn ATTRIBUTE_UNUSED, rtx *operands)
{
rtx shift = operands[3];
enum machine_mode mode = GET_MODE (shift);
machine_mode mode = GET_MODE (shift);
enum rtx_code code = GET_CODE (shift);
enum shift_type shift_type;
enum shift_mode shift_mode;
@ -4982,7 +4982,7 @@ expand_a_rotate (rtx operands[])
rtx dst = operands[0];
rtx src = operands[1];
rtx rotate_amount = operands[2];
enum machine_mode mode = GET_MODE (dst);
machine_mode mode = GET_MODE (dst);
if (h8sx_classify_shift (mode, ROTATE, rotate_amount) == H8SX_SHIFT_UNARY)
return false;
@ -5066,7 +5066,7 @@ output_a_rotate (enum rtx_code code, rtx *operands)
const char *insn_buf;
int bits;
int amount;
enum machine_mode mode = GET_MODE (dst);
machine_mode mode = GET_MODE (dst);
gcc_assert (GET_CODE (rotate_amount) == CONST_INT);
@ -5169,7 +5169,7 @@ compute_a_rotate_length (rtx *operands)
{
rtx src = operands[1];
rtx amount_rtx = operands[2];
enum machine_mode mode = GET_MODE (src);
machine_mode mode = GET_MODE (src);
int amount;
unsigned int length = 0;
@ -5848,7 +5848,7 @@ h8300_rtx_ok_for_base_p (rtx x, int strict)
CONSTANT_ADDRESS. */
static bool
h8300_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
h8300_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
/* The register indirect addresses like @er0 is always valid. */
if (h8300_rtx_ok_for_base_p (x, strict))
@ -5880,7 +5880,7 @@ h8300_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
types on the H8 series to handle more than 32bits. */
int
h8300_hard_regno_nregs (int regno ATTRIBUTE_UNUSED, enum machine_mode mode)
h8300_hard_regno_nregs (int regno ATTRIBUTE_UNUSED, machine_mode mode)
{
return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
}
@ -5888,7 +5888,7 @@ h8300_hard_regno_nregs (int regno ATTRIBUTE_UNUSED, enum machine_mode mode)
/* Worker function for HARD_REGNO_MODE_OK. */
int
h8300_hard_regno_mode_ok (int regno, enum machine_mode mode)
h8300_hard_regno_mode_ok (int regno, machine_mode mode)
{
if (TARGET_H8300)
/* If an even reg, then anything goes. Otherwise the mode must be
@ -5962,7 +5962,7 @@ h8300_function_value (const_tree ret_type,
On the H8 the return value is in R0/R1. */
static rtx
h8300_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
h8300_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, R0_REG);
}

2
gcc/config/i386/i386-builtin-types.awk
View File

@ -179,7 +179,7 @@ END {
# The vector types are defined via two tables defining the real
# machine mode and the builtin primitive type. We use two tables
# rather than a structure to avoid structure padding and save space.
print "static const enum machine_mode ix86_builtin_type_vect_mode[] = {"
print "static const machine_mode ix86_builtin_type_vect_mode[] = {"
for (i = 0; i < vect_defs; ++i) {
if (i == 0)
printf " "

76
gcc/config/i386/i386-protos.h
View File

@ -52,11 +52,11 @@ extern bool symbolic_reference_mentioned_p (rtx);
extern bool extended_reg_mentioned_p (rtx);
extern bool x86_extended_QIreg_mentioned_p (rtx_insn *);
extern bool x86_extended_reg_mentioned_p (rtx);
extern bool x86_maybe_negate_const_int (rtx *, enum machine_mode);
extern enum machine_mode ix86_cc_mode (enum rtx_code, rtx, rtx);
extern bool x86_maybe_negate_const_int (rtx *, machine_mode);
extern machine_mode ix86_cc_mode (enum rtx_code, rtx, rtx);
extern int avx_vpermilp_parallel (rtx par, enum machine_mode mode);
extern int avx_vperm2f128_parallel (rtx par, enum machine_mode mode);
extern int avx_vpermilp_parallel (rtx par, machine_mode mode);
extern int avx_vperm2f128_parallel (rtx par, machine_mode mode);
extern bool ix86_expand_strlen (rtx, rtx, rtx, rtx);
extern bool ix86_expand_set_or_movmem (rtx, rtx, rtx, rtx, rtx, rtx,
@ -65,12 +65,12 @@ extern bool ix86_expand_set_or_movmem (rtx, rtx, rtx, rtx, rtx, rtx,
extern bool constant_address_p (rtx);
extern bool legitimate_pic_operand_p (rtx);
extern bool legitimate_pic_address_disp_p (rtx);
extern bool ix86_legitimize_reload_address (rtx, enum machine_mode,
extern bool ix86_legitimize_reload_address (rtx, machine_mode,
int, int, int);
extern void print_reg (rtx, int, FILE*);
extern void ix86_print_operand (FILE *, rtx, int);
extern void split_double_mode (enum machine_mode, rtx[], int, rtx[], rtx[]);
extern void split_double_mode (machine_mode, rtx[], int, rtx[], rtx[]);
extern const char *output_set_got (rtx, rtx);
extern const char *output_387_binary_op (rtx, rtx*);
@ -81,30 +81,30 @@ extern const char *output_adjust_stack_and_probe (rtx);
extern const char *output_probe_stack_range (rtx, rtx);
extern void ix86_expand_clear (rtx);
extern void ix86_expand_move (enum machine_mode, rtx[]);
extern void ix86_expand_vector_move (enum machine_mode, rtx[]);
extern void ix86_expand_vector_move_misalign (enum machine_mode, rtx[]);
extern void ix86_expand_move (machine_mode, rtx[]);
extern void ix86_expand_vector_move (machine_mode, rtx[]);
extern void ix86_expand_vector_move_misalign (machine_mode, rtx[]);
extern rtx ix86_fixup_binary_operands (enum rtx_code,
enum machine_mode, rtx[]);
machine_mode, rtx[]);
extern void ix86_fixup_binary_operands_no_copy (enum rtx_code,
enum machine_mode, rtx[]);
machine_mode, rtx[]);
extern void ix86_expand_binary_operator (enum rtx_code,
enum machine_mode, rtx[]);
machine_mode, rtx[]);
extern void ix86_expand_vector_logical_operator (enum rtx_code,
enum machine_mode, rtx[]);
extern bool ix86_binary_operator_ok (enum rtx_code, enum machine_mode, rtx[]);
machine_mode, rtx[]);
extern bool ix86_binary_operator_ok (enum rtx_code, machine_mode, rtx[]);
extern bool ix86_avoid_lea_for_add (rtx_insn *, rtx[]);
extern bool ix86_use_lea_for_mov (rtx_insn *, rtx[]);
extern bool ix86_avoid_lea_for_addr (rtx_insn *, rtx[]);
extern void ix86_split_lea_for_addr (rtx_insn *, rtx[], enum machine_mode);
extern void ix86_split_lea_for_addr (rtx_insn *, rtx[], machine_mode);
extern bool ix86_lea_for_add_ok (rtx_insn *, rtx[]);
extern bool ix86_vec_interleave_v2df_operator_ok (rtx operands[3], bool high);
extern bool ix86_dep_by_shift_count (const_rtx set_insn, const_rtx use_insn);
extern bool ix86_agi_dependent (rtx_insn *set_insn, rtx_insn *use_insn);
extern void ix86_expand_unary_operator (enum rtx_code, enum machine_mode,
extern void ix86_expand_unary_operator (enum rtx_code, machine_mode,
rtx[]);
extern rtx ix86_build_const_vector (enum machine_mode, bool, rtx);
extern rtx ix86_build_signbit_mask (enum machine_mode, bool, bool);
extern rtx ix86_build_const_vector (machine_mode, bool, rtx);
extern rtx ix86_build_signbit_mask (machine_mode, bool, bool);
extern void ix86_split_convert_uns_si_sse (rtx[]);
extern void ix86_expand_convert_uns_didf_sse (rtx, rtx);
extern void ix86_expand_convert_uns_sixf_sse (rtx, rtx);
@ -114,13 +114,13 @@ extern void ix86_expand_convert_sign_didf_sse (rtx, rtx);
extern void ix86_expand_vector_convert_uns_vsivsf (rtx, rtx);
extern rtx ix86_expand_adjust_ufix_to_sfix_si (rtx, rtx *);
extern enum ix86_fpcmp_strategy ix86_fp_comparison_strategy (enum rtx_code);
extern void ix86_expand_fp_absneg_operator (enum rtx_code, enum machine_mode,
extern void ix86_expand_fp_absneg_operator (enum rtx_code, machine_mode,
rtx[]);
extern void ix86_expand_copysign (rtx []);
extern void ix86_split_copysign_const (rtx []);
extern void ix86_split_copysign_var (rtx []);
extern bool ix86_unary_operator_ok (enum rtx_code, enum machine_mode, rtx[]);
extern bool ix86_match_ccmode (rtx, enum machine_mode);
extern bool ix86_unary_operator_ok (enum rtx_code, machine_mode, rtx[]);
extern bool ix86_match_ccmode (rtx, machine_mode);
extern void ix86_expand_branch (enum rtx_code, rtx, rtx, rtx);
extern void ix86_expand_setcc (rtx, enum rtx_code, rtx, rtx);
extern bool ix86_expand_int_movcc (rtx[]);
@ -136,21 +136,21 @@ extern void ix86_split_call_vzeroupper (rtx, rtx);
extern void x86_initialize_trampoline (rtx, rtx, rtx);
extern rtx ix86_zero_extend_to_Pmode (rtx);
extern void ix86_split_long_move (rtx[]);
extern void ix86_split_ashl (rtx *, rtx, enum machine_mode);
extern void ix86_split_ashr (rtx *, rtx, enum machine_mode);
extern void ix86_split_lshr (rtx *, rtx, enum machine_mode);
extern void ix86_split_ashl (rtx *, rtx, machine_mode);
extern void ix86_split_ashr (rtx *, rtx, machine_mode);
extern void ix86_split_lshr (rtx *, rtx, machine_mode);
extern rtx ix86_find_base_term (rtx);
extern bool ix86_check_movabs (rtx, int);
extern void ix86_split_idivmod (enum machine_mode, rtx[], bool);
extern void ix86_split_idivmod (machine_mode, rtx[], bool);
extern rtx assign_386_stack_local (enum machine_mode, enum ix86_stack_slot);
extern rtx assign_386_stack_local (machine_mode, enum ix86_stack_slot);
extern int ix86_attr_length_immediate_default (rtx_insn *, bool);
extern int ix86_attr_length_address_default (rtx_insn *);
extern int ix86_attr_length_vex_default (rtx_insn *, bool, bool);
extern enum machine_mode ix86_fp_compare_mode (enum rtx_code);
extern machine_mode ix86_fp_compare_mode (enum rtx_code);
extern rtx ix86_libcall_value (enum machine_mode);
extern rtx ix86_libcall_value (machine_mode);
extern bool ix86_function_arg_regno_p (int);
extern void ix86_asm_output_function_label (FILE *, const char *, tree);
extern void ix86_call_abi_override (const_tree);
@ -158,12 +158,12 @@ extern int ix86_reg_parm_stack_space (const_tree);
extern void ix86_split_fp_branch (enum rtx_code code, rtx, rtx,
rtx, rtx, rtx);
extern bool ix86_hard_regno_mode_ok (int, enum machine_mode);
extern bool ix86_modes_tieable_p (enum machine_mode, enum machine_mode);
extern bool ix86_hard_regno_mode_ok (int, machine_mode);
extern bool ix86_modes_tieable_p (machine_mode, machine_mode);
extern bool ix86_secondary_memory_needed (enum reg_class, enum reg_class,
enum machine_mode, int);
extern bool ix86_cannot_change_mode_class (enum machine_mode,
enum machine_mode, enum reg_class);
machine_mode, int);
extern bool ix86_cannot_change_mode_class (machine_mode,
machine_mode, enum reg_class);
extern bool ix86_libc_has_function (enum function_class fn_class);
@ -174,10 +174,10 @@ extern void ix86_emit_fp_unordered_jump (rtx);
extern void ix86_emit_i387_log1p (rtx, rtx);
extern void ix86_emit_i387_round (rtx, rtx);
extern void ix86_emit_swdivsf (rtx, rtx, rtx, enum machine_mode);
extern void ix86_emit_swsqrtsf (rtx, rtx, enum machine_mode, bool);
extern void ix86_emit_swdivsf (rtx, rtx, rtx, machine_mode);
extern void ix86_emit_swsqrtsf (rtx, rtx, machine_mode, bool);
extern enum rtx_code ix86_reverse_condition (enum rtx_code, enum machine_mode);
extern enum rtx_code ix86_reverse_condition (enum rtx_code, machine_mode);
extern void ix86_expand_lround (rtx, rtx);
extern void ix86_expand_lfloorceil (rtx, rtx, bool);
@ -200,9 +200,9 @@ extern void init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree, int);
#ifdef TREE_CODE
extern int ix86_data_alignment (tree, int, bool);
extern unsigned int ix86_local_alignment (tree, enum machine_mode,
extern unsigned int ix86_local_alignment (tree, machine_mode,
unsigned int);
extern unsigned int ix86_minimum_alignment (tree, enum machine_mode,
extern unsigned int ix86_minimum_alignment (tree, machine_mode,
unsigned int);
extern int ix86_constant_alignment (tree, int);
extern tree ix86_handle_shared_attribute (tree *, tree, tree, int, bool *);

586
gcc/config/i386/i386.c
View File

File diff suppressed because it is too large Load Diff

40
gcc/config/i386/i386.md
View File

@ -4408,8 +4408,8 @@
(clobber (match_scratch:<ssevecmode> 4))])]
"!TARGET_64BIT && TARGET_SSE2 && TARGET_SSE_MATH"
{
enum machine_mode mode = <MODE>mode;
enum machine_mode vecmode = <ssevecmode>mode;
machine_mode mode = <MODE>mode;
machine_mode vecmode = <ssevecmode>mode;
REAL_VALUE_TYPE TWO31r;
rtx two31;
@ -4854,8 +4854,8 @@
&& reload_completed && SSE_REG_P (operands[0])"
[(const_int 0)]
{
const enum machine_mode vmode = <MODEF:ssevecmode>mode;
const enum machine_mode mode = <MODEF:MODE>mode;
const machine_mode vmode = <MODEF:ssevecmode>mode;
const machine_mode mode = <MODEF:MODE>mode;
rtx t, op0 = simplify_gen_subreg (vmode, operands[0], mode, 0);
emit_move_insn (op0, CONST0_RTX (vmode));
@ -5071,7 +5071,7 @@
"reload_completed && ix86_avoid_lea_for_addr (insn, operands)"
[(const_int 0)]
{
enum machine_mode mode = <MODE>mode;
machine_mode mode = <MODE>mode;
rtx pat;
/* ix86_avoid_lea_for_addr re-recognizes insn and may
@ -5439,7 +5439,7 @@
"reload_completed && ix86_lea_for_add_ok (insn, operands)"
[(const_int 0)]
{
enum machine_mode mode = <MODE>mode;
machine_mode mode = <MODE>mode;
rtx pat;
if (<MODE_SIZE> < GET_MODE_SIZE (SImode))
@ -5945,7 +5945,7 @@
"&& reload_completed"
[(const_int 0)]
{
enum machine_mode mode = SImode;
machine_mode mode = SImode;
rtx pat;
operands[0] = gen_lowpart (mode, operands[0]);
@ -5976,7 +5976,7 @@
"&& reload_completed"
[(const_int 0)]
{
enum machine_mode mode = SImode;
machine_mode mode = SImode;
rtx pat;
operands[0] = gen_lowpart (mode, operands[0]);
@ -6006,7 +6006,7 @@
"&& reload_completed"
[(const_int 0)]
{
enum machine_mode mode = SImode;
machine_mode mode = SImode;
rtx pat;
operands[0] = gen_lowpart (mode, operands[0]);
@ -6045,7 +6045,7 @@
"&& reload_completed"
[(const_int 0)]
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx pat;
if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (SImode))
@ -7451,7 +7451,7 @@
HOST_WIDE_INT len = INTVAL (operands[3]);
HOST_WIDE_INT pos = INTVAL (operands[4]);
HOST_WIDE_INT mask;
enum machine_mode mode, submode;
machine_mode mode, submode;
mode = GET_MODE (val);
if (MEM_P (val))
@ -7574,7 +7574,7 @@
(match_operand:SWIM 2 "<general_szext_operand>")))]
""
{
enum machine_mode mode = <MODE>mode;
machine_mode mode = <MODE>mode;
rtx (*insn) (rtx, rtx);
if (CONST_INT_P (operands[2]) && REG_P (operands[0]))
@ -7825,7 +7825,7 @@
[(const_int 0)]
{
HOST_WIDE_INT ival = INTVAL (operands[2]);
enum machine_mode mode;
machine_mode mode;
rtx (*insn) (rtx, rtx);
if (ival == (HOST_WIDE_INT) 0xffffffff)
@ -8733,8 +8733,8 @@
"reload_completed && SSE_REG_P (operands[0])"
[(set (match_dup 0) (match_dup 3))]
{
enum machine_mode mode = GET_MODE (operands[0]);
enum machine_mode vmode = GET_MODE (operands[2]);
machine_mode mode = GET_MODE (operands[0]);
machine_mode vmode = GET_MODE (operands[2]);
rtx tmp;
operands[0] = simplify_gen_subreg (vmode, operands[0], mode, 0);
@ -9512,7 +9512,7 @@
&& true_regnum (operands[0]) != true_regnum (operands[1])"
[(const_int 0)]
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx pat;
if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (SImode))
@ -12157,7 +12157,7 @@
(clobber (reg:CC FLAGS_REG))])]
""
{
enum machine_mode flags_mode;
machine_mode flags_mode;
if (<MODE>mode == SImode && !TARGET_CMOVE)
{
@ -12192,7 +12192,7 @@
(parallel [(set (match_dup 0) (plus:SI (match_dup 0) (const_int 1)))
(clobber (reg:CC FLAGS_REG))])]
{
enum machine_mode flags_mode
machine_mode flags_mode
= (TARGET_BMI && !TARGET_AVOID_FALSE_DEP_FOR_BMI) ? CCCmode : CCZmode;
operands[3] = gen_lowpart (QImode, operands[2]);
@ -17847,8 +17847,8 @@
[(set (match_dup 5) (match_dup 4))
(set (match_dup 0) (match_dup 1))]
{
enum machine_mode op1mode = GET_MODE (operands[1]);
enum machine_mode mode = op1mode == DImode ? DImode : SImode;
machine_mode op1mode = GET_MODE (operands[1]);
machine_mode mode = op1mode == DImode ? DImode : SImode;
int scale = 1 << INTVAL (operands[2]);
rtx index = gen_lowpart (word_mode, operands[1]);
rtx base = gen_lowpart (word_mode, operands[5]);

6
gcc/config/i386/predicates.md
View File

@ -1111,7 +1111,7 @@
(define_predicate "fcmov_comparison_operator"
(match_operand 0 "comparison_operator")
{
enum machine_mode inmode = GET_MODE (XEXP (op, 0));
machine_mode inmode = GET_MODE (XEXP (op, 0));
enum rtx_code code = GET_CODE (op);
if (inmode == CCFPmode || inmode == CCFPUmode)
@ -1158,7 +1158,7 @@
(define_predicate "ix86_comparison_operator"
(match_operand 0 "comparison_operator")
{
enum machine_mode inmode = GET_MODE (XEXP (op, 0));
machine_mode inmode = GET_MODE (XEXP (op, 0));
enum rtx_code code = GET_CODE (op);
if (inmode == CCFPmode || inmode == CCFPUmode)
@ -1195,7 +1195,7 @@
(define_predicate "ix86_carry_flag_operator"
(match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq")
{
enum machine_mode inmode = GET_MODE (XEXP (op, 0));
machine_mode inmode = GET_MODE (XEXP (op, 0));
enum rtx_code code = GET_CODE (op);
if (inmode == CCFPmode || inmode == CCFPUmode)

4
gcc/config/i386/sse.md
View File

@ -14533,7 +14533,7 @@
UNSPEC_ROUND))]
"TARGET_ROUND && !flag_trapping_math"
{
enum machine_mode scalar_mode;
machine_mode scalar_mode;
const struct real_format *fmt;
REAL_VALUE_TYPE pred_half, half_minus_pred_half;
rtx half, vec_half;
@ -17211,7 +17211,7 @@
[(match_operand 3 "const_int_operand" "n, n")])))]
"TARGET_SSSE3"
{
enum machine_mode imode = GET_MODE_INNER (GET_MODE (operands[0]));
machine_mode imode = GET_MODE_INNER (GET_MODE (operands[0]));
operands[2] = GEN_INT (INTVAL (operands[3]) * GET_MODE_SIZE (imode));
switch (which_alternative)

2
gcc/config/i386/sync.md
View File

@ -350,7 +350,7 @@
}
else
{
enum machine_mode hmode = <CASHMODE>mode;
machine_mode hmode = <CASHMODE>mode;
rtx lo_o, lo_e, lo_n, hi_o, hi_e, hi_n;
lo_o = operands[1];

10
gcc/config/ia64/ia64-protos.h
View File

@ -35,10 +35,10 @@ extern int addp4_optimize_ok (rtx, rtx);
extern void ia64_emit_cond_move (rtx, rtx, rtx);
extern int ia64_depz_field_mask (rtx, rtx);
extern void ia64_split_tmode_move (rtx[]);
extern bool ia64_expand_movxf_movrf (enum machine_mode, rtx[]);
extern bool ia64_expand_movxf_movrf (machine_mode, rtx[]);
extern void ia64_expand_compare (rtx *, rtx *, rtx *);
extern void ia64_expand_vecint_cmov (rtx[]);
extern bool ia64_expand_vecint_minmax (enum rtx_code, enum machine_mode, rtx[]);
extern bool ia64_expand_vecint_minmax (enum rtx_code, machine_mode, rtx[]);
extern void ia64_unpack_assemble (rtx, rtx, rtx, bool);
extern void ia64_expand_unpack (rtx [], bool, bool);
extern void ia64_expand_widen_sum (rtx[], bool);
@ -57,7 +57,7 @@ extern bool ia64_expand_load_address (rtx, rtx);
extern int ia64_hard_regno_rename_ok (int, int);
extern enum reg_class ia64_secondary_reload_class (enum reg_class,
enum machine_mode, rtx);
machine_mode, rtx);
extern const char *get_bundle_name (int);
extern const char *output_probe_stack_range (rtx, rtx);
@ -68,7 +68,7 @@ extern void ia64_expand_vec_setv2sf (rtx op[3]);
#ifdef TREE_CODE
#ifdef RTX_CODE
extern rtx ia64_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
extern rtx ia64_expand_builtin (tree, rtx, rtx, machine_mode, int);
extern rtx ia64_va_arg (tree, tree);
#endif /* RTX_CODE */
@ -91,7 +91,7 @@ extern void ia64_split_return_addr_rtx (rtx);
#ifdef ARGS_SIZE_RTX
/* expr.h defines ARGS_SIZE_RTX and `enum direction'. */
extern enum direction ia64_hpux_function_arg_padding (enum machine_mode, const_tree);
extern enum direction ia64_hpux_function_arg_padding (machine_mode, const_tree);
#endif /* ARGS_SIZE_RTX */
extern void ia64_hpux_handle_builtin_pragma (struct cpp_reader *);

156
gcc/config/ia64/ia64.c
View File

@ -188,7 +188,7 @@ static void ia64_init_sched_context (void *, bool);
static void ia64_set_sched_context (void *);
static void ia64_clear_sched_context (void *);
static void ia64_free_sched_context (void *);
static int ia64_mode_to_int (enum machine_mode);
static int ia64_mode_to_int (machine_mode);
static void ia64_set_sched_flags (spec_info_t);
static ds_t ia64_get_insn_spec_ds (rtx_insn *);
static ds_t ia64_get_insn_checked_ds (rtx_insn *);
@ -215,29 +215,29 @@ static rtx gen_fr_restore_x (rtx, rtx, rtx);
static void ia64_option_override (void);
static bool ia64_can_eliminate (const int, const int);
static enum machine_mode hfa_element_mode (const_tree, bool);
static void ia64_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
static machine_mode hfa_element_mode (const_tree, bool);
static void ia64_setup_incoming_varargs (cumulative_args_t, machine_mode,
tree, int *, int);
static int ia64_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static int ia64_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx ia64_function_arg_1 (cumulative_args_t, enum machine_mode,
static rtx ia64_function_arg_1 (cumulative_args_t, machine_mode,
const_tree, bool, bool);
static rtx ia64_function_arg (cumulative_args_t, enum machine_mode,
static rtx ia64_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx ia64_function_incoming_arg (cumulative_args_t,
enum machine_mode, const_tree, bool);
static void ia64_function_arg_advance (cumulative_args_t, enum machine_mode,
machine_mode, const_tree, bool);
static void ia64_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static unsigned int ia64_function_arg_boundary (enum machine_mode,
static unsigned int ia64_function_arg_boundary (machine_mode,
const_tree);
static bool ia64_function_ok_for_sibcall (tree, tree);
static bool ia64_return_in_memory (const_tree, const_tree);
static rtx ia64_function_value (const_tree, const_tree, bool);
static rtx ia64_libcall_value (enum machine_mode, const_rtx);
static rtx ia64_libcall_value (machine_mode, const_rtx);
static bool ia64_function_value_regno_p (const unsigned int);
static int ia64_register_move_cost (enum machine_mode, reg_class_t,
static int ia64_register_move_cost (machine_mode, reg_class_t,
reg_class_t);
static int ia64_memory_move_cost (enum machine_mode mode, reg_class_t,
static int ia64_memory_move_cost (machine_mode mode, reg_class_t,
bool);
static bool ia64_rtx_costs (rtx, int, int, int, int *, bool);
static int ia64_unspec_may_trap_p (const_rtx, unsigned);
@ -303,7 +303,7 @@ static void ia64_globalize_decl_name (FILE *, tree);
static int ia64_hpux_reloc_rw_mask (void) ATTRIBUTE_UNUSED;
static int ia64_reloc_rw_mask (void) ATTRIBUTE_UNUSED;
static section *ia64_select_rtx_section (enum machine_mode, rtx,
static section *ia64_select_rtx_section (machine_mode, rtx,
unsigned HOST_WIDE_INT);
static void ia64_output_dwarf_dtprel (FILE *, int, rtx)
ATTRIBUTE_UNUSED;
@ -318,7 +318,7 @@ static void ia64_vms_init_libfuncs (void)
ATTRIBUTE_UNUSED;
static void ia64_soft_fp_init_libfuncs (void)
ATTRIBUTE_UNUSED;
static bool ia64_vms_valid_pointer_mode (enum machine_mode mode)
static bool ia64_vms_valid_pointer_mode (machine_mode mode)
ATTRIBUTE_UNUSED;
static tree ia64_vms_common_object_attribute (tree *, tree, tree, int, bool *)
ATTRIBUTE_UNUSED;
@ -328,29 +328,29 @@ static tree ia64_handle_version_id_attribute (tree *, tree, tree, int, bool *);
static void ia64_encode_section_info (tree, rtx, int);
static rtx ia64_struct_value_rtx (tree, int);
static tree ia64_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
static bool ia64_scalar_mode_supported_p (enum machine_mode mode);
static bool ia64_vector_mode_supported_p (enum machine_mode mode);
static bool ia64_libgcc_floating_mode_supported_p (enum machine_mode mode);
static bool ia64_legitimate_constant_p (enum machine_mode, rtx);
static bool ia64_legitimate_address_p (enum machine_mode, rtx, bool);
static bool ia64_cannot_force_const_mem (enum machine_mode, rtx);
static bool ia64_scalar_mode_supported_p (machine_mode mode);
static bool ia64_vector_mode_supported_p (machine_mode mode);
static bool ia64_libgcc_floating_mode_supported_p (machine_mode mode);
static bool ia64_legitimate_constant_p (machine_mode, rtx);
static bool ia64_legitimate_address_p (machine_mode, rtx, bool);
static bool ia64_cannot_force_const_mem (machine_mode, rtx);
static const char *ia64_mangle_type (const_tree);
static const char *ia64_invalid_conversion (const_tree, const_tree);
static const char *ia64_invalid_unary_op (int, const_tree);
static const char *ia64_invalid_binary_op (int, const_tree, const_tree);
static enum machine_mode ia64_c_mode_for_suffix (char);
static machine_mode ia64_c_mode_for_suffix (char);
static void ia64_trampoline_init (rtx, tree, rtx);
static void ia64_override_options_after_change (void);
static bool ia64_member_type_forces_blk (const_tree, enum machine_mode);
static bool ia64_member_type_forces_blk (const_tree, machine_mode);
static tree ia64_builtin_decl (unsigned, bool);
static reg_class_t ia64_preferred_reload_class (rtx, reg_class_t);
static enum machine_mode ia64_get_reg_raw_mode (int regno);
static machine_mode ia64_get_reg_raw_mode (int regno);
static section * ia64_hpux_function_section (tree, enum node_frequency,
bool, bool);
static bool ia64_vectorize_vec_perm_const_ok (enum machine_mode vmode,
static bool ia64_vectorize_vec_perm_const_ok (machine_mode vmode,
const unsigned char *sel);
#define MAX_VECT_LEN 8
@ -359,7 +359,7 @@ struct expand_vec_perm_d
{
rtx target, op0, op1;
unsigned char perm[MAX_VECT_LEN];
enum machine_mode vmode;
machine_mode vmode;
unsigned char nelt;
bool one_operand_p;
bool testing_p;
@ -1002,7 +1002,7 @@ ia64_legitimate_address_disp (const_rtx reg, const_rtx disp, bool strict)
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
ia64_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
ia64_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x, bool strict)
{
if (ia64_legitimate_address_reg (x, strict))
@ -1024,7 +1024,7 @@ ia64_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
field in an instruction. */
static bool
ia64_legitimate_constant_p (enum machine_mode mode, rtx x)
ia64_legitimate_constant_p (machine_mode mode, rtx x)
{
switch (GET_CODE (x))
{
@ -1079,7 +1079,7 @@ ia64_legitimate_constant_p (enum machine_mode mode, rtx x)
/* Don't allow TLS addresses to get spilled to memory. */
static bool
ia64_cannot_force_const_mem (enum machine_mode mode, rtx x)
ia64_cannot_force_const_mem (machine_mode mode, rtx x)
{
if (mode == RFmode)
return true;
@ -1286,7 +1286,7 @@ ia64_expand_tls_address (enum tls_model tls_kind, rtx op0, rtx op1,
rtx
ia64_expand_move (rtx op0, rtx op1)
{
enum machine_mode mode = GET_MODE (op0);
machine_mode mode = GET_MODE (op0);
if (!reload_in_progress && !reload_completed && !ia64_move_ok (op0, op1))
op1 = force_reg (mode, op1);
@ -1613,7 +1613,7 @@ ia64_split_tmode_move (rtx operands[])
we see something like the above, we spill the inner register to memory. */
static rtx
spill_xfmode_rfmode_operand (rtx in, int force, enum machine_mode mode)
spill_xfmode_rfmode_operand (rtx in, int force, machine_mode mode)
{
if (GET_CODE (in) == SUBREG
&& GET_MODE (SUBREG_REG (in)) == TImode
@ -1638,7 +1638,7 @@ spill_xfmode_rfmode_operand (rtx in, int force, enum machine_mode mode)
DONE. */
bool
ia64_expand_movxf_movrf (enum machine_mode mode, rtx operands[])
ia64_expand_movxf_movrf (machine_mode mode, rtx operands[])
{
rtx op0 = operands[0];
@ -1861,7 +1861,7 @@ ia64_expand_compare (rtx *expr, rtx *op0, rtx *op1)
been reversed, and so the sense of the comparison should be inverted. */
static bool
ia64_expand_vecint_compare (enum rtx_code code, enum machine_mode mode,
ia64_expand_vecint_compare (enum rtx_code code, machine_mode mode,
rtx dest, rtx op0, rtx op1)
{
bool negate = false;
@ -1952,7 +1952,7 @@ ia64_expand_vecint_compare (enum rtx_code code, enum machine_mode mode,
void
ia64_expand_vecint_cmov (rtx operands[])
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
enum rtx_code code = GET_CODE (operands[3]);
bool negate;
rtx cmp, x, ot, of;
@ -2002,7 +2002,7 @@ ia64_expand_vecint_cmov (rtx operands[])
/* Emit an integral vector min or max operation. Return true if all done. */
bool
ia64_expand_vecint_minmax (enum rtx_code code, enum machine_mode mode,
ia64_expand_vecint_minmax (enum rtx_code code, machine_mode mode,
rtx operands[])
{
rtx xops[6];
@ -2059,7 +2059,7 @@ ia64_expand_vecint_minmax (enum rtx_code code, enum machine_mode mode,
void
ia64_unpack_assemble (rtx out, rtx lo, rtx hi, bool highp)
{
enum machine_mode vmode = GET_MODE (lo);
machine_mode vmode = GET_MODE (lo);
unsigned int i, high, nelt = GET_MODE_NUNITS (vmode);
struct expand_vec_perm_d d;
bool ok;
@ -2088,7 +2088,7 @@ ia64_unpack_assemble (rtx out, rtx lo, rtx hi, bool highp)
static rtx
ia64_unpack_sign (rtx vec, bool unsignedp)
{
enum machine_mode mode = GET_MODE (vec);
machine_mode mode = GET_MODE (vec);
rtx zero = CONST0_RTX (mode);
if (unsignedp)
@ -2119,7 +2119,7 @@ ia64_expand_unpack (rtx operands[3], bool unsignedp, bool highp)
void
ia64_expand_widen_sum (rtx operands[3], bool unsignedp)
{
enum machine_mode wmode;
machine_mode wmode;
rtx l, h, t, sign;
sign = ia64_unpack_sign (operands[1], unsignedp);
@ -2336,7 +2336,7 @@ void
ia64_expand_atomic_op (enum rtx_code code, rtx mem, rtx val,
rtx old_dst, rtx new_dst, enum memmodel model)
{
enum machine_mode mode = GET_MODE (mem);
machine_mode mode = GET_MODE (mem);
rtx old_reg, new_reg, cmp_reg, ar_ccv, label;
enum insn_code icode;
@ -4503,7 +4503,7 @@ ia64_trampoline_init (rtx m_tramp, tree fndecl, rtx static_chain)
We generate the actual spill instructions during prologue generation. */
static void
ia64_setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
ia64_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode,
tree type, int * pretend_size,
int second_time ATTRIBUTE_UNUSED)
{
@ -4532,11 +4532,11 @@ ia64_setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
have already decided to pass them by reference. Top-level zero-sized
aggregates are excluded because our parallels crash the middle-end. */
static enum machine_mode
static machine_mode
hfa_element_mode (const_tree type, bool nested)
{
enum machine_mode element_mode = VOIDmode;
enum machine_mode mode;
machine_mode element_mode = VOIDmode;
machine_mode mode;
enum tree_code code = TREE_CODE (type);
int know_element_mode = 0;
tree t;
@ -4611,7 +4611,7 @@ hfa_element_mode (const_tree type, bool nested)
/* Return the number of words required to hold a quantity of TYPE and MODE
when passed as an argument. */
static int
ia64_function_arg_words (const_tree type, enum machine_mode mode)
ia64_function_arg_words (const_tree type, machine_mode mode)
{
int words;
@ -4658,7 +4658,7 @@ ia64_function_arg_offset (const CUMULATIVE_ARGS *cum,
registers. */
static rtx
ia64_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
ia64_function_arg_1 (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named, bool incoming)
{
const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -4666,7 +4666,7 @@ ia64_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
int basereg = (incoming ? GR_ARG_FIRST : AR_ARG_FIRST);
int words = ia64_function_arg_words (type, mode);
int offset = ia64_function_arg_offset (cum, type, words);
enum machine_mode hfa_mode = VOIDmode;
machine_mode hfa_mode = VOIDmode;
/* For OPEN VMS, emit the instruction setting up the argument register here,
when we know this will be together with the other arguments setup related
@ -4753,7 +4753,7 @@ ia64_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
for (; offset < byte_size && int_regs < MAX_ARGUMENT_SLOTS; i++)
{
enum machine_mode gr_mode = DImode;
machine_mode gr_mode = DImode;
unsigned int gr_size;
/* If we have an odd 4 byte hunk because we ran out of FR regs,
@ -4833,7 +4833,7 @@ ia64_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
else
{
/* See comment above. */
enum machine_mode inner_mode =
machine_mode inner_mode =
(BYTES_BIG_ENDIAN && mode == SFmode) ? DImode : mode;
rtx fp_reg = gen_rtx_EXPR_LIST (VOIDmode,
@ -4853,7 +4853,7 @@ ia64_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
/* Implement TARGET_FUNCION_ARG target hook. */
static rtx
ia64_function_arg (cumulative_args_t cum, enum machine_mode mode,
ia64_function_arg (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
return ia64_function_arg_1 (cum, mode, type, named, false);
@ -4863,7 +4863,7 @@ ia64_function_arg (cumulative_args_t cum, enum machine_mode mode,
static rtx
ia64_function_incoming_arg (cumulative_args_t cum,
enum machine_mode mode,
machine_mode mode,
const_tree type, bool named)
{
return ia64_function_arg_1 (cum, mode, type, named, true);
@ -4874,7 +4874,7 @@ ia64_function_incoming_arg (cumulative_args_t cum,
in memory. */
static int
ia64_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
ia64_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -4900,7 +4900,7 @@ ia64_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
/* Return ivms_arg_type based on machine_mode. */
static enum ivms_arg_type
ia64_arg_type (enum machine_mode mode)
ia64_arg_type (machine_mode mode)
{
switch (mode)
{
@ -4917,13 +4917,13 @@ ia64_arg_type (enum machine_mode mode)
ia64_function_arg. */
static void
ia64_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
ia64_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
int words = ia64_function_arg_words (type, mode);
int offset = ia64_function_arg_offset (cum, type, words);
enum machine_mode hfa_mode = VOIDmode;
machine_mode hfa_mode = VOIDmode;
/* If all arg slots are already full, then there is nothing to do. */
if (cum->words >= MAX_ARGUMENT_SLOTS)
@ -5015,7 +5015,7 @@ ia64_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
even though their normal alignment is 8 bytes. See ia64_function_arg. */
static unsigned int
ia64_function_arg_boundary (enum machine_mode mode, const_tree type)
ia64_function_arg_boundary (machine_mode mode, const_tree type)
{
if (mode == TFmode && TARGET_HPUX && TARGET_ILP32)
return PARM_BOUNDARY * 2;
@ -5089,8 +5089,8 @@ ia64_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
static bool
ia64_return_in_memory (const_tree valtype, const_tree fntype ATTRIBUTE_UNUSED)
{
enum machine_mode mode;
enum machine_mode hfa_mode;
machine_mode mode;
machine_mode hfa_mode;
HOST_WIDE_INT byte_size;
mode = TYPE_MODE (valtype);
@ -5127,8 +5127,8 @@ ia64_function_value (const_tree valtype,
const_tree fn_decl_or_type,
bool outgoing ATTRIBUTE_UNUSED)
{
enum machine_mode mode;
enum machine_mode hfa_mode;
machine_mode mode;
machine_mode hfa_mode;
int unsignedp;
const_tree func = fn_decl_or_type;
@ -5216,7 +5216,7 @@ ia64_function_value (const_tree valtype,
/* Worker function for TARGET_LIBCALL_VALUE. */
static rtx
ia64_libcall_value (enum machine_mode mode,
ia64_libcall_value (machine_mode mode,
const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode,
@ -5678,7 +5678,7 @@ ia64_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
one in class TO, using MODE. */
static int
ia64_register_move_cost (enum machine_mode mode, reg_class_t from,
ia64_register_move_cost (machine_mode mode, reg_class_t from,
reg_class_t to)
{
/* ADDL_REGS is the same as GR_REGS for movement purposes. */
@ -5750,7 +5750,7 @@ ia64_register_move_cost (enum machine_mode mode, reg_class_t from,
memory. */
static int
ia64_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
ia64_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t rclass,
bool in ATTRIBUTE_UNUSED)
{
@ -5804,7 +5804,7 @@ ia64_preferred_reload_class (rtx x, reg_class_t rclass)
enum reg_class
ia64_secondary_reload_class (enum reg_class rclass,
enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
int regno = -1;
@ -7876,7 +7876,7 @@ get_spec_load_gen_function (ds_t ts, int mode_no)
return gen_ld[mode_no];
}
/* Constants that help mapping 'enum machine_mode' to int. */
/* Constants that help mapping 'machine_mode' to int. */
enum SPEC_MODES
{
SPEC_MODE_INVALID = -1,
@ -7894,7 +7894,7 @@ enum
/* Return index of the MODE. */
static int
ia64_mode_to_int (enum machine_mode mode)
ia64_mode_to_int (machine_mode mode)
{
switch (mode)
{
@ -10443,7 +10443,7 @@ ia64_init_builtins (void)
rtx
ia64_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
@ -10467,7 +10467,7 @@ ia64_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
case IA64_BUILTIN_INFQ:
case IA64_BUILTIN_HUGE_VALQ:
{
enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
REAL_VALUE_TYPE inf;
rtx tmp;
@ -10509,7 +10509,7 @@ ia64_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
most significant bits of the stack slot. */
enum direction
ia64_hpux_function_arg_padding (enum machine_mode mode, const_tree type)
ia64_hpux_function_arg_padding (machine_mode mode, const_tree type)
{
/* Exception to normal case for structures/unions/etc. */
@ -10676,7 +10676,7 @@ ia64_soft_fp_init_libfuncs (void)
}
static bool
ia64_vms_valid_pointer_mode (enum machine_mode mode)
ia64_vms_valid_pointer_mode (machine_mode mode)
{
return (mode == SImode || mode == DImode);
}
@ -10703,7 +10703,7 @@ ia64_reloc_rw_mask (void)
is to honor small data. */
static section *
ia64_select_rtx_section (enum machine_mode mode, rtx x,
ia64_select_rtx_section (machine_mode mode, rtx x,
unsigned HOST_WIDE_INT align)
{
if (GET_MODE_SIZE (mode) > 0
@ -10912,7 +10912,7 @@ ia64_struct_value_rtx (tree fntype,
}
static bool
ia64_scalar_mode_supported_p (enum machine_mode mode)
ia64_scalar_mode_supported_p (machine_mode mode)
{
switch (mode)
{
@ -10938,7 +10938,7 @@ ia64_scalar_mode_supported_p (enum machine_mode mode)
}
static bool
ia64_vector_mode_supported_p (enum machine_mode mode)
ia64_vector_mode_supported_p (machine_mode mode)
{
switch (mode)
{
@ -10958,7 +10958,7 @@ ia64_vector_mode_supported_p (enum machine_mode mode)
/* Implement TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P. */
static bool
ia64_libgcc_floating_mode_supported_p (enum machine_mode mode)
ia64_libgcc_floating_mode_supported_p (machine_mode mode)
{
switch (mode)
{
@ -11175,7 +11175,7 @@ ia64_handle_version_id_attribute (tree *node ATTRIBUTE_UNUSED,
/* Target hook for c_mode_for_suffix. */
static enum machine_mode
static machine_mode
ia64_c_mode_for_suffix (char suffix)
{
if (suffix == 'q')
@ -11214,7 +11214,7 @@ ia64_dconst_0_375 (void)
return ia64_dconst_0_375_rtx;
}
static enum machine_mode
static machine_mode
ia64_get_reg_raw_mode (int regno)
{
if (FR_REGNO_P (regno))
@ -11226,7 +11226,7 @@ ia64_get_reg_raw_mode (int regno)
anymore. */
bool
ia64_member_type_forces_blk (const_tree, enum machine_mode mode)
ia64_member_type_forces_blk (const_tree, machine_mode mode)
{
return TARGET_HPUX && mode == TFmode;
}
@ -11273,7 +11273,7 @@ static bool
expand_vselect_vconcat (rtx target, rtx op0, rtx op1,
const unsigned char *perm, unsigned nelt)
{
enum machine_mode v2mode;
machine_mode v2mode;
rtx x;
v2mode = GET_MODE_2XWIDER_MODE (GET_MODE (op0));
@ -11708,7 +11708,7 @@ ia64_expand_vec_perm_const (rtx operands[4])
/* Implement targetm.vectorize.vec_perm_const_ok. */
static bool
ia64_vectorize_vec_perm_const_ok (enum machine_mode vmode,
ia64_vectorize_vec_perm_const_ok (machine_mode vmode,
const unsigned char *sel)
{
struct expand_vec_perm_d d;
@ -11781,7 +11781,7 @@ void
ia64_expand_vec_perm_even_odd (rtx target, rtx op0, rtx op1, int odd)
{
struct expand_vec_perm_d d;
enum machine_mode vmode = GET_MODE (target);
machine_mode vmode = GET_MODE (target);
unsigned int i, nelt = GET_MODE_NUNITS (vmode);
bool ok;

6
gcc/config/iq2000/iq2000-protos.h
View File

@ -20,8 +20,8 @@
#ifndef GCC_IQ2000_PROTOS_H
#define GCC_IQ2000_PROTOS_H
extern int iq2000_check_split (rtx, enum machine_mode);
extern int iq2000_reg_mode_ok_for_base_p (rtx, enum machine_mode, int);
extern int iq2000_check_split (rtx, machine_mode);
extern int iq2000_reg_mode_ok_for_base_p (rtx, machine_mode, int);
extern const char * iq2000_fill_delay_slot (const char *, enum delay_type, rtx *, rtx_insn *);
extern const char * iq2000_move_1word (rtx *, rtx_insn *, int);
extern HOST_WIDE_INT iq2000_debugger_offset (rtx, HOST_WIDE_INT);
@ -38,7 +38,7 @@ extern char * iq2000_output_conditional_branch (rtx_insn *, rtx *,
#ifdef RTX_CODE
extern rtx gen_int_relational (enum rtx_code, rtx, rtx, rtx, int *);
extern void gen_conditional_branch (rtx *, enum machine_mode);
extern void gen_conditional_branch (rtx *, machine_mode);
#endif
#ifdef TREE_CODE

74
gcc/config/iq2000/iq2000.c
View File

@ -154,42 +154,42 @@ static rtx iq2000_load_reg3;
static rtx iq2000_load_reg4;
/* Mode used for saving/restoring general purpose registers. */
static enum machine_mode gpr_mode;
static machine_mode gpr_mode;
/* Initialize the GCC target structure. */
static struct machine_function* iq2000_init_machine_status (void);
static void iq2000_option_override (void);
static section *iq2000_select_rtx_section (enum machine_mode, rtx,
static section *iq2000_select_rtx_section (machine_mode, rtx,
unsigned HOST_WIDE_INT);
static void iq2000_init_builtins (void);
static rtx iq2000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
static rtx iq2000_expand_builtin (tree, rtx, rtx, machine_mode, int);
static bool iq2000_return_in_memory (const_tree, const_tree);
static void iq2000_setup_incoming_varargs (cumulative_args_t,
enum machine_mode, tree, int *,
machine_mode, tree, int *,
int);
static bool iq2000_rtx_costs (rtx, int, int, int, int *, bool);
static int iq2000_address_cost (rtx, enum machine_mode, addr_space_t,
static int iq2000_address_cost (rtx, machine_mode, addr_space_t,
bool);
static section *iq2000_select_section (tree, int, unsigned HOST_WIDE_INT);
static rtx iq2000_legitimize_address (rtx, rtx, enum machine_mode);
static bool iq2000_pass_by_reference (cumulative_args_t, enum machine_mode,
static rtx iq2000_legitimize_address (rtx, rtx, machine_mode);
static bool iq2000_pass_by_reference (cumulative_args_t, machine_mode,
const_tree, bool);
static int iq2000_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static int iq2000_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx iq2000_function_arg (cumulative_args_t,
enum machine_mode, const_tree, bool);
machine_mode, const_tree, bool);
static void iq2000_function_arg_advance (cumulative_args_t,
enum machine_mode, const_tree, bool);
static unsigned int iq2000_function_arg_boundary (enum machine_mode,
machine_mode, const_tree, bool);
static unsigned int iq2000_function_arg_boundary (machine_mode,
const_tree);
static void iq2000_va_start (tree, rtx);
static bool iq2000_legitimate_address_p (enum machine_mode, rtx, bool);
static bool iq2000_legitimate_address_p (machine_mode, rtx, bool);
static bool iq2000_can_eliminate (const int, const int);
static void iq2000_asm_trampoline_template (FILE *);
static void iq2000_trampoline_init (rtx, tree, rtx);
static rtx iq2000_function_value (const_tree, const_tree, bool);
static rtx iq2000_libcall_value (enum machine_mode, const_rtx);
static rtx iq2000_libcall_value (machine_mode, const_rtx);
static void iq2000_print_operand (FILE *, rtx, int);
static void iq2000_print_operand_address (FILE *, rtx);
static bool iq2000_print_operand_punct_valid_p (unsigned char code);
@ -272,7 +272,7 @@ struct gcc_target targetm = TARGET_INITIALIZER;
/* Return nonzero if we split the address into high and low parts. */
int
iq2000_check_split (rtx address, enum machine_mode mode)
iq2000_check_split (rtx address, machine_mode mode)
{
/* This is the same check used in simple_memory_operand.
We use it here because LO_SUM is not offsettable. */
@ -292,7 +292,7 @@ iq2000_check_split (rtx address, enum machine_mode mode)
int
iq2000_reg_mode_ok_for_base_p (rtx reg,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int strict)
{
return (strict
@ -305,7 +305,7 @@ iq2000_reg_mode_ok_for_base_p (rtx reg,
function is called during reload. */
bool
iq2000_legitimate_address_p (enum machine_mode mode, rtx xinsn, bool strict)
iq2000_legitimate_address_p (machine_mode mode, rtx xinsn, bool strict)
{
if (TARGET_DEBUG_A_MODE)
{
@ -366,7 +366,7 @@ iq2000_legitimate_address_p (enum machine_mode mode, rtx xinsn, bool strict)
}
if (TARGET_DEBUG_A_MODE)
GO_PRINTF ("Not a enum machine_mode mode, legitimate address\n");
GO_PRINTF ("Not a machine_mode mode, legitimate address\n");
/* The address was not legitimate. */
return 0;
@ -386,7 +386,7 @@ iq2000_fill_delay_slot (const char *ret, enum delay_type type, rtx operands[],
rtx_insn *cur_insn)
{
rtx set_reg;
enum machine_mode mode;
machine_mode mode;
rtx_insn *next_insn = cur_insn ? NEXT_INSN (cur_insn) : NULL;
int num_nops;
@ -573,7 +573,7 @@ iq2000_move_1word (rtx operands[], rtx_insn *insn, int unsignedp)
rtx op1 = operands[1];
enum rtx_code code0 = GET_CODE (op0);
enum rtx_code code1 = GET_CODE (op1);
enum machine_mode mode = GET_MODE (op0);
machine_mode mode = GET_MODE (op0);
int subreg_offset0 = 0;
int subreg_offset1 = 0;
enum delay_type delay = DELAY_NONE;
@ -796,7 +796,7 @@ iq2000_move_1word (rtx operands[], rtx_insn *insn, int unsignedp)
/* Provide the costs of an addressing mode that contains ADDR. */
static int
iq2000_address_cost (rtx addr, enum machine_mode mode, addr_space_t as,
iq2000_address_cost (rtx addr, machine_mode mode, addr_space_t as,
bool speed)
{
switch (GET_CODE (addr))
@ -924,7 +924,7 @@ gen_int_relational (enum rtx_code test_code, rtx result, rtx cmp0, rtx cmp1,
};
enum internal_test test;
enum machine_mode mode;
machine_mode mode;
struct cmp_info *p_info;
int branch_p;
int eqne_p;
@ -1058,7 +1058,7 @@ gen_int_relational (enum rtx_code test_code, rtx result, rtx cmp0, rtx cmp1,
The comparison operands are saved away by cmp{si,di,sf,df}. */
void
gen_conditional_branch (rtx operands[], enum machine_mode mode)
gen_conditional_branch (rtx operands[], machine_mode mode)
{
enum rtx_code test_code = GET_CODE (operands[0]);
rtx cmp0 = operands[1];
@ -1147,7 +1147,7 @@ init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
position in CUM. */
static void
iq2000_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
iq2000_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1218,7 +1218,7 @@ iq2000_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
and type TYPE in CUM, or 0 if the argument is to be passed on the stack. */
static rtx
iq2000_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
iq2000_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1375,7 +1375,7 @@ iq2000_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
if (mode == VOIDmode)
{
if (cum->num_adjusts > 0)
ret = gen_rtx_PARALLEL ((enum machine_mode) cum->fp_code,
ret = gen_rtx_PARALLEL ((machine_mode) cum->fp_code,
gen_rtvec_v (cum->num_adjusts, cum->adjust));
}
@ -1383,7 +1383,7 @@ iq2000_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
}
static unsigned int
iq2000_function_arg_boundary (enum machine_mode mode, const_tree type)
iq2000_function_arg_boundary (machine_mode mode, const_tree type)
{
return (type != NULL_TREE
? (TYPE_ALIGN (type) <= PARM_BOUNDARY
@ -1395,7 +1395,7 @@ iq2000_function_arg_boundary (enum machine_mode mode, const_tree type)
}
static int
iq2000_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
iq2000_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1934,7 +1934,7 @@ iq2000_expand_prologue (void)
for (cur_arg = fnargs; cur_arg != 0; cur_arg = next_arg)
{
tree passed_type = DECL_ARG_TYPE (cur_arg);
enum machine_mode passed_mode = TYPE_MODE (passed_type);
machine_mode passed_mode = TYPE_MODE (passed_type);
rtx entry_parm;
if (TREE_ADDRESSABLE (passed_type))
@ -2167,7 +2167,7 @@ iq2000_can_use_return_insn (void)
mode MODE. */
static section *
iq2000_select_rtx_section (enum machine_mode mode, rtx x ATTRIBUTE_UNUSED,
iq2000_select_rtx_section (machine_mode mode, rtx x ATTRIBUTE_UNUSED,
unsigned HOST_WIDE_INT align)
{
/* For embedded applications, always put constants in read-only data,
@ -2226,7 +2226,7 @@ iq2000_function_value (const_tree valtype,
bool outgoing ATTRIBUTE_UNUSED)
{
int reg = GP_RETURN;
enum machine_mode mode = TYPE_MODE (valtype);
machine_mode mode = TYPE_MODE (valtype);
int unsignedp = TYPE_UNSIGNED (valtype);
const_tree func = fn_decl_or_type;
@ -2243,7 +2243,7 @@ iq2000_function_value (const_tree valtype,
/* Worker function for TARGET_LIBCALL_VALUE. */
static rtx
iq2000_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
iq2000_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (((GET_MODE_CLASS (mode) != MODE_INT
|| GET_MODE_SIZE (mode) >= 4)
@ -2265,7 +2265,7 @@ iq2000_function_value_regno_p (const unsigned int regno)
/* Return true when an argument must be passed by reference. */
static bool
iq2000_pass_by_reference (cumulative_args_t cum_v, enum machine_mode mode,
iq2000_pass_by_reference (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -2602,7 +2602,7 @@ expand_one_builtin (enum insn_code icode, rtx target, tree exp,
rtx pat;
tree arg [5];
rtx op [5];
enum machine_mode mode [5];
machine_mode mode [5];
int i;
mode[0] = insn_data[icode].operand[0].mode;
@ -2674,7 +2674,7 @@ expand_one_builtin (enum insn_code icode, rtx target, tree exp,
static rtx
iq2000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
int ignore ATTRIBUTE_UNUSED)
{
tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
@ -2866,7 +2866,7 @@ iq2000_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
static void
iq2000_setup_incoming_varargs (cumulative_args_t cum_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
tree type ATTRIBUTE_UNUSED, int * pretend_size,
int no_rtl)
{
@ -3250,7 +3250,7 @@ iq2000_print_operand_punct_valid_p (unsigned char code)
rtx
iq2000_legitimize_address (rtx xinsn, rtx old_x ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
if (TARGET_DEBUG_B_MODE)
{
@ -3310,7 +3310,7 @@ iq2000_rtx_costs (rtx x, int code, int outer_code ATTRIBUTE_UNUSED,
int opno ATTRIBUTE_UNUSED, int * total,
bool speed ATTRIBUTE_UNUSED)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
switch (code)
{

2
gcc/config/iq2000/iq2000.md
View File

@ -691,7 +691,7 @@
{
if (iq2000_check_split (operands[1], SImode))
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx tem = ((reload_in_progress | reload_completed)
? operands[0] : gen_reg_rtx (mode));

4
gcc/config/lm32/lm32-protos.h
View File

@ -32,7 +32,7 @@ extern int lm32_can_use_return (void);
extern rtx lm32_return_addr_rtx (int count, rtx frame);
extern int lm32_expand_block_move (rtx *);
extern int nonpic_symbol_mentioned_p (rtx);
extern rtx lm32_legitimize_pic_address (rtx, enum machine_mode, rtx);
extern rtx lm32_legitimize_pic_address (rtx, machine_mode, rtx);
extern void lm32_expand_scc (rtx operands[]);
extern void lm32_expand_conditional_branch (rtx operands[]);
extern bool lm32_move_ok (enum machine_mode, rtx operands[2]);
extern bool lm32_move_ok (machine_mode, rtx operands[2]);

24
gcc/config/lm32/lm32.c
View File

@ -81,20 +81,20 @@ static void expand_save_restore (struct lm32_frame_info *info, int op);
static void stack_adjust (HOST_WIDE_INT amount);
static bool lm32_in_small_data_p (const_tree);
static void lm32_setup_incoming_varargs (cumulative_args_t cum,
enum machine_mode mode, tree type,
machine_mode mode, tree type,
int *pretend_size, int no_rtl);
static bool lm32_rtx_costs (rtx x, int code, int outer_code, int opno,
int *total, bool speed);
static bool lm32_can_eliminate (const int, const int);
static bool
lm32_legitimate_address_p (enum machine_mode mode, rtx x, bool strict);
lm32_legitimate_address_p (machine_mode mode, rtx x, bool strict);
static HOST_WIDE_INT lm32_compute_frame_size (int size);
static void lm32_option_override (void);
static rtx lm32_function_arg (cumulative_args_t cum,
enum machine_mode mode, const_tree type,
machine_mode mode, const_tree type,
bool named);
static void lm32_function_arg_advance (cumulative_args_t cum,
enum machine_mode mode,
machine_mode mode,
const_tree type, bool named);
#undef TARGET_OPTION_OVERRIDE
@ -178,7 +178,7 @@ gen_int_relational (enum rtx_code code,
rtx cmp1,
rtx destination)
{
enum machine_mode mode;
machine_mode mode;
int branch_p;
mode = GET_MODE (cmp0);
@ -632,7 +632,7 @@ lm32_print_operand_address (FILE * file, rtx addr)
(otherwise it is an extra parameter matching an ellipsis). */
static rtx
lm32_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
lm32_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -651,7 +651,7 @@ lm32_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
}
static void
lm32_function_arg_advance (cumulative_args_t cum, enum machine_mode mode,
lm32_function_arg_advance (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
*get_cumulative_args (cum) += LM32_NUM_REGS2 (mode, type);
@ -687,7 +687,7 @@ lm32_compute_initial_elimination_offset (int from, int to)
}
static void
lm32_setup_incoming_varargs (cumulative_args_t cum_v, enum machine_mode mode,
lm32_setup_incoming_varargs (cumulative_args_t cum_v, machine_mode mode,
tree type, int *pretend_size, int no_rtl)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -831,7 +831,7 @@ lm32_block_move_inline (rtx dest, rtx src, HOST_WIDE_INT length,
HOST_WIDE_INT offset, delta;
unsigned HOST_WIDE_INT bits;
int i;
enum machine_mode mode;
machine_mode mode;
rtx *regs;
/* Work out how many bits to move at a time. */
@ -940,7 +940,7 @@ static bool
lm32_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
int *total, bool speed)
{
enum machine_mode mode = GET_MODE (x);
machine_mode mode = GET_MODE (x);
bool small_mode;
const int arithmetic_latency = 1;
@ -1207,7 +1207,7 @@ lm32_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
lm32_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x, bool strict)
lm32_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x, bool strict)
{
/* (rM) */
if (strict && REG_P (x) && STRICT_REG_OK_FOR_BASE_P (x))
@ -1234,7 +1234,7 @@ lm32_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x, bool
/* Check a move is not memory to memory. */
bool
lm32_move_ok (enum machine_mode mode, rtx operands[2]) {
lm32_move_ok (machine_mode mode, rtx operands[2]) {
if (memory_operand (operands[0], mode))
return register_or_zero_operand (operands[1], mode);
return true;

22
gcc/config/m32c/m32c-protos.h
View File

@ -38,7 +38,7 @@ int m32c_trampoline_size (void);
#ifdef RTX_CODE
int m32c_cannot_change_mode_class (enum machine_mode, enum machine_mode, int);
int m32c_cannot_change_mode_class (machine_mode, machine_mode, int);
rtx m32c_eh_return_stackadj_rtx (void);
void m32c_emit_eh_epilogue (rtx);
int m32c_expand_cmpstr (rtx *);
@ -49,24 +49,24 @@ int m32c_expand_movstr (rtx *);
void m32c_expand_neg_mulpsi3 (rtx *);
int m32c_expand_setmemhi (rtx *);
bool m32c_matches_constraint_p (rtx, int);
int m32c_hard_regno_nregs (int, enum machine_mode);
int m32c_hard_regno_ok (int, enum machine_mode);
int m32c_hard_regno_nregs (int, machine_mode);
int m32c_hard_regno_ok (int, machine_mode);
bool m32c_illegal_subreg_p (rtx);
bool m32c_immd_dbl_mov (rtx *, enum machine_mode);
bool m32c_immd_dbl_mov (rtx *, machine_mode);
rtx m32c_incoming_return_addr_rtx (void);
int m32c_legitimize_reload_address (rtx *, enum machine_mode, int, int, int);
int m32c_limit_reload_class (enum machine_mode, int);
int m32c_modes_tieable_p (enum machine_mode, enum machine_mode);
bool m32c_mov_ok (rtx *, enum machine_mode);
int m32c_legitimize_reload_address (rtx *, machine_mode, int, int, int);
int m32c_limit_reload_class (machine_mode, int);
int m32c_modes_tieable_p (machine_mode, machine_mode);
bool m32c_mov_ok (rtx *, machine_mode);
char * m32c_output_compare (rtx_insn *, rtx *);
int m32c_prepare_move (rtx *, enum machine_mode);
int m32c_prepare_move (rtx *, machine_mode);
int m32c_prepare_shift (rtx *, int, int);
int m32c_reg_ok_for_base_p (rtx, int);
enum reg_class m32c_regno_reg_class (int);
rtx m32c_return_addr_rtx (int);
const char *m32c_scc_pattern (rtx *, RTX_CODE);
int m32c_secondary_reload_class (int, enum machine_mode, rtx);
int m32c_split_move (rtx *, enum machine_mode, int);
int m32c_secondary_reload_class (int, machine_mode, rtx);
int m32c_split_move (rtx *, machine_mode, int);
int m32c_split_psi_p (rtx *);
int current_function_special_page_vector (rtx);

96
gcc/config/m32c/m32c.c
View File

@ -96,22 +96,22 @@ static int m32c_comp_type_attributes (const_tree, const_tree);
static bool m32c_fixed_condition_code_regs (unsigned int *, unsigned int *);
static struct machine_function *m32c_init_machine_status (void);
static void m32c_insert_attributes (tree, tree *);
static bool m32c_legitimate_address_p (enum machine_mode, rtx, bool);
static bool m32c_addr_space_legitimate_address_p (enum machine_mode, rtx, bool, addr_space_t);
static rtx m32c_function_arg (cumulative_args_t, enum machine_mode,
static bool m32c_legitimate_address_p (machine_mode, rtx, bool);
static bool m32c_addr_space_legitimate_address_p (machine_mode, rtx, bool, addr_space_t);
static rtx m32c_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static bool m32c_pass_by_reference (cumulative_args_t, enum machine_mode,
static bool m32c_pass_by_reference (cumulative_args_t, machine_mode,
const_tree, bool);
static void m32c_function_arg_advance (cumulative_args_t, enum machine_mode,
static void m32c_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static unsigned int m32c_function_arg_boundary (enum machine_mode, const_tree);
static unsigned int m32c_function_arg_boundary (machine_mode, const_tree);
static int m32c_pushm_popm (Push_Pop_Type);
static bool m32c_strict_argument_naming (cumulative_args_t);
static rtx m32c_struct_value_rtx (tree, int);
static rtx m32c_subreg (enum machine_mode, rtx, enum machine_mode, int);
static rtx m32c_subreg (machine_mode, rtx, machine_mode, int);
static int need_to_save (int);
static rtx m32c_function_value (const_tree, const_tree, bool);
static rtx m32c_libcall_value (enum machine_mode, const_rtx);
static rtx m32c_libcall_value (machine_mode, const_rtx);
/* Returns true if an address is specified, else false. */
static bool m32c_get_pragma_address (const char *varname, unsigned *addr);
@ -291,7 +291,7 @@ encode_pattern (rtx x)
by print_operand(). */
static const char *
reg_name_with_mode (int regno, enum machine_mode mode)
reg_name_with_mode (int regno, machine_mode mode)
{
int mlen = GET_MODE_SIZE (mode);
if (regno == R0_REGNO && mlen == 1)
@ -379,7 +379,7 @@ reduce_class (reg_class_t original_class, reg_class_t limiting_class,
/* Used by m32c_register_move_cost to determine if a move is
impossibly expensive. */
static bool
class_can_hold_mode (reg_class_t rclass, enum machine_mode mode)
class_can_hold_mode (reg_class_t rclass, machine_mode mode)
{
/* Cache the results: 0=untested 1=no 2=yes */
static char results[LIM_REG_CLASSES][MAX_MACHINE_MODE];
@ -561,7 +561,7 @@ m32c_conditional_register_usage (void)
different registers are different sizes from each other, *and* may
be different sizes in different chip families. */
static int
m32c_hard_regno_nregs_1 (int regno, enum machine_mode mode)
m32c_hard_regno_nregs_1 (int regno, machine_mode mode)
{
if (regno == FLG_REGNO && mode == CCmode)
return 1;
@ -587,7 +587,7 @@ m32c_hard_regno_nregs_1 (int regno, enum machine_mode mode)
}
int
m32c_hard_regno_nregs (int regno, enum machine_mode mode)
m32c_hard_regno_nregs (int regno, machine_mode mode)
{
int rv = m32c_hard_regno_nregs_1 (regno, mode);
return rv ? rv : 1;
@ -596,7 +596,7 @@ m32c_hard_regno_nregs (int regno, enum machine_mode mode)
/* Implements HARD_REGNO_MODE_OK. The above function does the work
already; just test its return value. */
int
m32c_hard_regno_ok (int regno, enum machine_mode mode)
m32c_hard_regno_ok (int regno, machine_mode mode)
{
return m32c_hard_regno_nregs_1 (regno, mode) != 0;
}
@ -606,7 +606,7 @@ m32c_hard_regno_ok (int regno, enum machine_mode mode)
bigger than our registers anyway, it's easier to implement this
function that way, leaving QImode as the only unique case. */
int
m32c_modes_tieable_p (enum machine_mode m1, enum machine_mode m2)
m32c_modes_tieable_p (machine_mode m1, machine_mode m2)
{
if (GET_MODE_SIZE (m1) == GET_MODE_SIZE (m2))
return 1;
@ -735,7 +735,7 @@ m32c_preferred_output_reload_class (rtx x, reg_class_t rclass)
address registers for reloads since they're needed for address
reloads. */
int
m32c_limit_reload_class (enum machine_mode mode, int rclass)
m32c_limit_reload_class (machine_mode mode, int rclass)
{
#if DEBUG_RELOAD
fprintf (stderr, "limit_reload_class for %s: %s ->",
@ -763,7 +763,7 @@ m32c_limit_reload_class (enum machine_mode mode, int rclass)
reloaded through appropriately sized general or address
registers. */
int
m32c_secondary_reload_class (int rclass, enum machine_mode mode, rtx x)
m32c_secondary_reload_class (int rclass, machine_mode mode, rtx x)
{
int cc = class_contents[rclass][0];
#if DEBUG0
@ -804,7 +804,7 @@ m32c_class_likely_spilled_p (reg_class_t regclass)
#define TARGET_CLASS_MAX_NREGS m32c_class_max_nregs
static unsigned char
m32c_class_max_nregs (reg_class_t regclass, enum machine_mode mode)
m32c_class_max_nregs (reg_class_t regclass, machine_mode mode)
{
int rn;
unsigned char max = 0;
@ -824,8 +824,8 @@ m32c_class_max_nregs (reg_class_t regclass, enum machine_mode mode)
registers (well, it does on a0/a1 but if we let gcc do that, reload
suffers). Otherwise, we allow changes to larger modes. */
int
m32c_cannot_change_mode_class (enum machine_mode from,
enum machine_mode to, int rclass)
m32c_cannot_change_mode_class (machine_mode from,
machine_mode to, int rclass)
{
int rn;
#if DEBUG0
@ -962,7 +962,7 @@ m32c_matches_constraint_p (rtx value, int constraint)
rtx
m32c_return_addr_rtx (int count)
{
enum machine_mode mode;
machine_mode mode;
int offset;
rtx ra_mem;
@ -1189,7 +1189,7 @@ m32c_pushm_popm (Push_Pop_Type ppt)
if (ppt == PP_pushm)
{
enum machine_mode mode = (bytes == 2) ? HImode : SImode;
machine_mode mode = (bytes == 2) ? HImode : SImode;
rtx addr;
/* Always use stack_pointer_rtx instead of calling
@ -1344,7 +1344,7 @@ m32c_push_rounding (int n)
#define TARGET_FUNCTION_ARG m32c_function_arg
static rtx
m32c_function_arg (cumulative_args_t ca_v,
enum machine_mode mode, const_tree type, bool named)
machine_mode mode, const_tree type, bool named)
{
CUMULATIVE_ARGS *ca = get_cumulative_args (ca_v);
@ -1397,7 +1397,7 @@ m32c_function_arg (cumulative_args_t ca_v,
#define TARGET_PASS_BY_REFERENCE m32c_pass_by_reference
static bool
m32c_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1427,7 +1427,7 @@ m32c_init_cumulative_args (CUMULATIVE_ARGS * ca,
#define TARGET_FUNCTION_ARG_ADVANCE m32c_function_arg_advance
static void
m32c_function_arg_advance (cumulative_args_t ca_v,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1443,7 +1443,7 @@ m32c_function_arg_advance (cumulative_args_t ca_v,
#undef TARGET_FUNCTION_ARG_BOUNDARY
#define TARGET_FUNCTION_ARG_BOUNDARY m32c_function_arg_boundary
static unsigned int
m32c_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
m32c_function_arg_boundary (machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED)
{
return (TARGET_A16 ? 8 : 16);
@ -1464,7 +1464,7 @@ m32c_function_arg_regno_p (int r)
#undef TARGET_VALID_POINTER_MODE
#define TARGET_VALID_POINTER_MODE m32c_valid_pointer_mode
static bool
m32c_valid_pointer_mode (enum machine_mode mode)
m32c_valid_pointer_mode (machine_mode mode)
{
if (mode == HImode
|| mode == PSImode
@ -1488,7 +1488,7 @@ m32c_valid_pointer_mode (enum machine_mode mode)
#define TARGET_LIBCALL_VALUE m32c_libcall_value
static rtx
m32c_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
m32c_libcall_value (machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
{
/* return reg or parallel */
#if 0
@ -1550,7 +1550,7 @@ m32c_function_value (const_tree valtype,
bool outgoing ATTRIBUTE_UNUSED)
{
/* return reg or parallel */
const enum machine_mode mode = TYPE_MODE (valtype);
const machine_mode mode = TYPE_MODE (valtype);
return m32c_libcall_value (mode, NULL_RTX);
}
@ -1672,7 +1672,7 @@ m32c_trampoline_init (rtx m_tramp, tree fndecl, rtx chainval)
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P m32c_legitimate_address_p
bool
m32c_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
m32c_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
int mode_adjust;
if (CONSTANT_P (x))
@ -1852,7 +1852,7 @@ m32c_reg_ok_for_base_p (rtx x, int strict)
#define TARGET_LEGITIMIZE_ADDRESS m32c_legitimize_address
static rtx
m32c_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
enum machine_mode mode)
machine_mode mode)
{
#if DEBUG0
fprintf (stderr, "m32c_legitimize_address for mode %s\n", mode_name[mode]);
@ -1880,7 +1880,7 @@ m32c_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
/* Implements LEGITIMIZE_RELOAD_ADDRESS. See comment above. */
int
m32c_legitimize_reload_address (rtx * x,
enum machine_mode mode,
machine_mode mode,
int opnum,
int type, int ind_levels ATTRIBUTE_UNUSED)
{
@ -1943,7 +1943,7 @@ m32c_legitimize_reload_address (rtx * x,
/* Return the appropriate mode for a named address pointer. */
#undef TARGET_ADDR_SPACE_POINTER_MODE
#define TARGET_ADDR_SPACE_POINTER_MODE m32c_addr_space_pointer_mode
static enum machine_mode
static machine_mode
m32c_addr_space_pointer_mode (addr_space_t addrspace)
{
switch (addrspace)
@ -1960,7 +1960,7 @@ m32c_addr_space_pointer_mode (addr_space_t addrspace)
/* Return the appropriate mode for a named address address. */
#undef TARGET_ADDR_SPACE_ADDRESS_MODE
#define TARGET_ADDR_SPACE_ADDRESS_MODE m32c_addr_space_address_mode
static enum machine_mode
static machine_mode
m32c_addr_space_address_mode (addr_space_t addrspace)
{
switch (addrspace)
@ -1979,7 +1979,7 @@ m32c_addr_space_address_mode (addr_space_t addrspace)
#define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P \
m32c_addr_space_legitimate_address_p
static bool
m32c_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
m32c_addr_space_legitimate_address_p (machine_mode mode, rtx x,
bool strict, addr_space_t as)
{
if (as == ADDR_SPACE_FAR)
@ -2068,7 +2068,7 @@ m32c_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
#undef TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS
#define TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS m32c_addr_space_legitimize_address
static rtx
m32c_addr_space_legitimize_address (rtx x, rtx oldx, enum machine_mode mode,
m32c_addr_space_legitimize_address (rtx x, rtx oldx, machine_mode mode,
addr_space_t as)
{
if (as != ADDR_SPACE_GENERIC)
@ -2161,7 +2161,7 @@ m32c_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
#define TARGET_REGISTER_MOVE_COST m32c_register_move_cost
static int
m32c_register_move_cost (enum machine_mode mode, reg_class_t from,
m32c_register_move_cost (machine_mode mode, reg_class_t from,
reg_class_t to)
{
int cost = COSTS_N_INSNS (3);
@ -2209,7 +2209,7 @@ m32c_register_move_cost (enum machine_mode mode, reg_class_t from,
#define TARGET_MEMORY_MOVE_COST m32c_memory_move_cost
static int
m32c_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
m32c_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -2302,7 +2302,7 @@ m32c_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
#undef TARGET_ADDRESS_COST
#define TARGET_ADDRESS_COST m32c_address_cost
static int
m32c_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED,
m32c_address_cost (rtx addr, machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
@ -3146,7 +3146,7 @@ m32c_illegal_subreg_p (rtx op)
{
int offset;
unsigned int i;
enum machine_mode src_mode, dest_mode;
machine_mode src_mode, dest_mode;
if (GET_CODE (op) == MEM
&& ! m32c_legitimate_address_p (Pmode, XEXP (op, 0), false))
@ -3200,7 +3200,7 @@ m32c_illegal_subreg_p (rtx op)
number of address registers, and we can get into a situation where
we need three of them when we only have two. */
bool
m32c_mov_ok (rtx * operands, enum machine_mode mode ATTRIBUTE_UNUSED)
m32c_mov_ok (rtx * operands, machine_mode mode ATTRIBUTE_UNUSED)
{
rtx op0 = operands[0];
rtx op1 = operands[1];
@ -3241,7 +3241,7 @@ m32c_mov_ok (rtx * operands, enum machine_mode mode ATTRIBUTE_UNUSED)
location, can be combined into single SImode mov instruction. */
bool
m32c_immd_dbl_mov (rtx * operands ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED)
machine_mode mode ATTRIBUTE_UNUSED)
{
/* ??? This relied on the now-defunct MEM_SCALAR and MEM_IN_STRUCT_P
flags. */
@ -3253,8 +3253,8 @@ m32c_immd_dbl_mov (rtx * operands ATTRIBUTE_UNUSED,
/* Subregs are non-orthogonal for us, because our registers are all
different sizes. */
static rtx
m32c_subreg (enum machine_mode outer,
rtx x, enum machine_mode inner, int byte)
m32c_subreg (machine_mode outer,
rtx x, machine_mode inner, int byte)
{
int r, nr = -1;
@ -3341,7 +3341,7 @@ m32c_subreg (enum machine_mode outer,
/* Used to emit move instructions. We split some moves,
and avoid mem-mem moves. */
int
m32c_prepare_move (rtx * operands, enum machine_mode mode)
m32c_prepare_move (rtx * operands, machine_mode mode)
{
if (far_addr_space_p (operands[0])
&& CONSTANT_P (operands[1]))
@ -3403,12 +3403,12 @@ m32c_split_psi_p (rtx * operands)
(define_expand), 1 if it is not optional (define_insn_and_split),
and 3 for define_split (alternate api). */
int
m32c_split_move (rtx * operands, enum machine_mode mode, int split_all)
m32c_split_move (rtx * operands, machine_mode mode, int split_all)
{
rtx s[4], d[4];
int parts, si, di, rev = 0;
int rv = 0, opi = 2;
enum machine_mode submode = HImode;
machine_mode submode = HImode;
rtx *ops, local_ops[10];
/* define_split modifies the existing operands, but the other two
@ -3744,7 +3744,7 @@ shift_gen_func_for (int mode, int code)
int
m32c_prepare_shift (rtx * operands, int scale, int shift_code)
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
shift_gen_func func = shift_gen_func_for (mode, shift_code);
rtx temp;
@ -4183,7 +4183,7 @@ m32c_emit_epilogue (void)
if (cfun->machine->is_interrupt)
{
enum machine_mode spmode = TARGET_A16 ? HImode : PSImode;
machine_mode spmode = TARGET_A16 ? HImode : PSImode;
/* REIT clears B flag and restores $fp for us, but we still
have to fix up the stack. USE_RTS just means we didn't

14
gcc/config/m32r/m32r-protos.h
View File

@ -49,13 +49,13 @@ extern rtx m32r_return_addr (int);
extern rtx m32r_function_symbol (const char *);
#ifdef HAVE_MACHINE_MODES
extern int call_operand (rtx, enum machine_mode);
extern int small_data_operand (rtx, enum machine_mode);
extern int addr24_operand (rtx, enum machine_mode);
extern int addr32_operand (rtx, enum machine_mode);
extern int call26_operand (rtx, enum machine_mode);
extern int memreg_operand (rtx, enum machine_mode);
extern int small_insn_p (rtx, enum machine_mode);
extern int call_operand (rtx, machine_mode);
extern int small_data_operand (rtx, machine_mode);
extern int addr24_operand (rtx, machine_mode);
extern int addr32_operand (rtx, machine_mode);
extern int call26_operand (rtx, machine_mode);
extern int memreg_operand (rtx, machine_mode);
extern int small_insn_p (rtx, machine_mode);
#endif /* HAVE_MACHINE_MODES */

66
gcc/config/m32r/m32r.c
View File

@ -78,8 +78,8 @@ static void m32r_option_override (void);
static void init_reg_tables (void);
static void block_move_call (rtx, rtx, rtx);
static int m32r_is_insn (rtx);
static bool m32r_legitimate_address_p (enum machine_mode, rtx, bool);
static rtx m32r_legitimize_address (rtx, rtx, enum machine_mode);
static bool m32r_legitimate_address_p (machine_mode, rtx, bool);
static rtx m32r_legitimize_address (rtx, rtx, machine_mode);
static bool m32r_mode_dependent_address_p (const_rtx, addr_space_t);
static tree m32r_handle_model_attribute (tree *, tree, tree, int, bool *);
static void m32r_print_operand (FILE *, rtx, int);
@ -97,25 +97,25 @@ static void m32r_encode_section_info (tree, rtx, int);
static bool m32r_in_small_data_p (const_tree);
static bool m32r_return_in_memory (const_tree, const_tree);
static rtx m32r_function_value (const_tree, const_tree, bool);
static rtx m32r_libcall_value (enum machine_mode, const_rtx);
static rtx m32r_libcall_value (machine_mode, const_rtx);
static bool m32r_function_value_regno_p (const unsigned int);
static void m32r_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
static void m32r_setup_incoming_varargs (cumulative_args_t, machine_mode,
tree, int *, int);
static void init_idents (void);
static bool m32r_rtx_costs (rtx, int, int, int, int *, bool speed);
static int m32r_memory_move_cost (enum machine_mode, reg_class_t, bool);
static bool m32r_pass_by_reference (cumulative_args_t, enum machine_mode,
static int m32r_memory_move_cost (machine_mode, reg_class_t, bool);
static bool m32r_pass_by_reference (cumulative_args_t, machine_mode,
const_tree, bool);
static int m32r_arg_partial_bytes (cumulative_args_t, enum machine_mode,
static int m32r_arg_partial_bytes (cumulative_args_t, machine_mode,
tree, bool);
static rtx m32r_function_arg (cumulative_args_t, enum machine_mode,
static rtx m32r_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static void m32r_function_arg_advance (cumulative_args_t, enum machine_mode,
static void m32r_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static bool m32r_can_eliminate (const int, const int);
static void m32r_conditional_register_usage (void);
static void m32r_trampoline_init (rtx, tree, rtx);
static bool m32r_legitimate_constant_p (enum machine_mode, rtx);
static bool m32r_legitimate_constant_p (machine_mode, rtx);
/* M32R specific attributes. */
@ -297,7 +297,7 @@ init_reg_tables (void)
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
enum machine_mode m = (enum machine_mode) i;
machine_mode m = (machine_mode) i;
switch (GET_MODE_CLASS (m))
{
@ -515,7 +515,7 @@ m32r_init_expanders (void)
}
int
call_operand (rtx op, enum machine_mode mode)
call_operand (rtx op, machine_mode mode)
{
if (!MEM_P (op))
return 0;
@ -526,7 +526,7 @@ call_operand (rtx op, enum machine_mode mode)
/* Return 1 if OP is a reference to an object in .sdata/.sbss. */
int
small_data_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
small_data_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
if (! TARGET_SDATA_USE)
return 0;
@ -546,7 +546,7 @@ small_data_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
/* Return 1 if OP is a symbol that can use 24-bit addressing. */
int
addr24_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
addr24_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
rtx sym;
@ -580,7 +580,7 @@ addr24_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
/* Return 1 if OP is a symbol that needs 32-bit addressing. */
int
addr32_operand (rtx op, enum machine_mode mode)
addr32_operand (rtx op, machine_mode mode)
{
rtx sym;
@ -605,7 +605,7 @@ addr32_operand (rtx op, enum machine_mode mode)
/* Return 1 if OP is a function that can be called with the `bl' insn. */
int
call26_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
call26_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
if (flag_pic)
return 1;
@ -659,7 +659,7 @@ easy_df_const (rtx op)
This is used in insn length calcs. */
int
memreg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
memreg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
return MEM_P (op) && REG_P (XEXP (op, 0));
}
@ -668,7 +668,7 @@ memreg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
static bool
m32r_pass_by_reference (cumulative_args_t ca ATTRIBUTE_UNUSED,
enum machine_mode mode, const_tree type,
machine_mode mode, const_tree type,
bool named ATTRIBUTE_UNUSED)
{
int size;
@ -893,7 +893,7 @@ gen_compare (enum rtx_code code, rtx x, rtx y, int need_compare)
bool
gen_cond_store (enum rtx_code code, rtx op0, rtx op1, rtx op2)
{
enum machine_mode mode = GET_MODE (op0);
machine_mode mode = GET_MODE (op0);
gcc_assert (mode == SImode);
switch (code)
@ -1040,7 +1040,7 @@ gen_cond_store (enum rtx_code code, rtx op0, rtx op1, rtx op2)
rtx
gen_split_move_double (rtx operands[])
{
enum machine_mode mode = GET_MODE (operands[0]);
machine_mode mode = GET_MODE (operands[0]);
rtx dest = operands[0];
rtx src = operands[1];
rtx val;
@ -1157,7 +1157,7 @@ gen_split_move_double (rtx operands[])
static int
m32r_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
m32r_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1217,7 +1217,7 @@ m32r_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
and the rest are pushed. */
static rtx
m32r_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
m32r_function_arg (cumulative_args_t cum_v, machine_mode mode,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1233,7 +1233,7 @@ m32r_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
(TYPE is null for libcalls where that information may not be available.) */
static void
m32r_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
m32r_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1265,7 +1265,7 @@ m32r_function_value (const_tree valtype,
/* Worker function for TARGET_LIBCALL_VALUE. */
static rtx
m32r_libcall_value (enum machine_mode mode,
m32r_libcall_value (machine_mode mode,
const_rtx fun ATTRIBUTE_UNUSED)
{
return gen_rtx_REG (mode, 0);
@ -1289,7 +1289,7 @@ m32r_function_value_regno_p (const unsigned int regno)
and mode MODE, and we rely on this fact. */
static void
m32r_setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
m32r_setup_incoming_varargs (cumulative_args_t cum, machine_mode mode,
tree type, int *pretend_size, int no_rtl)
{
int first_anon_arg;
@ -1363,7 +1363,7 @@ m32r_issue_rate (void)
??? Is that the right way to look at it? */
static int
m32r_memory_move_cost (enum machine_mode mode,
m32r_memory_move_cost (machine_mode mode,
reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
@ -2018,7 +2018,7 @@ m32r_legitimize_pic_address (rtx orig, rtx reg)
static rtx
m32r_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED)
machine_mode mode ATTRIBUTE_UNUSED)
{
if (flag_pic)
return m32r_legitimize_pic_address (x, NULL_RTX);
@ -2838,7 +2838,7 @@ m32r_rtx_ok_for_offset_p (const_rtx x)
}
static inline bool
m32r_legitimate_offset_addres_p (enum machine_mode mode ATTRIBUTE_UNUSED,
m32r_legitimate_offset_addres_p (machine_mode mode ATTRIBUTE_UNUSED,
const_rtx x, bool strict)
{
if (GET_CODE (x) == PLUS
@ -2853,7 +2853,7 @@ m32r_legitimate_offset_addres_p (enum machine_mode mode ATTRIBUTE_UNUSED,
since more than one instruction will be required. */
static inline bool
m32r_legitimate_lo_sum_addres_p (enum machine_mode mode, const_rtx x,
m32r_legitimate_lo_sum_addres_p (machine_mode mode, const_rtx x,
bool strict)
{
if (GET_CODE (x) == LO_SUM
@ -2868,7 +2868,7 @@ m32r_legitimate_lo_sum_addres_p (enum machine_mode mode, const_rtx x,
/* Is this a load and increment operation. */
static inline bool
m32r_load_postinc_p (enum machine_mode mode, const_rtx x, bool strict)
m32r_load_postinc_p (machine_mode mode, const_rtx x, bool strict)
{
if ((mode == SImode || mode == SFmode)
&& GET_CODE (x) == POST_INC
@ -2882,7 +2882,7 @@ m32r_load_postinc_p (enum machine_mode mode, const_rtx x, bool strict)
/* Is this an increment/decrement and store operation. */
static inline bool
m32r_store_preinc_predec_p (enum machine_mode mode, const_rtx x, bool strict)
m32r_store_preinc_predec_p (machine_mode mode, const_rtx x, bool strict)
{
if ((mode == SImode || mode == SFmode)
&& (GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
@ -2896,7 +2896,7 @@ m32r_store_preinc_predec_p (enum machine_mode mode, const_rtx x, bool strict)
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
m32r_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
m32r_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
if (m32r_rtx_ok_for_base_p (x, strict)
|| m32r_legitimate_offset_addres_p (mode, x, strict)
@ -2926,7 +2926,7 @@ m32r_conditional_register_usage (void)
constant to memory if they can't handle them. */
static bool
m32r_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
m32r_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return !(GET_CODE (x) == CONST
&& GET_CODE (XEXP (x, 0)) == PLUS

16
gcc/config/m68k/m68k-protos.h
View File

@ -44,7 +44,7 @@ extern const char *output_call (rtx);
extern const char *output_sibcall (rtx);
extern void output_dbcc_and_branch (rtx *);
extern int floating_exact_log2 (rtx);
extern bool strict_low_part_peephole_ok (enum machine_mode mode,
extern bool strict_low_part_peephole_ok (machine_mode mode,
rtx_insn *first_insn, rtx target);
/* Functions from m68k.c used in macros. */
@ -55,16 +55,16 @@ extern void notice_update_cc (rtx, rtx);
extern bool m68k_legitimate_base_reg_p (rtx, bool);
extern bool m68k_legitimate_index_reg_p (rtx, bool);
extern bool m68k_illegitimate_symbolic_constant_p (rtx);
extern bool m68k_legitimate_constant_p (enum machine_mode, rtx);
extern bool m68k_legitimate_constant_p (machine_mode, rtx);
extern bool m68k_matches_q_p (rtx);
extern bool m68k_matches_u_p (rtx);
extern rtx legitimize_pic_address (rtx, enum machine_mode, rtx);
extern rtx legitimize_pic_address (rtx, machine_mode, rtx);
extern rtx m68k_legitimize_tls_address (rtx);
extern bool m68k_tls_reference_p (rtx, bool);
extern int valid_dbcc_comparison_p_2 (rtx, enum machine_mode);
extern rtx m68k_libcall_value (enum machine_mode);
extern int valid_dbcc_comparison_p_2 (rtx, machine_mode);
extern rtx m68k_libcall_value (machine_mode);
extern rtx m68k_function_value (const_tree, const_tree);
extern int emit_move_sequence (rtx *, enum machine_mode, rtx);
extern int emit_move_sequence (rtx *, machine_mode, rtx);
extern bool m68k_movem_pattern_p (rtx, rtx, HOST_WIDE_INT, bool);
extern const char *m68k_output_movem (rtx *, rtx, HOST_WIDE_INT, bool);
extern void m68k_final_prescan_insn (rtx_insn *, rtx *, int);
@ -86,9 +86,9 @@ extern enum attr_op_mem m68k_sched_attr_op_mem (rtx_insn *);
#endif /* RTX_CODE */
extern bool m68k_regno_mode_ok (int, enum machine_mode);
extern bool m68k_regno_mode_ok (int, machine_mode);
extern enum reg_class m68k_secondary_reload_class (enum reg_class,
enum machine_mode, rtx);
machine_mode, rtx);
extern enum reg_class m68k_preferred_reload_class (rtx, enum reg_class);
extern int flags_in_68881 (void);
extern void m68k_expand_prologue (void);

54
gcc/config/m68k/m68k.c
View File

@ -152,7 +152,7 @@ static int m68k_sched_first_cycle_multipass_dfa_lookahead (void);
static bool m68k_can_eliminate (const int, const int);
static void m68k_conditional_register_usage (void);
static bool m68k_legitimate_address_p (enum machine_mode, rtx, bool);
static bool m68k_legitimate_address_p (machine_mode, rtx, bool);
static void m68k_option_override (void);
static void m68k_override_options_after_change (void);
static rtx find_addr_reg (rtx);
@ -167,7 +167,7 @@ static void m68k_compute_frame_layout (void);
static bool m68k_save_reg (unsigned int regno, bool interrupt_handler);
static bool m68k_ok_for_sibcall_p (tree, tree);
static bool m68k_tls_symbol_p (rtx);
static rtx m68k_legitimize_address (rtx, rtx, enum machine_mode);
static rtx m68k_legitimize_address (rtx, rtx, machine_mode);
static bool m68k_rtx_costs (rtx, int, int, int, int *, bool);
#if M68K_HONOR_TARGET_STRICT_ALIGNMENT
static bool m68k_return_in_memory (const_tree, const_tree);
@ -176,11 +176,11 @@ static void m68k_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
static void m68k_trampoline_init (rtx, tree, rtx);
static int m68k_return_pops_args (tree, tree, int);
static rtx m68k_delegitimize_address (rtx);
static void m68k_function_arg_advance (cumulative_args_t, enum machine_mode,
static void m68k_function_arg_advance (cumulative_args_t, machine_mode,
const_tree, bool);
static rtx m68k_function_arg (cumulative_args_t, enum machine_mode,
static rtx m68k_function_arg (cumulative_args_t, machine_mode,
const_tree, bool);
static bool m68k_cannot_force_const_mem (enum machine_mode mode, rtx x);
static bool m68k_cannot_force_const_mem (machine_mode mode, rtx x);
static bool m68k_output_addr_const_extra (FILE *, rtx);
static void m68k_init_sync_libfuncs (void) ATTRIBUTE_UNUSED;
@ -933,7 +933,7 @@ m68k_emit_movem (rtx base, HOST_WIDE_INT offset,
{
int i;
rtx body, addr, src, operands[2];
enum machine_mode mode;
machine_mode mode;
body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (adjust_stack_p + count));
mode = reg_raw_mode[regno];
@ -1326,7 +1326,7 @@ m68k_expand_epilogue (bool sibcall_p)
It also rejects some comparisons when CC_NO_OVERFLOW is set. */
int
valid_dbcc_comparison_p_2 (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
valid_dbcc_comparison_p_2 (rtx x, machine_mode mode ATTRIBUTE_UNUSED)
{
switch (GET_CODE (x))
{
@ -1425,7 +1425,7 @@ m68k_ok_for_sibcall_p (tree decl, tree exp)
static rtx
m68k_function_arg (cumulative_args_t cum ATTRIBUTE_UNUSED,
enum machine_mode mode ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED,
const_tree type ATTRIBUTE_UNUSED,
bool named ATTRIBUTE_UNUSED)
{
@ -1433,7 +1433,7 @@ m68k_function_arg (cumulative_args_t cum ATTRIBUTE_UNUSED,
}
static void
m68k_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
m68k_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -1477,7 +1477,7 @@ m68k_legitimize_sibcall_address (rtx x)
nothing needs to be done because REG can certainly go in an address reg. */
static rtx
m68k_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
m68k_legitimize_address (rtx x, rtx oldx, machine_mode mode)
{
if (m68k_tls_symbol_p (x))
return m68k_legitimize_tls_address (x);
@ -1906,7 +1906,7 @@ m68k_illegitimate_symbolic_constant_p (rtx x)
/* Implement TARGET_CANNOT_FORCE_CONST_MEM. */
static bool
m68k_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
m68k_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return m68k_illegitimate_symbolic_constant_p (x);
}
@ -1961,7 +1961,7 @@ m68k_jump_table_ref_p (rtx x)
is valid, describe its components in *ADDRESS. */
static bool
m68k_decompose_address (enum machine_mode mode, rtx x,
m68k_decompose_address (machine_mode mode, rtx x,
bool strict_p, struct m68k_address *address)
{
unsigned int reach;
@ -2109,7 +2109,7 @@ m68k_decompose_address (enum machine_mode mode, rtx x,
STRICT_P says whether strict checking is needed. */
bool
m68k_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
m68k_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
{
struct m68k_address address;
@ -2131,7 +2131,7 @@ m68k_legitimate_mem_p (rtx x, struct m68k_address *address)
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
bool
m68k_legitimate_constant_p (enum machine_mode mode, rtx x)
m68k_legitimate_constant_p (machine_mode mode, rtx x)
{
return mode != XFmode && !m68k_illegitimate_symbolic_constant_p (x);
}
@ -2435,7 +2435,7 @@ m68k_wrap_symbol_into_got_ref (rtx x, enum m68k_reloc reloc, rtx temp_reg)
handled. */
rtx
legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
legitimize_pic_address (rtx orig, machine_mode mode ATTRIBUTE_UNUSED,
rtx reg)
{
rtx pic_ref = orig;
@ -3568,7 +3568,7 @@ output_movsi (rtx operands[2])
/* Copy OP and change its mode to MODE. */
static rtx
copy_operand (rtx op, enum machine_mode mode)
copy_operand (rtx op, machine_mode mode)
{
/* ??? This looks really ugly. There must be a better way
to change a mode on the operand. */
@ -3619,7 +3619,7 @@ m68k_emit_move_double (rtx operands[2])
new rtx with the correct mode. */
static rtx
force_mode (enum machine_mode mode, rtx orig)
force_mode (machine_mode mode, rtx orig)
{
if (mode == GET_MODE (orig))
return orig;
@ -3631,7 +3631,7 @@ force_mode (enum machine_mode mode, rtx orig)
}
static int
fp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
fp_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
return reg_renumber && FP_REG_P (op);
}
@ -3647,7 +3647,7 @@ fp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
of SCRATCH_REG in the proper mode. */
int
emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
emit_move_sequence (rtx *operands, machine_mode mode, rtx scratch_reg)
{
register rtx operand0 = operands[0];
register rtx operand1 = operands[1];
@ -4309,7 +4309,7 @@ init_68881_table (void)
{
int i;
REAL_VALUE_TYPE r;
enum machine_mode mode;
machine_mode mode;
mode = SFmode;
for (i = 0; i < 7; i++)
@ -4804,7 +4804,7 @@ print_operand_address (FILE *file, rtx addr)
clear insn. */
bool
strict_low_part_peephole_ok (enum machine_mode mode, rtx_insn *first_insn,
strict_low_part_peephole_ok (machine_mode mode, rtx_insn *first_insn,
rtx target)
{
rtx_insn *p = first_insn;
@ -5167,7 +5167,7 @@ m68k_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED,
restrict the 68881 registers to floating-point modes. */
bool
m68k_regno_mode_ok (int regno, enum machine_mode mode)
m68k_regno_mode_ok (int regno, machine_mode mode)
{
if (DATA_REGNO_P (regno))
{
@ -5196,7 +5196,7 @@ m68k_regno_mode_ok (int regno, enum machine_mode mode)
enum reg_class
m68k_secondary_reload_class (enum reg_class rclass,
enum machine_mode mode, rtx x)
machine_mode mode, rtx x)
{
int regno;
@ -5259,7 +5259,7 @@ m68k_preferred_reload_class (rtx x, enum reg_class rclass)
If there is need for a hard-float ABI it is probably worth doing it
properly and also passing function arguments in FP registers. */
rtx
m68k_libcall_value (enum machine_mode mode)
m68k_libcall_value (machine_mode mode)
{
switch (mode) {
case SFmode:
@ -5281,7 +5281,7 @@ m68k_libcall_value (enum machine_mode mode)
rtx
m68k_function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED)
{
enum machine_mode mode;
machine_mode mode;
mode = TYPE_MODE (valtype);
switch (mode) {
@ -5324,7 +5324,7 @@ m68k_function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED)
static bool
m68k_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
{
enum machine_mode mode = TYPE_MODE (type);
machine_mode mode = TYPE_MODE (type);
if (mode == BLKmode)
return true;
@ -5386,7 +5386,7 @@ enum attr_op_type
/* Return type of memory ADDR_RTX refers to. */
static enum attr_op_type
sched_address_type (enum machine_mode mode, rtx addr_rtx)
sched_address_type (machine_mode mode, rtx addr_rtx)
{
struct m68k_address address;

8
gcc/config/mcore/mcore-protos.h
View File

@ -34,7 +34,7 @@ extern int mcore_naked_function_p (void);
#ifdef TREE_CODE
#ifdef HAVE_MACHINE_MODES
extern int mcore_num_arg_regs (enum machine_mode, const_tree);
extern int mcore_num_arg_regs (machine_mode, const_tree);
#endif /* HAVE_MACHINE_MODES */
#ifdef RTX_CODE
@ -55,14 +55,14 @@ extern const char * mcore_output_andn (rtx, rtx *);
extern bool mcore_gen_compare (RTX_CODE, rtx, rtx);
extern int mcore_symbolic_address_p (rtx);
extern bool mcore_r15_operand_p (rtx);
extern enum reg_class mcore_secondary_reload_class (enum reg_class, enum machine_mode, rtx);
extern enum reg_class mcore_secondary_reload_class (enum reg_class, machine_mode, rtx);
extern enum reg_class mcore_reload_class (rtx, enum reg_class);
extern int mcore_is_same_reg (rtx, rtx);
extern int mcore_arith_S_operand (rtx);
#ifdef HAVE_MACHINE_MODES
extern const char * mcore_output_move (rtx, rtx *, enum machine_mode);
extern const char * mcore_output_movedouble (rtx *, enum machine_mode);
extern const char * mcore_output_move (rtx, rtx *, machine_mode);
extern const char * mcore_output_movedouble (rtx *, machine_mode);
extern int const_ok_for_mcore (HOST_WIDE_INT);
#endif /* HAVE_MACHINE_MODES */
#endif /* RTX_CODE */

46
gcc/config/mcore/mcore.c
View File

@ -112,15 +112,15 @@ cond_type;
static void output_stack_adjust (int, int);
static int calc_live_regs (int *);
static int try_constant_tricks (HOST_WIDE_INT, HOST_WIDE_INT *, HOST_WIDE_INT *);
static const char * output_inline_const (enum machine_mode, rtx *);
static const char * output_inline_const (machine_mode, rtx *);
static void layout_mcore_frame (struct mcore_frame *);
static void mcore_setup_incoming_varargs (cumulative_args_t, enum machine_mode, tree, int *, int);
static void mcore_setup_incoming_varargs (cumulative_args_t, machine_mode, tree, int *, int);
static cond_type is_cond_candidate (rtx);
static rtx_insn *emit_new_cond_insn (rtx, int);
static rtx_insn *conditionalize_block (rtx_insn *);
static void conditionalize_optimization (void);
static void mcore_reorg (void);
static rtx handle_structs_in_regs (enum machine_mode, const_tree, int);
static rtx handle_structs_in_regs (machine_mode, const_tree, int);
static void mcore_mark_dllexport (tree);
static void mcore_mark_dllimport (tree);
static int mcore_dllexport_p (tree);
@ -144,21 +144,21 @@ static bool mcore_rtx_costs (rtx, int, int, int,
static void mcore_external_libcall (rtx);
static bool mcore_return_in_memory (const_tree, const_tree);
static int mcore_arg_partial_bytes (cumulative_args_t,
enum machine_mode,
machine_mode,
tree, bool);
static rtx mcore_function_arg (cumulative_args_t,
enum machine_mode,
machine_mode,
const_tree, bool);
static void mcore_function_arg_advance (cumulative_args_t,
enum machine_mode,
machine_mode,
const_tree, bool);
static unsigned int mcore_function_arg_boundary (enum machine_mode,
static unsigned int mcore_function_arg_boundary (machine_mode,
const_tree);
static void mcore_asm_trampoline_template (FILE *);
static void mcore_trampoline_init (rtx, tree, rtx);
static bool mcore_warn_func_return (tree);
static void mcore_option_override (void);
static bool mcore_legitimate_constant_p (enum machine_mode, rtx);
static bool mcore_legitimate_constant_p (machine_mode, rtx);
/* MCore specific attributes. */
@ -1170,7 +1170,7 @@ mcore_output_andn (rtx insn ATTRIBUTE_UNUSED, rtx operands[])
/* Output an inline constant. */
static const char *
output_inline_const (enum machine_mode mode, rtx operands[])
output_inline_const (machine_mode mode, rtx operands[])
{
HOST_WIDE_INT x = 0, y = 0;
int trick_no;
@ -1270,7 +1270,7 @@ output_inline_const (enum machine_mode mode, rtx operands[])
const char *
mcore_output_move (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
enum machine_mode mode ATTRIBUTE_UNUSED)
machine_mode mode ATTRIBUTE_UNUSED)
{
rtx dst = operands[0];
rtx src = operands[1];
@ -1340,7 +1340,7 @@ mcore_output_move (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
to take care when we see overlapping source and dest registers. */
const char *
mcore_output_movedouble (rtx operands[], enum machine_mode mode ATTRIBUTE_UNUSED)
mcore_output_movedouble (rtx operands[], machine_mode mode ATTRIBUTE_UNUSED)
{
rtx dst = operands[0];
rtx src = operands[1];
@ -1562,7 +1562,7 @@ mcore_expand_insv (rtx operands[])
known constants. DEST and SRC are registers. OFFSET is the known
starting point for the output pattern. */
static const enum machine_mode mode_from_align[] =
static const machine_mode mode_from_align[] =
{
VOIDmode, QImode, HImode, VOIDmode, SImode,
};
@ -1571,7 +1571,7 @@ static void
block_move_sequence (rtx dst_mem, rtx src_mem, int size, int align)
{
rtx temp[2];
enum machine_mode mode[2];
machine_mode mode[2];
int amount[2];
bool active[2];
int phase = 0;
@ -1935,7 +1935,7 @@ mcore_initial_elimination_offset (int from, int to)
static void
mcore_setup_incoming_varargs (cumulative_args_t args_so_far_v,
enum machine_mode mode, tree type,
machine_mode mode, tree type,
int * ptr_pretend_size ATTRIBUTE_UNUSED,
int second_time ATTRIBUTE_UNUSED)
{
@ -2645,7 +2645,7 @@ mcore_r15_operand_p (rtx x)
enum reg_class
mcore_secondary_reload_class (enum reg_class rclass,
enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
if (TEST_HARD_REG_BIT (reg_class_contents[rclass], 15)
&& !mcore_r15_operand_p (x))
@ -2701,7 +2701,7 @@ mcore_option_override (void)
hold a function argument of mode MODE and type TYPE. */
int
mcore_num_arg_regs (enum machine_mode mode, const_tree type)
mcore_num_arg_regs (machine_mode mode, const_tree type)
{
int size;
@ -2717,7 +2717,7 @@ mcore_num_arg_regs (enum machine_mode mode, const_tree type)
}
static rtx
handle_structs_in_regs (enum machine_mode mode, const_tree type, int reg)
handle_structs_in_regs (machine_mode mode, const_tree type, int reg)
{
int size;
@ -2763,7 +2763,7 @@ handle_structs_in_regs (enum machine_mode mode, const_tree type, int reg)
rtx
mcore_function_value (const_tree valtype, const_tree func)
{
enum machine_mode mode;
machine_mode mode;
int unsigned_p;
mode = TYPE_MODE (valtype);
@ -2793,7 +2793,7 @@ mcore_function_value (const_tree valtype, const_tree func)
its data type forbids. */
static rtx
mcore_function_arg (cumulative_args_t cum, enum machine_mode mode,
mcore_function_arg (cumulative_args_t cum, machine_mode mode,
const_tree type, bool named)
{
int arg_reg;
@ -2813,7 +2813,7 @@ mcore_function_arg (cumulative_args_t cum, enum machine_mode mode,
}
static void
mcore_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
mcore_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
const_tree type, bool named ATTRIBUTE_UNUSED)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
@ -2823,7 +2823,7 @@ mcore_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
}
static unsigned int
mcore_function_arg_boundary (enum machine_mode mode,
mcore_function_arg_boundary (machine_mode mode,
const_tree type ATTRIBUTE_UNUSED)
{
/* Doubles must be aligned to an 8 byte boundary. */
@ -2840,7 +2840,7 @@ mcore_function_arg_boundary (enum machine_mode mode,
the function. */
static int
mcore_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
mcore_arg_partial_bytes (cumulative_args_t cum, machine_mode mode,
tree type, bool named)
{
int reg = ROUND_REG (*get_cumulative_args (cum), mode);
@ -3193,7 +3193,7 @@ mcore_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
On the MCore, allow anything but a double. */
static bool
mcore_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
mcore_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return GET_CODE (x) != CONST_DOUBLE;
}

2
gcc/config/mcore/mcore.md
View File

@ -2769,7 +2769,7 @@
"*
{
int ofs;
enum machine_mode mode;
machine_mode mode;
rtx base_reg = XEXP (operands[4], 0);
if ((ofs = mcore_byte_offset (INTVAL (operands[3]))) > -1)

Some files were not shown because too many files have changed in this diff Show More