+2001-11-08 Geoffrey Keating <geoffk@redhat.com>
+
+ * config.sub: Import from master sources, rev. 1.230.
+ * MAINTAINERS: Change 'stormy16' to 'xstormy16'.
+
2001-11-07 Laurent Guerby <guerby@acm.org>
* MAINTAINERS (Write After Approval): Add self.
sparc port Richard Henderson rth@redhat.com
sparc port David S. Miller davem@redhat.com
sparc port Jakub Jelinek jakub@redhat.com
-stormy16 port Geoffrey Keating geoffk@redhat.com
+xstormy16 port Geoffrey Keating geoffk@redhat.com
x86 ports Stan Cox scox@redhat.com
c4x port Michael Hayes m.hayes@elec.canterbury.ac.nz
arc port Richard Kenner kenner@nyu.edu
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
# Free Software Foundation, Inc.
-timestamp='2001-10-05'
+timestamp='2001-11-08'
# This file is (in principle) common to ALL GNU software.
# The presence of a machine in this file suggests that SOME GNU software
| pdp10 | pdp11 | pj | pjl \
| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
| pyramid \
- | s390 | s390x \
| sh | sh[34] | sh[34]eb | shbe | shle \
| sparc | sparc64 | sparclet | sparclite | sparcv9 | sparcv9b \
- | stormy16 | strongarm \
+ | strongarm \
| tahoe | thumb | tic80 | tron \
| v850 \
| we32k \
- | x86 | xscale \
+ | x86 | xscale | xstormy16 \
| z8k)
basic_machine=$basic_machine-unknown
;;
| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
| pyramid-* \
| romp-* | rs6000-* \
- | s390-* | s390x-* \
| sh-* | sh[34]-* | sh[34]eb-* | shbe-* | shle-* \
| sparc-* | sparc64-* | sparc86x-* | sparclite-* \
- | sparcv9-* | sparcv9b-* | stormy16-* | strongarm-* | sv1-* \
+ | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* \
| t3e-* | tahoe-* | thumb-* | tic30-* | tic54x-* | tic80-* | tron-* \
| v850-* | vax-* \
| we32k-* \
- | x86-* | x86_64-* | xmp-* | xps100-* | xscale-* \
+ | x86-* | x86_64-* | xmp-* | xps100-* | xscale-* | xstormy16-* \
| ymp-* \
| z8k-*)
;;
rtpc | rtpc-*)
basic_machine=romp-ibm
;;
+ s390 | s390-*)
+ basic_machine=s390-ibm
+ ;;
+ s390x | s390x-*)
+ basic_machine=s390x-ibm
+ ;;
sa29200)
basic_machine=a29k-amd
os=-udi
| -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
- | -os2* | -vos*)
+ | -os2* | -vos* | -palmos* | -uclinux*)
# Remember, each alternative MUST END IN *, to match a version number.
;;
-qnx*)
+2001-11-08 Geoffrey Keating <geoffk@redhat.com>
+
+ * config.gcc: Rename stormy16 to xstormy16.
+ * config/stormy16/stormy-abi: Likewise.
+ * config/stormy16/stormy16-protos.h: Likewise.
+ * config/stormy16/stormy16.c: Likewise.
+ * config/stormy16/stormy16.h: Likewise.
+ * config/stormy16/stormy16.md: Likewise.
+
+2001-11-06 Geoffrey Keating <geoffk@redhat.com>
+
+ * tree.h (TYPE_VOLATILE): Add enable-checking code.
+ (TYPE_READONLY): Likewise.
+
Thu Nov 8 18:00:55 2001 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* reload1.c (reload): Don't delete equiv insn if can throw.
-Stormy16 ABI
+xStormy16 ABI
************
!!!!! NOTE !!!!!
ELF file header
---------------
-Stormy16 ELF files are distinguished by the value EM_STORMY16 in
+xStormy16 ELF files are distinguished by the value EM_XSTORMY16 in
the e_machine field of the ELF file header:
-#define EM_STORMY16 0xad45
+#define EM_XSTORMY16 0xad45
DWARF Register Number Mapping
-----------------------------
Name Value Field Calculation Overflow
----------------------------------------------------------------
-R_STORMY16_NONE 0 none none none
-R_STORMY16_32 1 32 S + A none
-R_STORMY16_16 2 16 S + A unsigned
-R_STORMY16_8 3 8 S + A unsigned
-R_STORMY16_PC32 4 32 S + A - P none
-R_STORMY16_PC16 5 16 S + A - P signed
-R_STORMY16_PC8 6 8 S + A - P signed
-R_STORMY16_REL_12 7 16:12:0 S + A - P signed
-R_STORMY16_24 8 32:23:1 (S + A) >> 1 unsigned
-R_STORMY16_GNU_VTINHERIT 9 n/a n/a n/a
-R_STORMY16_GNU_VTENTRY 10 n/a n/a n/a
+R_XSTORMY16_NONE 0 none none none
+R_XSTORMY16_32 1 32 S + A none
+R_XSTORMY16_16 2 16 S + A unsigned
+R_XSTORMY16_8 3 8 S + A unsigned
+R_XSTORMY16_PC32 4 32 S + A - P none
+R_XSTORMY16_PC16 5 16 S + A - P signed
+R_XSTORMY16_PC8 6 8 S + A - P signed
+R_XSTORMY16_REL_12 7 16:12:0 S + A - P signed
+R_XSTORMY16_24 8 32:23:1 (S + A) >> 1 unsigned
+R_XSTORMY16_GNU_VTINHERIT 9 n/a n/a n/a
+R_XSTORMY16_GNU_VTENTRY 10 n/a n/a n/a
In the 'Calculation' column, 'S' is the value of the symbol to which
the reloc refers, 'A' is the addend, and 'P' represents the place of
-/* Prototypes for exported functions defined in stormy16.c
+/* Prototypes for exported functions defined in xstormy16.c
Copyright (C) 2000, 2001 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
-extern struct stormy16_stack_layout
- stormy16_compute_stack_layout PARAMS((void));
-extern void stormy16_expand_prologue PARAMS ((void));
-extern void stormy16_expand_epilogue PARAMS ((void));
-extern int stormy16_initial_elimination_offset PARAMS ((int, int));
+extern struct xstormy16_stack_layout
+ xstormy16_compute_stack_layout PARAMS((void));
+extern void xstormy16_expand_prologue PARAMS ((void));
+extern void xstormy16_expand_epilogue PARAMS ((void));
+extern int xstormy16_initial_elimination_offset PARAMS ((int, int));
extern int direct_return PARAMS ((void));
-extern int stormy16_interrupt_function_p PARAMS ((void));
-extern int stormy16_epilogue_uses PARAMS ((int));
+extern int xstormy16_interrupt_function_p PARAMS ((void));
+extern int xstormy16_epilogue_uses PARAMS ((int));
#if defined (TREE_CODE)
# if defined (HAVE_MACHINE_MODES)
-extern CUMULATIVE_ARGS stormy16_function_arg_advance
+extern CUMULATIVE_ARGS xstormy16_function_arg_advance
PARAMS ((CUMULATIVE_ARGS, enum machine_mode, tree, int));
# endif
-extern void stormy16_setup_incoming_varargs
+extern void xstormy16_setup_incoming_varargs
PARAMS ((CUMULATIVE_ARGS, int, tree, int *));
-extern tree stormy16_build_va_list PARAMS ((void));
-extern void stormy16_encode_section_info PARAMS ((tree));
+extern tree xstormy16_build_va_list PARAMS ((void));
+extern void xstormy16_encode_section_info PARAMS ((tree));
#endif
#if defined (TREE_CODE) && defined (RTX_CODE)
-extern void stormy16_expand_builtin_va_start PARAMS ((int, tree, rtx));
-extern rtx stormy16_expand_builtin_va_arg PARAMS ((tree, tree));
-extern void stormy16_initialize_trampoline PARAMS ((rtx, rtx, rtx));
-extern rtx stormy16_function_value PARAMS ((tree, tree));
-extern void stormy16_asm_output_mi_thunk PARAMS ((FILE *, tree, int, tree));
+extern void xstormy16_expand_builtin_va_start PARAMS ((int, tree, rtx));
+extern rtx xstormy16_expand_builtin_va_arg PARAMS ((tree, tree));
+extern void xstormy16_initialize_trampoline PARAMS ((rtx, rtx, rtx));
+extern rtx xstormy16_function_value PARAMS ((tree, tree));
+extern void xstormy16_asm_output_mi_thunk PARAMS ((FILE *, tree, int, tree));
#endif
#ifdef RTX_CODE
-extern void stormy16_emit_cbranch PARAMS ((enum rtx_code, rtx));
-extern char * stormy16_output_cbranch_hi PARAMS ((rtx, const char *, int,
+extern void xstormy16_emit_cbranch PARAMS ((enum rtx_code, rtx));
+extern char * xstormy16_output_cbranch_hi PARAMS ((rtx, const char *, int,
rtx));
-extern char * stormy16_output_cbranch_si PARAMS ((rtx, const char *, int,
+extern char * xstormy16_output_cbranch_si PARAMS ((rtx, const char *, int,
rtx));
-extern int stormy16_mode_dependent_address_p PARAMS ((rtx));
-extern int stormy16_extra_constraint_p PARAMS ((rtx, int));
+extern int xstormy16_mode_dependent_address_p PARAMS ((rtx));
+extern int xstormy16_extra_constraint_p PARAMS ((rtx, int));
-extern void stormy16_print_operand PARAMS ((FILE *, rtx, int));
-extern void stormy16_print_operand_address PARAMS ((FILE *, rtx));
+extern void xstormy16_print_operand PARAMS ((FILE *, rtx, int));
+extern void xstormy16_print_operand_address PARAMS ((FILE *, rtx));
-extern void stormy16_expand_casesi PARAMS ((rtx, rtx, rtx, rtx, rtx));
-extern void stormy16_output_addr_vec PARAMS ((FILE *, rtx, rtx));
-extern void stormy16_expand_call PARAMS ((rtx, rtx, rtx));
+extern void xstormy16_expand_casesi PARAMS ((rtx, rtx, rtx, rtx, rtx));
+extern void xstormy16_output_addr_vec PARAMS ((FILE *, rtx, rtx));
+extern void xstormy16_expand_call PARAMS ((rtx, rtx, rtx));
#endif
#if defined (HAVE_MACHINE_MODES) && defined (RTX_CODE)
-extern int stormy16_ineqsi_operator PARAMS ((rtx, enum machine_mode));
+extern int xstormy16_ineqsi_operator PARAMS ((rtx, enum machine_mode));
extern int equality_operator PARAMS ((rtx, enum machine_mode));
extern int inequality_operator PARAMS ((rtx, enum machine_mode));
-extern void stormy16_split_cbranch PARAMS ((enum machine_mode,
+extern void xstormy16_split_cbranch PARAMS ((enum machine_mode,
rtx, rtx, rtx, rtx));
extern int short_memory_operand PARAMS ((rtx, enum machine_mode));
-extern enum reg_class stormy16_secondary_reload_class
+extern enum reg_class xstormy16_secondary_reload_class
PARAMS ((enum reg_class, enum machine_mode, rtx));
-extern int stormy16_carry_plus_operand PARAMS ((rtx, enum machine_mode));
-extern enum reg_class stormy16_preferred_reload_class
+extern int xstormy16_carry_plus_operand PARAMS ((rtx, enum machine_mode));
+extern enum reg_class xstormy16_preferred_reload_class
PARAMS ((rtx, enum reg_class));
-extern int stormy16_legitimate_address_p
+extern int xstormy16_legitimate_address_p
PARAMS ((enum machine_mode, rtx, int));
-extern void stormy16_split_move PARAMS ((enum machine_mode, rtx, rtx));
-extern void stormy16_expand_move PARAMS ((enum machine_mode, rtx, rtx));
-extern void stormy16_expand_arith PARAMS ((enum machine_mode, enum rtx_code,
+extern void xstormy16_split_move PARAMS ((enum machine_mode, rtx, rtx));
+extern void xstormy16_expand_move PARAMS ((enum machine_mode, rtx, rtx));
+extern void xstormy16_expand_arith PARAMS ((enum machine_mode, enum rtx_code,
rtx, rtx, rtx, rtx));
extern int shift_operator PARAMS ((rtx, enum machine_mode));
-extern const char * stormy16_output_shift PARAMS ((enum machine_mode,
+extern const char * xstormy16_output_shift PARAMS ((enum machine_mode,
enum rtx_code,
rtx, rtx, rtx));
#endif
-/* Stormy16 target functions.
+/* Xstormy16 target functions.
Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
#include "tm_p.h"
static rtx emit_addhi3_postreload PARAMS ((rtx, rtx, rtx));
-static void stormy16_asm_out_constructor PARAMS ((rtx, int));
-static void stormy16_asm_out_destructor PARAMS ((rtx, int));
+static void xstormy16_asm_out_constructor PARAMS ((rtx, int));
+static void xstormy16_asm_out_destructor PARAMS ((rtx, int));
/* Define the information needed to generate branch and scc insns. This is
stored from the compare operation. */
-struct rtx_def * stormy16_compare_op0;
-struct rtx_def * stormy16_compare_op1;
+struct rtx_def * xstormy16_compare_op0;
+struct rtx_def * xstormy16_compare_op1;
/* Return 1 if this is a LT, GE, LTU, or GEU operator. */
int
-stormy16_ineqsi_operator (op, mode)
+xstormy16_ineqsi_operator (op, mode)
register rtx op;
enum machine_mode mode;
{
/* Emit a branch of kind CODE to location LOC. */
void
-stormy16_emit_cbranch (code, loc)
+xstormy16_emit_cbranch (code, loc)
enum rtx_code code;
rtx loc;
{
- rtx op0 = stormy16_compare_op0;
- rtx op1 = stormy16_compare_op1;
+ rtx op0 = xstormy16_compare_op0;
+ rtx op1 = xstormy16_compare_op1;
rtx condition_rtx, loc_ref, branch, cy_clobber;
rtvec vec;
enum machine_mode mode;
if (gt_p)
lab = gen_label_rtx ();
- stormy16_emit_cbranch (unsigned_p ? LTU : LT, gt_p ? lab : loc);
+ xstormy16_emit_cbranch (unsigned_p ? LTU : LT, gt_p ? lab : loc);
/* This should be generated as a comparison against the temporary
created by the previous insn, but reload can't handle that. */
- stormy16_emit_cbranch (gt_p ? NE : EQ, loc);
+ xstormy16_emit_cbranch (gt_p ? NE : EQ, loc);
if (gt_p)
emit_label (lab);
return;
for (i = 0; i < num_words - 1; i++)
{
- stormy16_compare_op0 = simplify_gen_subreg (word_mode, op0, mode,
+ xstormy16_compare_op0 = simplify_gen_subreg (word_mode, op0, mode,
i * UNITS_PER_WORD);
- stormy16_compare_op1 = simplify_gen_subreg (word_mode, op1, mode,
+ xstormy16_compare_op1 = simplify_gen_subreg (word_mode, op1, mode,
i * UNITS_PER_WORD);
- stormy16_emit_cbranch (NE, code == EQ ? lab : loc);
+ xstormy16_emit_cbranch (NE, code == EQ ? lab : loc);
}
- stormy16_compare_op0 = simplify_gen_subreg (word_mode, op0, mode,
+ xstormy16_compare_op0 = simplify_gen_subreg (word_mode, op0, mode,
i * UNITS_PER_WORD);
- stormy16_compare_op1 = simplify_gen_subreg (word_mode, op1, mode,
+ xstormy16_compare_op1 = simplify_gen_subreg (word_mode, op1, mode,
i * UNITS_PER_WORD);
- stormy16_emit_cbranch (code, loc);
+ xstormy16_emit_cbranch (code, loc);
if (code == EQ)
emit_label (lab);
/* Take a SImode conditional branch, one of GT/LE/GTU/LEU, and split
the arithmetic operation. Most of the work is done by
- stormy16_expand_arith. */
+ xstormy16_expand_arith. */
void
-stormy16_split_cbranch (mode, label, comparison, dest, carry)
+xstormy16_split_cbranch (mode, label, comparison, dest, carry)
enum machine_mode mode;
rtx label;
rtx comparison;
rtx compare;
start_sequence ();
- stormy16_expand_arith (mode, COMPARE, dest, op0, op1, carry);
+ xstormy16_expand_arith (mode, COMPARE, dest, op0, op1, carry);
seq = gen_sequence ();
end_sequence ();
compare = SET_SRC (XVECEXP (PATTERN (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)),
INSN is the insn. */
char *
-stormy16_output_cbranch_hi (op, label, reversed, insn)
+xstormy16_output_cbranch_hi (op, label, reversed, insn)
rtx op;
const char * label;
int reversed;
INSN is the insn. */
char *
-stormy16_output_cbranch_si (op, label, reversed, insn)
+xstormy16_output_cbranch_si (op, label, reversed, insn)
rtx op;
const char * label;
int reversed;
This case often occurs between floating-point and general registers. */
enum reg_class
-stormy16_secondary_reload_class (class, mode, x)
+xstormy16_secondary_reload_class (class, mode, x)
enum reg_class class;
enum machine_mode mode;
rtx x;
/* When reloading a PLUS, the carry register will be required
unless the inc or dec instructions can be used. */
- if (stormy16_carry_plus_operand (x, mode))
+ if (xstormy16_carry_plus_operand (x, mode))
return CARRY_REGS;
return NO_REGS;
/* Recognise a PLUS that needs the carry register. */
int
-stormy16_carry_plus_operand (x, mode)
+xstormy16_carry_plus_operand (x, mode)
rtx x;
enum machine_mode mode ATTRIBUTE_UNUSED;
{
enum reg_class
-stormy16_preferred_reload_class (x, class)
+xstormy16_preferred_reload_class (x, class)
enum reg_class class;
rtx x;
{
&& (INTVAL (X) + (OFFSET) < 0x100 || INTVAL (X) + (OFFSET) >= 0x7F00))
int
-stormy16_legitimate_address_p (mode, x, strict)
+xstormy16_legitimate_address_p (mode, x, strict)
enum machine_mode mode ATTRIBUTE_UNUSED;
rtx x;
int strict;
address for DImode or DFmode, or if the address is a post-increment
or pre-decrement address. */
int
-stormy16_mode_dependent_address_p (x)
+xstormy16_mode_dependent_address_p (x)
rtx x;
{
if (LEGITIMATE_ADDRESS_CONST_INT_P (x, 0)
represented by the constraint letter C. If C is not defined as an extra
constraint, the value returned should be 0 regardless of VALUE. */
int
-stormy16_extra_constraint_p (x, c)
+xstormy16_extra_constraint_p (x, c)
rtx x;
int c;
{
case 'S':
return (GET_CODE (x) == MEM
&& GET_CODE (XEXP (x, 0)) == CONST_INT
- && stormy16_legitimate_address_p (VOIDmode, XEXP (x, 0), 0));
+ && xstormy16_legitimate_address_p (VOIDmode, XEXP (x, 0), 0));
/* 'T' is for Rx. */
case 'T':
*/
void
-stormy16_split_move (mode, dest, src)
+xstormy16_split_move (mode, dest, src)
enum machine_mode mode;
rtx dest;
rtx src;
mode MODE from SRC to DEST. */
void
-stormy16_expand_move (mode, dest, src)
+xstormy16_expand_move (mode, dest, src)
enum machine_mode mode;
rtx dest;
rtx src;
&& ! reload_completed
&& GET_CODE (dest) == MEM
&& (GET_CODE (XEXP (dest, 0)) != CONST_INT
- || ! stormy16_legitimate_address_p (mode, XEXP (dest, 0), 0))
+ || ! xstormy16_legitimate_address_p (mode, XEXP (dest, 0), 0))
&& GET_CODE (src) != REG
&& GET_CODE (src) != SUBREG)
src = copy_to_mode_reg (mode, src);
if (reload_completed
&& mode != HImode && mode != QImode)
{
- stormy16_split_move (mode, dest, src);
+ xstormy16_split_move (mode, dest, src);
return;
}
instruction. */
/* A structure to describe the layout. */
-struct stormy16_stack_layout
+struct xstormy16_stack_layout
{
/* Size of the topmost three items on the stack. */
int locals_size;
&& (regs_ever_live[REGNUM] || ! current_function_is_leaf)))
/* Compute the stack layout. */
-struct stormy16_stack_layout
-stormy16_compute_stack_layout ()
+struct xstormy16_stack_layout
+xstormy16_compute_stack_layout ()
{
- struct stormy16_stack_layout layout;
+ struct xstormy16_stack_layout layout;
int regno;
- const int ifun = stormy16_interrupt_function_p ();
+ const int ifun = xstormy16_interrupt_function_p ();
layout.locals_size = get_frame_size ();
/* Determine how all the special registers get eliminated. */
int
-stormy16_initial_elimination_offset (from, to)
+xstormy16_initial_elimination_offset (from, to)
int from, to;
{
- struct stormy16_stack_layout layout;
+ struct xstormy16_stack_layout layout;
int result;
- layout = stormy16_compute_stack_layout ();
+ layout = xstormy16_compute_stack_layout ();
if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
result = layout.sp_minus_fp - layout.locals_size;
Also any insns generated here should have RTX_FRAME_RELATED_P(insn) = 1
so that the debug info generation code can handle them properly. */
void
-stormy16_expand_prologue ()
+xstormy16_expand_prologue ()
{
- struct stormy16_stack_layout layout;
+ struct xstormy16_stack_layout layout;
int regno;
rtx insn;
rtx mem_push_rtx;
rtx mem_fake_push_rtx;
- const int ifun = stormy16_interrupt_function_p ();
+ const int ifun = xstormy16_interrupt_function_p ();
mem_push_rtx = gen_rtx_POST_INC (Pmode, stack_pointer_rtx);
mem_push_rtx = gen_rtx_MEM (HImode, mem_push_rtx);
mem_fake_push_rtx = gen_rtx_PRE_INC (Pmode, stack_pointer_rtx);
mem_fake_push_rtx = gen_rtx_MEM (HImode, mem_fake_push_rtx);
- layout = stormy16_compute_stack_layout ();
+ layout = xstormy16_compute_stack_layout ();
/* Save the argument registers if necessary. */
if (layout.stdarg_save_size)
direct_return ()
{
return (reload_completed
- && stormy16_compute_stack_layout ().frame_size == 0);
+ && xstormy16_compute_stack_layout ().frame_size == 0);
}
/* Called after register allocation to add any instructions needed for
such scheduling. */
void
-stormy16_expand_epilogue ()
+xstormy16_expand_epilogue ()
{
- struct stormy16_stack_layout layout;
+ struct xstormy16_stack_layout layout;
rtx mem_pop_rtx;
int regno;
- const int ifun = stormy16_interrupt_function_p ();
+ const int ifun = xstormy16_interrupt_function_p ();
mem_pop_rtx = gen_rtx_PRE_DEC (Pmode, stack_pointer_rtx);
mem_pop_rtx = gen_rtx_MEM (HImode, mem_pop_rtx);
- layout = stormy16_compute_stack_layout ();
+ layout = xstormy16_compute_stack_layout ();
/* Pop the stack for the locals. */
if (layout.locals_size)
}
int
-stormy16_epilogue_uses (regno)
+xstormy16_epilogue_uses (regno)
int regno;
{
if (reload_completed && call_used_regs[regno])
{
- const int ifun = stormy16_interrupt_function_p ();
+ const int ifun = xstormy16_interrupt_function_p ();
return REG_NEEDS_SAVE (regno, ifun);
}
return 0;
This function need not do anything if the argument in question was
passed on the stack. The compiler knows how to track the amount of
stack space used for arguments without any special help. However,
- it makes life easier for stormy16_build_va_list if it does update
+ it makes life easier for xstormy16_build_va_list if it does update
the word count. */
CUMULATIVE_ARGS
-stormy16_function_arg_advance (cum, mode, type, named)
+xstormy16_function_arg_advance (cum, mode, type, named)
CUMULATIVE_ARGS cum;
enum machine_mode mode;
tree type;
and partially on the stack, the whole of it is passed on the
stack. */
if (cum < NUM_ARGUMENT_REGISTERS
- && cum + STORMY16_WORD_SIZE (type, mode) > NUM_ARGUMENT_REGISTERS)
+ && cum + XSTORMY16_WORD_SIZE (type, mode) > NUM_ARGUMENT_REGISTERS)
cum = NUM_ARGUMENT_REGISTERS;
- cum += STORMY16_WORD_SIZE (type, mode);
+ cum += XSTORMY16_WORD_SIZE (type, mode);
return cum;
}
/* Do any needed setup for a variadic function. CUM has not been updated
for the last named argument which has type TYPE and mode MODE. */
void
-stormy16_setup_incoming_varargs (cum, int_mode, type, pretend_size)
+xstormy16_setup_incoming_varargs (cum, int_mode, type, pretend_size)
CUMULATIVE_ARGS cum ATTRIBUTE_UNUSED;
int int_mode ATTRIBUTE_UNUSED;
tree type ATTRIBUTE_UNUSED;
To keep the layout nice, the pointer is first in the structure. */
tree
-stormy16_build_va_list ()
+xstormy16_build_va_list ()
{
tree f_1, f_2, record, type_decl;
variable to initialize. NEXTARG is the machine independent notion of the
'next' argument after the variable arguments. */
void
-stormy16_expand_builtin_va_start (stdarg_p, valist, nextarg)
+xstormy16_expand_builtin_va_start (stdarg_p, valist, nextarg)
int stdarg_p ATTRIBUTE_UNUSED;
tree valist;
rtx nextarg ATTRIBUTE_UNUSED;
tree base, count;
tree t;
- if (stormy16_interrupt_function_p ())
+ if (xstormy16_interrupt_function_p ())
error ("cannot use va_start in interrupt function");
f_base = TYPE_FIELDS (va_list_type_node);
Note: This algorithm is documented in stormy-abi. */
rtx
-stormy16_expand_builtin_va_arg (valist, type)
+xstormy16_expand_builtin_va_arg (valist, type)
tree valist;
tree type;
{
the nested function; STATIC_CHAIN is an RTX for the static chain
value that should be passed to the function when it is called. */
void
-stormy16_initialize_trampoline (addr, fnaddr, static_chain)
+xstormy16_initialize_trampoline (addr, fnaddr, static_chain)
rtx addr;
rtx fnaddr;
rtx static_chain;
because these are returned in another way. See `STRUCT_VALUE_REGNUM' and
related macros. */
rtx
-stormy16_function_value (valtype, func)
+xstormy16_function_value (valtype, func)
tree valtype;
tree func ATTRIBUTE_UNUSED;
{
probably not. */
void
-stormy16_asm_output_mi_thunk (file, thunk_fndecl, delta, function)
+xstormy16_asm_output_mi_thunk (file, thunk_fndecl, delta, function)
FILE *file;
tree thunk_fndecl ATTRIBUTE_UNUSED;
int delta;
/* Mark functions with SYMBOL_REF_FLAG. */
void
-stormy16_encode_section_info (decl)
+xstormy16_encode_section_info (decl)
tree decl;
{
if (TREE_CODE (decl) == FUNCTION_DECL)
/* Output constructors and destructors. Just like
default_named_section_asm_out_* but don't set the sections writable. */
#undef TARGET_ASM_CONSTRUCTOR
-#define TARGET_ASM_CONSTRUCTOR stormy16_asm_out_constructor
+#define TARGET_ASM_CONSTRUCTOR xstormy16_asm_out_constructor
#undef TARGET_ASM_DESTRUCTOR
-#define TARGET_ASM_DESTRUCTOR stormy16_asm_out_destructor
+#define TARGET_ASM_DESTRUCTOR xstormy16_asm_out_destructor
static void
-stormy16_asm_out_destructor (symbol, priority)
+xstormy16_asm_out_destructor (symbol, priority)
rtx symbol;
int priority;
{
}
static void
-stormy16_asm_out_constructor (symbol, priority)
+xstormy16_asm_out_constructor (symbol, priority)
rtx symbol;
int priority;
{
\f
/* Print a memory address as an operand to reference that memory location. */
void
-stormy16_print_operand_address (file, address)
+xstormy16_print_operand_address (file, address)
FILE * file;
rtx address;
{
/* Print an operand to a assembler instruction. */
void
-stormy16_print_operand (file, x, code)
+xstormy16_print_operand (file, x, code)
FILE * file;
rtx x;
int code;
if (GET_CODE (x) == SYMBOL_REF)
assemble_name (file, XSTR (x, 0));
else
- stormy16_print_operand_address (file, x);
+ xstormy16_print_operand_address (file, x);
return;
case 'o':
break;
default:
- output_operand_lossage ("stormy16_print_operand: unknown code");
+ output_operand_lossage ("xstormy16_print_operand: unknown code");
return;
}
break;
case MEM:
- stormy16_print_operand_address (file, XEXP (x, 0));
+ xstormy16_print_operand_address (file, XEXP (x, 0));
break;
default:
*/
void
-stormy16_expand_casesi (index, lower_bound, range, table, default_label)
+xstormy16_expand_casesi (index, lower_bound, range, table, default_label)
rtx index;
rtx lower_bound;
rtx range;
all reach. */
void
-stormy16_output_addr_vec (file, label, table)
+xstormy16_output_addr_vec (file, label, table)
FILE *file;
rtx label ATTRIBUTE_UNUSED;
rtx table;
for (idx = 0; idx < vlen; idx++)
{
fputs ("\tjmpf ", file);
- stormy16_print_operand_address (file,
+ xstormy16_print_operand_address (file,
XEXP (XVECEXP (table, 0, idx), 0));
fputc ('\n', file);
}
*/
void
-stormy16_expand_call (retval, dest, counter)
+xstormy16_expand_call (retval, dest, counter)
rtx retval;
rtx dest;
rtx counter;
using CARRY as a temporary. When CODE is COMPARE, a branch
template is generated (this saves duplicating code in
- stormy16_split_cbranch). */
+ xstormy16_split_cbranch). */
void
-stormy16_expand_arith (mode, code, dest, src0, src1, carry)
+xstormy16_expand_arith (mode, code, dest, src0, src1, carry)
enum machine_mode mode;
enum rtx_code code;
rtx dest;
SIZE_R will be a CONST_INT, X will be a hard register. */
const char *
-stormy16_output_shift (mode, code, x, size_r, temp)
+xstormy16_output_shift (mode, code, x, size_r, temp)
enum machine_mode mode;
enum rtx_code code;
rtx x;
/* Return nonzero if the function is an interrupt function. */
int
-stormy16_interrupt_function_p ()
+xstormy16_interrupt_function_p ()
{
tree attributes;
}
#undef TARGET_ATTRIBUTE_TABLE
-#define TARGET_ATTRIBUTE_TABLE stormy16_attribute_table
-static tree stormy16_handle_interrupt_attribute PARAMS ((tree *, tree, tree, int, bool *));
-static const struct attribute_spec stormy16_attribute_table[] =
+#define TARGET_ATTRIBUTE_TABLE xstormy16_attribute_table
+static tree xstormy16_handle_interrupt_attribute PARAMS ((tree *, tree, tree, int, bool *));
+static const struct attribute_spec xstormy16_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
- { "interrupt", 0, 0, false, true, true, stormy16_handle_interrupt_attribute },
+ { "interrupt", 0, 0, false, true, true, xstormy16_handle_interrupt_attribute },
{ NULL, 0, 0, false, false, false, NULL }
};
/* Handle an "interrupt" attribute;
arguments as in struct attribute_spec.handler. */
static tree
-stormy16_handle_interrupt_attribute (node, name, args, flags, no_add_attrs)
+xstormy16_handle_interrupt_attribute (node, name, args, flags, no_add_attrs)
tree *node;
tree name;
tree args ATTRIBUTE_UNUSED;
-/* Stormy16 cpu description.
+/* Xstormy16 cpu description.
Copyright (C) 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
Contributed by Red Hat, Inc.
between the two is that `LIB_SPEC' is used at the end of the command given
to the linker.
- For stormy16:
+ For xstormy16:
- If -msim is specified, everything is built and linked as for the sim.
- If -T is specified, that linker script is used, and it should provide
appropriate libraries.
The result is to define the macros `__mc68000__', `__sun__' and `__unix__'
unconditionally, and the macros `mc68000', `sun' and `unix' provided `-ansi'
is not specified. */
-#define CPP_PREDEFINES "-Dstormy16 -Amachine=stormy16 -D__INT_MAX__=32767"
+#define CPP_PREDEFINES "-Dxstormy16 -Amachine=xstormy16 -D__INT_MAX__=32767"
/* This declaration should be present. */
extern int target_flags;
#define TARGET_VERSION \
fprintf (stderr, " (68k, MIT syntax)");
#endif */
-#define TARGET_VERSION fprintf (stderr, " (stormy16 cpu core)");
+#define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)");
/* Sometimes certain combinations of command options do not make sense on a
particular target machine. You can define a macro `OVERRIDE_OPTIONS' to
This declaration must be present. */
#define PREFERRED_RELOAD_CLASS(X, CLASS) \
- stormy16_preferred_reload_class (X, CLASS)
+ xstormy16_preferred_reload_class (X, CLASS)
/* Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of input
reloads. If you don't define this macro, the default is to use CLASS,
unchanged. */
#define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \
- stormy16_preferred_reload_class (X, CLASS)
+ xstormy16_preferred_reload_class (X, CLASS)
/* A C expression that places additional restrictions on the register class to
use when it is necessary to be able to hold a value of mode MODE in a reload
/* This chip has the interesting property that only the first eight
registers can be moved to/from memory. */
#define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \
- stormy16_secondary_reload_class (CLASS, MODE, X)
+ xstormy16_secondary_reload_class (CLASS, MODE, X)
/* #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) */
/* #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) */
input and `r' on the output. The next alternative specifies `m' on the
input and a register class that does not include r0 on the output. */
#define EXTRA_CONSTRAINT(VALUE, C) \
- stormy16_extra_constraint_p (VALUE, C)
+ xstormy16_extra_constraint_p (VALUE, C)
\f
/* Basic Stack Layout */
You only need to define this macro if you want to support call frame
debugging information like that provided by DWARF 2. */
-#define INCOMING_FRAME_SP_OFFSET (stormy16_interrupt_function_p () ? 6 : 4)
+#define INCOMING_FRAME_SP_OFFSET (xstormy16_interrupt_function_p () ? 6 : 4)
\f
/* Stack Checking. */
initial difference between the specified pair of registers. This macro must
be defined if `ELIMINABLE_REGS' is defined. */
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
- (OFFSET) = stormy16_initial_elimination_offset (FROM, TO)
+ (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO)
/* Define this macro if the `longjmp' function restores registers from the
stack frames, rather than from those saved specifically by `setjmp'.
#define NUM_ARGUMENT_REGISTERS 6
#define FIRST_ARGUMENT_REGISTER 2
-#define STORMY16_WORD_SIZE(TYPE, MODE) \
+#define XSTORMY16_WORD_SIZE(TYPE, MODE) \
((((TYPE) ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \
+ 1) \
/ 2)
stack and then loaded into a register. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((MODE) == VOIDmode ? const0_rtx \
- : (CUM) + STORMY16_WORD_SIZE (TYPE, MODE) > NUM_ARGUMENT_REGISTERS ? 0 \
+ : (CUM) + XSTORMY16_WORD_SIZE (TYPE, MODE) > NUM_ARGUMENT_REGISTERS ? 0 \
: gen_rtx_REG (MODE, (CUM) + 2))
/* Define this macro if the target machine has "register windows", so that the
the stack. The compiler knows how to track the amount of stack space used
for arguments without any special help. */
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
- ((CUM) = stormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
+ ((CUM) = xstormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
/* If defined, a C expression which determines whether, and in which direction,
to pad out an argument with extra space. The value should be of type `enum
because these are returned in another way. See `STRUCT_VALUE_REGNUM' and
related macros, below. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- stormy16_function_value (VALTYPE, FUNC)
+ xstormy16_function_value (VALTYPE, FUNC)
/* Define this macro if the target machine has "register windows" so that the
frame pointer registers are already be assumed to be used as
needed. */
#define EPILOGUE_USES(REGNO) \
- stormy16_epilogue_uses (REGNO)
+ xstormy16_epilogue_uses (REGNO)
/* Define this macro if the function epilogue contains delay slots to which
instructions from the rest of the function can be "moved". The definition
FUNCTION instead of jumping to it. The generic approach does not support
varargs. */
#define ASM_OUTPUT_MI_THUNK(FILE, THUNK_FNDECL, DELTA, FUNCTION) \
- stormy16_asm_output_mi_thunk (FILE, THUNK_FNDECL, DELTA, FUNCTION)
+ xstormy16_asm_output_mi_thunk (FILE, THUNK_FNDECL, DELTA, FUNCTION)
\f
/* Generating Code for Profiling. */
a message describing why the function could not be inlined. The message will
displayed if the '-Winline' command line switch has been given. If the message
contains a '%s' sequence, this will be replaced by the name of the function. */
-/* #define TARGET_CANNOT_INLINE_P(FN_DECL) stormy16_cannot_inline_p (FN_DECL) */
+/* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */
\f
/* Implementing the Varargs Macros. */
this case. */
#define SETUP_INCOMING_VARARGS(ARGS_SO_FAR, MODE, TYPE, PRETEND_ARGS_SIZE, SECOND_TIME) \
if (! SECOND_TIME) \
- stormy16_setup_incoming_varargs (ARGS_SO_FAR, MODE, TYPE, & PRETEND_ARGS_SIZE)
+ xstormy16_setup_incoming_varargs (ARGS_SO_FAR, MODE, TYPE, & PRETEND_ARGS_SIZE)
/* Define this macro if the location where a function argument is passed
depends on whether or not it is a named argument.
/* Build up the stdarg/varargs va_list type tree, assinging it to NODE. If not
defined, it is assumed that va_list is a void * pointer. */
#define BUILD_VA_LIST_TYPE(NODE) \
- ((NODE) = stormy16_build_va_list ())
+ ((NODE) = xstormy16_build_va_list ())
/* Implement the stdarg/varargs va_start macro. STDARG_P is non-zero if this
is stdarg.h instead of varargs.h. VALIST is the tree of the va_list
'next' argument after the variable arguments. If not defined, a standard
implementation will be defined that works for arguments passed on the stack. */
#define EXPAND_BUILTIN_VA_START(STDARG_P, VALIST, NEXTARG) \
- stormy16_expand_builtin_va_start (STDARG_P, VALIST, NEXTARG)
+ xstormy16_expand_builtin_va_start (STDARG_P, VALIST, NEXTARG)
/* Implement the stdarg/varargs va_arg macro. VALIST is the variable of type
va_list as a tree, TYPE is the type passed to va_arg. */
#define EXPAND_BUILTIN_VA_ARG(VALIST, TYPE) \
- stormy16_expand_builtin_va_arg (VALIST, TYPE)
+ xstormy16_expand_builtin_va_arg (VALIST, TYPE)
/* Implement the stdarg/varargs va_end macro. VALIST is the variable of type
va_list as a tree. */
the nested function; STATIC_CHAIN is an RTX for the static chain value that
should be passed to the function when it is called. */
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
- stormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
+ xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
/* A C expression to allocate run-time space for a trampoline. The expression
value should be an RTX representing a memory reference to the space for the
#ifdef REG_OK_STRICT
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \
do { \
- if (stormy16_legitimate_address_p (MODE, X, 1)) \
+ if (xstormy16_legitimate_address_p (MODE, X, 1)) \
goto LABEL; \
} while (0)
#else
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \
do { \
- if (stormy16_legitimate_address_p (MODE, X, 0)) \
+ if (xstormy16_legitimate_address_p (MODE, X, 0)) \
goto LABEL; \
} while (0)
#endif
or pre-decrement address.
*/
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
- if (stormy16_mode_dependent_address_p (ADDR)) \
+ if (xstormy16_mode_dependent_address_p (ADDR)) \
goto LABEL
/* A C expression that is nonzero if X is a legitimate constant for an
The usual thing for this macro to do is to record a flag in the `symbol_ref'
(such as `SYMBOL_REF_FLAG') or to store a modified name string in the
`symbol_ref' (if one bit is not enough information). */
-#define ENCODE_SECTION_INFO(DECL) stormy16_encode_section_info(DECL)
+#define ENCODE_SECTION_INFO(DECL) xstormy16_encode_section_info(DECL)
/* Decode SYM_NAME and store the real name part in VAR, sans the characters
that encode section info. Define this macro if `ENCODE_SECTION_INFO' alters
When the machine description has a specification `%PUNCT' (a `%' followed by
a punctuation character), this macro is called with a null pointer for X and
the punctuation character for CODE. */
-#define PRINT_OPERAND(STREAM, X, CODE) stormy16_print_operand (STREAM, X, CODE)
+#define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE)
/* A C expression which evaluates to true if CODE is a valid punctuation
character for use in the `PRINT_OPERAND' macro. If
then check for it here.
This declaration must be present. */
-#define PRINT_OPERAND_ADDRESS(STREAM, X) stormy16_print_operand_address (STREAM, X)
+#define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X)
/* A C statement, to be executed after all slot-filler instructions have been
output. If necessary, call `dbr_sequence_length' to determine the number of
which would be bad. Instead, it controls the output of the table
itself. */
#define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \
- stormy16_output_addr_vec (file, LABEL, BODY)
+ xstormy16_output_addr_vec (file, LABEL, BODY)
/* Alignment for ADDR_VECs is the same as for code. */
#define ADDR_VEC_ALIGN(ADDR_VEC) 1
{"shift_operator", {ASHIFT, ASHIFTRT, LSHIFTRT }}, \
{"equality_operator", {EQ, NE }}, \
{"inequality_operator", {GE, GT, LE, LT, GEU, GTU, LEU, LTU }}, \
- {"stormy16_ineqsi_operator", {LT, GE, LTU, GEU }},
+ {"xstormy16_ineqsi_operator", {LT, GE, LTU, GEU }},
/* An alias for a machine mode name. This is the machine mode that elements of
a jump-table should have. */
stored from the compare operation. Note that we can't use "rtx" here
since it hasn't been defined! */
-extern struct rtx_def *stormy16_compare_op0, *stormy16_compare_op1;
+extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1;
-/* End of stormy16.h */
+/* End of xstormy16.h */
-;; STORMY16 Machine description template
+;; XSTORMY16 Machine description template
;; Copyright (C) 1997, 1998, 1999, 2001 Free Software Foundation, Inc.
;; Contributed by Red Hat, Inc.
[(set (match_operand:QI 0 "nonimmediate_operand" "")
(match_operand:QI 1 "general_operand" ""))]
""
- "{ stormy16_expand_move (QImode, operands[0], operands[1]); DONE; }")
+ "{ xstormy16_expand_move (QImode, operands[0], operands[1]); DONE; }")
(define_insn "*movqi_internal"
[(set (match_operand:QI 0 "nonimmediate_operand" "=r,Q,r,m,e,e,T,r,S")
[(set (match_operand:HI 0 "nonimmediate_operand" "")
(match_operand:HI 1 "general_operand" ""))]
""
- "{ stormy16_expand_move (HImode, operands[0], operands[1]); DONE; }")
+ "{ xstormy16_expand_move (HImode, operands[0], operands[1]); DONE; }")
(define_insn "*movhi_internal"
[(set (match_operand:HI 0 "nonimmediate_operand" "=r,Q,r,m,e,e,T,r,S")
[(set (match_operand:SI 0 "nonimmediate_operand" "")
(match_operand:SI 1 "general_operand" ""))]
""
- "{ stormy16_expand_move (SImode, operands[0], operands[1]); DONE; }")
+ "{ xstormy16_expand_move (SImode, operands[0], operands[1]); DONE; }")
(define_insn_and_split "*movsi_internal"
[(set (match_operand:SI 0 "nonimmediate_operand" "=r,Q,r,m,e,&e,e,r,S")
"#"
"reload_completed"
[(pc)]
- "{ stormy16_split_move (SImode, operands[0], operands[1]); DONE; }"
+ "{ xstormy16_split_move (SImode, operands[0], operands[1]); DONE; }"
[(set_attr_alternative "length"
[(const_int 4)
(const_int 4)
; shows it how to place the register in RTL to make the addition work.
(define_expand "reload_inhi"
[(parallel [(set (match_operand:HI 0 "register_operand" "=r")
- (match_operand:HI 1 "stormy16_carry_plus_operand" ""))
+ (match_operand:HI 1 "xstormy16_carry_plus_operand" ""))
(clobber (match_operand:BI 2 "" "=&y"))])]
""
"if (! rtx_equal_p (operands[0], XEXP (operands[1], 0)))
"#"
"reload_completed"
[(pc)]
- "{ stormy16_expand_arith (SImode, PLUS, operands[0], operands[1],
+ "{ xstormy16_expand_arith (SImode, PLUS, operands[0], operands[1],
operands[2], operands[3]); DONE; } "
[(set_attr "length" "4")])
"#"
"reload_completed"
[(pc)]
- "{ stormy16_expand_arith (SImode, MINUS, operands[0], operands[1],
+ "{ xstormy16_expand_arith (SImode, MINUS, operands[0], operands[1],
operands[2], operands[3]); DONE; } "
[(set_attr "length" "4")])
[(set (match_operand:SI 0 "register_operand" "")
(neg:SI (match_operand:SI 1 "register_operand" "")))]
""
- "{ stormy16_expand_arith (SImode, NEG, operands[0], const0_rtx,
+ "{ xstormy16_expand_arith (SImode, NEG, operands[0], const0_rtx,
operands[1], gen_reg_rtx (BImode)); DONE; }")
;; ::::::::::::::::::::
(clobber (match_operand:BI 3 "register_operand" "=y,y"))
(clobber (match_operand:HI 4 "" "=X,r"))]
""
- "* return stormy16_output_shift (SImode, GET_CODE (operands[5]),
+ "* return xstormy16_output_shift (SImode, GET_CODE (operands[5]),
operands[0], operands[2], operands[4]);"
[(set_attr "length" "6,10")
(set_attr "psw_operand" "clobber,clobber")])
""
"
{
- stormy16_compare_op0 = operands[0];
- stormy16_compare_op1 = operands[1];
+ xstormy16_compare_op0 = operands[0];
+ xstormy16_compare_op1 = operands[1];
DONE;
}")
""
"
{
- stormy16_compare_op0 = operands[0];
- stormy16_compare_op1 = operands[1];
+ xstormy16_compare_op0 = operands[0];
+ xstormy16_compare_op1 = operands[1];
DONE;
}")
(define_expand "beq"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (EQ, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (EQ, operands[0]); DONE; }")
(define_expand "bne"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (NE, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (NE, operands[0]); DONE; }")
(define_expand "bge"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (GE, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (GE, operands[0]); DONE; }")
(define_expand "bgt"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (GT, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (GT, operands[0]); DONE; }")
(define_expand "ble"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (LE, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (LE, operands[0]); DONE; }")
(define_expand "blt"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (LT, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (LT, operands[0]); DONE; }")
(define_expand "bgeu"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (GEU, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (GEU, operands[0]); DONE; }")
(define_expand "bgtu"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (GTU, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (GTU, operands[0]); DONE; }")
(define_expand "bleu"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (LEU, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (LEU, operands[0]); DONE; }")
(define_expand "bltu"
[(use (match_operand 0 "" ""))]
""
- "{ stormy16_emit_cbranch (LTU, operands[0]); DONE; }")
+ "{ xstormy16_emit_cbranch (LTU, operands[0]); DONE; }")
(define_insn "*cbranchhi"
""
"*
{
- return stormy16_output_cbranch_hi (operands[1], \"%l0\", 0, insn);
+ return xstormy16_output_cbranch_hi (operands[1], \"%l0\", 0, insn);
}"
[(set_attr "branch_class" "bcc12")
(set_attr "psw_operand" "0,0,1")])
""
"*
{
- return stormy16_output_cbranch_hi (operands[1], \"%l0\", 1, insn);
+ return xstormy16_output_cbranch_hi (operands[1], \"%l0\", 1, insn);
}"
[(set_attr "branch_class" "bcc12")
(set_attr "psw_operand" "0,0,1")])
""
"*
{
- return stormy16_output_cbranch_si (operands[1], \"%l0\", 0, insn);
+ return xstormy16_output_cbranch_si (operands[1], \"%l0\", 0, insn);
}"
[(set_attr "branch_class" "bcc8p2")
(set_attr "psw_operand" "clobber")])
(define_insn_and_split "*ineqbranchsi"
[(set (pc)
- (if_then_else (match_operator:SI 1 "stormy16_ineqsi_operator"
+ (if_then_else (match_operator:SI 1 "xstormy16_ineqsi_operator"
[(match_operand:SI 2 "register_operand"
"+r")
(match_operand:SI 3 "nonmemory_operand"
"#"
"reload_completed"
[(pc)]
- "{ stormy16_split_cbranch (SImode, operands[0], operands[1], operands[2],
+ "{ xstormy16_split_cbranch (SImode, operands[0], operands[1], operands[2],
operands[4]); DONE; }"
[(set_attr "length" "8")])
(define_insn "*ineqbranch_1"
[(set (pc)
- (if_then_else (match_operator:HI 5 "stormy16_ineqsi_operator"
+ (if_then_else (match_operator:HI 5 "xstormy16_ineqsi_operator"
[(minus:HI (match_operand:HI 1 "register_operand"
"T,r,r")
(zero_extend:HI (match_operand:BI 4
""
"*
{
- return stormy16_output_cbranch_si (operands[5], \"%l0\", 0, insn);
+ return xstormy16_output_cbranch_si (operands[5], \"%l0\", 0, insn);
}"
[(set_attr "branch_class" "bcc8p2,bcc8p2,bcc8p4")
(set_attr "psw_operand" "2,2,2")])
(match_operand 1 "" ""))
(use (match_operand 2 "immediate_operand" ""))]
""
- "stormy16_expand_call (NULL_RTX, operands[0], operands[1]); DONE;")
+ "xstormy16_expand_call (NULL_RTX, operands[0], operands[1]); DONE;")
;; Subroutine call instruction returning a value. Operand 0 is the hard
;; register in which the value is returned. There are three more operands, the
(match_operand:SI 2 "" "")))
(use (match_operand 3 "immediate_operand" ""))]
""
- "stormy16_expand_call (operands[0], operands[1], operands[2]); DONE;")
+ "xstormy16_expand_call (operands[0], operands[1], operands[2]); DONE;")
(define_insn "*call_internal"
[(call (mem:HI (match_operand:HI 0 "nonmemory_operand" "i,r"))
""
"*
{
- return stormy16_output_cbranch_hi (NULL_RTX, \"%l0\", 0, insn);
+ return xstormy16_output_cbranch_hi (NULL_RTX, \"%l0\", 0, insn);
}"
[(set_attr "branch_class" "br12")
(set_attr "psw_operand" "nop")])
""
"
{
- stormy16_expand_casesi (operands[0], operands[1], operands[2],
+ xstormy16_expand_casesi (operands[0], operands[1], operands[2],
operands[3], operands[4]);
DONE;
}")
""
"
{
- stormy16_expand_prologue ();
+ xstormy16_expand_prologue ();
DONE;
}")
""
"
{
- stormy16_expand_epilogue ();
+ xstormy16_expand_epilogue ();
DONE;
}")
+2001-11-08 Geoffrey Keating <geoffk@redhat.com>
+
+ * g++.old-deja/g++.bugs/900227_01.C: Change stormy16 to xstormy16.
+ * g++.old-deja/g++.eh/badalloc1.C: Change stormy16 to xstormy16.
+ * g++.old-deja/g++.mike/ns15.C: Change stormy16 to xstormy16.
+ * g++.old-deja/g++.pt/crash16.C: Change stormy16 to xstormy16.
+ * gcc.c-torture/compile/961203-1.x: Change stormy16 to xstormy16.
+ * gcc.c-torture/compile/980506-1.x: Change stormy16 to xstormy16.
+ * gcc.c-torture/compile/990617-1.x: Change stormy16 to xstormy16.
+
2001-11-08 Neil Booth <neil@daikokuya.demon.co.uk>
* g++.dg/warn/Wshadow-1.C: New tests.
int main ();
-short s = (short) &main; // WARNING - small integer XFAIL h8*-*-* stormy16-*-*
+short s = (short) &main; // WARNING - small integer XFAIL h8*-*-* xstormy16-*-*
char c = (char) &main; // WARNING - small integer
int main () { return 0; }
-// excess errors test - XFAIL stormy16-*-*
+// excess errors test - XFAIL xstormy16-*-*
// Copyright (C) 2000 Free Software Foundation, Inc.
// Contributed by Nathan Sidwell 6 June 2000 <nathan@codesourcery.com>
// Build don't link:
-// excess errors test - XFAIL stormy16-*-*
+// excess errors test - XFAIL xstormy16-*-*
#include <stdio.h>
#include <stdlib.h>
// Build don't link:
// Special g++ Options:
-// excess errors test - XFAIL stormy16-*-*
+// excess errors test - XFAIL xstormy16-*-*
extern "C" void qsort(void *base, __SIZE_TYPE__ nmemb, __SIZE_TYPE__ size,
int (*compar)(const void *, const void *));
-# The structure is too large for the stormy16 - won't fit in 16 bits.
+# The structure is too large for the xstormy16 - won't fit in 16 bits.
-if { [istarget "stormy16-*-*"] } {
+if { [istarget "xstormy16-*-*"] } {
return 1;
}
-# The arrays are too large for the stormy16 - won't fit in 16 bits.
-if { [istarget "stormy16-*-*"] } {
+# The arrays are too large for the xstormy16 - won't fit in 16 bits.
+if { [istarget "xstormy16-*-*"] } {
return 1;
}
-# 0x70000000 is too large a constant to become a pointer on stormy16.
+# 0x70000000 is too large a constant to become a pointer on xstormy16.
-if { [istarget "stormy16-*-*"] } {
+if { [istarget "xstormy16-*-*"] } {
return 1;
}
projects / gcc.git / commitdiff