#include "config.h"
#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "hashtab.h"
#include "insn-config.h"
#include "output.h"
#include "flags.h"
#include "tree.h"
#include "function.h"
#include "expr.h"
#include "toplev.h"
#include "recog.h"
#include "ggc.h"
#include "dwarf2.h"
#include "debug.h"
#include "tm_p.h"
#include "integrate.h"
#include "target.h"
#include "target-def.h"
#include "real.h"
#define MMIX_FIRST_GLOBAL_REGNUM 32
#define MMIX_CFUN_HAS_LANDING_PAD (cfun->machine->has_landing_pad != 0)
#define MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS \
(flag_exceptions \
&& ((reload_completed && regs_ever_live[MMIX_rJ_REGNUM]) \
|| !leaf_function_p ()))
#define IS_MMIX_EH_RETURN_DATA_REG(REGNO) \
(current_function_calls_eh_return \
&& (EH_RETURN_DATA_REGNO (0) == REGNO \
|| EH_RETURN_DATA_REGNO (1) == REGNO \
|| EH_RETURN_DATA_REGNO (2) == REGNO \
|| EH_RETURN_DATA_REGNO (3) == REGNO))
#define MMIX_OUTPUT_REGNO(N) \
(TARGET_ABI_GNU \
|| (int) (N) < MMIX_RETURN_VALUE_REGNUM \
|| (int) (N) > MMIX_LAST_STACK_REGISTER_REGNUM \
|| cfun == NULL \
|| cfun->machine == NULL \
|| cfun->machine->in_prologue \
? (N) : ((N) - MMIX_RETURN_VALUE_REGNUM \
+ cfun->machine->highest_saved_stack_register + 1))
#define MMIX_POP_ARGUMENT() \
((! TARGET_ABI_GNU \
&& current_function_return_rtx != NULL \
&& ! current_function_returns_struct) \
? (GET_CODE (current_function_return_rtx) == PARALLEL \
? GET_NUM_ELEM (XVEC (current_function_return_rtx, 0)) : 1) \
: 0)
rtx mmix_compare_op0;
rtx mmix_compare_op1;
const char *mmix_cc1_ignored_option;
static int mmix_output_destination_register;
static void mmix_output_shiftvalue_op_from_str
PARAMS ((FILE *, const char *, HOST_WIDEST_INT));
static void mmix_output_shifted_value PARAMS ((FILE *, HOST_WIDEST_INT));
static void mmix_output_condition PARAMS ((FILE *, rtx, int));
static HOST_WIDEST_INT mmix_intval PARAMS ((rtx));
static void mmix_output_octa PARAMS ((FILE *, HOST_WIDEST_INT, int));
static bool mmix_assemble_integer PARAMS ((rtx, unsigned int, int));
static struct machine_function * mmix_init_machine_status PARAMS ((void));
static void mmix_encode_section_info PARAMS ((tree, int));
static const char *mmix_strip_name_encoding PARAMS ((const char *));
static void mmix_emit_sp_add PARAMS ((HOST_WIDE_INT offset));
static void mmix_target_asm_function_prologue
PARAMS ((FILE *, HOST_WIDE_INT));
static void mmix_target_asm_function_end_prologue PARAMS ((FILE *));
static void mmix_target_asm_function_epilogue
PARAMS ((FILE *, HOST_WIDE_INT));
static void mmix_asm_output_mi_thunk
PARAMS ((FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree));
#undef TARGET_ASM_BYTE_OP
#define TARGET_ASM_BYTE_OP NULL
#undef TARGET_ASM_ALIGNED_HI_OP
#define TARGET_ASM_ALIGNED_HI_OP NULL
#undef TARGET_ASM_ALIGNED_SI_OP
#define TARGET_ASM_ALIGNED_SI_OP NULL
#undef TARGET_ASM_ALIGNED_DI_OP
#define TARGET_ASM_ALIGNED_DI_OP NULL
#undef TARGET_ASM_INTEGER
#define TARGET_ASM_INTEGER mmix_assemble_integer
#undef TARGET_ASM_FUNCTION_PROLOGUE
#define TARGET_ASM_FUNCTION_PROLOGUE mmix_target_asm_function_prologue
#undef TARGET_ASM_FUNCTION_END_PROLOGUE
#define TARGET_ASM_FUNCTION_END_PROLOGUE mmix_target_asm_function_end_prologue
#undef TARGET_ASM_FUNCTION_EPILOGUE
#define TARGET_ASM_FUNCTION_EPILOGUE mmix_target_asm_function_epilogue
#undef TARGET_ENCODE_SECTION_INFO
#define TARGET_ENCODE_SECTION_INFO mmix_encode_section_info
#undef TARGET_STRIP_NAME_ENCODING
#define TARGET_STRIP_NAME_ENCODING mmix_strip_name_encoding
#undef TARGET_ASM_OUTPUT_MI_THUNK
#define TARGET_ASM_OUTPUT_MI_THUNK mmix_asm_output_mi_thunk
#undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
#define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
struct gcc_target targetm = TARGET_INITIALIZER;
void
mmix_override_options ()
{
if (flag_pic)
{
warning ("-f%s not supported: ignored", (flag_pic > 1) ? "PIC" : "pic");
flag_pic = 0;
}
}
void
mmix_init_expanders ()
{
init_machine_status = mmix_init_machine_status;
}
static struct machine_function *
mmix_init_machine_status ()
{
return ggc_alloc_cleared (sizeof (struct machine_function));
}
int
mmix_data_alignment (type, basic_align)
tree type ATTRIBUTE_UNUSED;
int basic_align;
{
if (basic_align < 32)
return 32;
return basic_align;
}
int
mmix_constant_alignment (constant, basic_align)
tree constant ATTRIBUTE_UNUSED;
int basic_align;
{
if (basic_align < 32)
return 32;
return basic_align;
}
int
mmix_local_alignment (type, basic_align)
tree type ATTRIBUTE_UNUSED;
int basic_align;
{
if (basic_align < 32)
return 32;
return basic_align;
}
void
mmix_conditional_register_usage ()
{
int i;
if (TARGET_ABI_GNU)
{
static const int gnu_abi_reg_alloc_order[]
= MMIX_GNU_ABI_REG_ALLOC_ORDER;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
reg_alloc_order[i] = gnu_abi_reg_alloc_order[i];
for (i = 15; i <= 30; i++)
call_used_regs[i] = 0;
for (i = MMIX_RESERVED_GNU_ARG_0_REGNUM;
i < MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS;
i++)
fixed_regs[i] = 0;
}
if (! TARGET_TOPLEVEL_SYMBOLS)
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (reg_names[i][0] == ':')
reg_names[i]++;
}
int
mmix_local_regno (regno)
int regno;
{
return regno <= MMIX_LAST_STACK_REGISTER_REGNUM && !call_used_regs[regno];
}
enum reg_class
mmix_preferred_reload_class (x, class)
rtx x ATTRIBUTE_UNUSED;
enum reg_class class;
{
return GET_CODE (x) == MOD && GET_MODE (x) == DImode
? REMAINDER_REG : class;
}
enum reg_class
mmix_preferred_output_reload_class (x, class)
rtx x ATTRIBUTE_UNUSED;
enum reg_class class;
{
return GET_CODE (x) == MOD && GET_MODE (x) == DImode
? REMAINDER_REG : class;
}
enum reg_class
mmix_secondary_reload_class (class, mode, x, in_p)
enum reg_class class;
enum machine_mode mode ATTRIBUTE_UNUSED;
rtx x ATTRIBUTE_UNUSED;
int in_p ATTRIBUTE_UNUSED;
{
if (class == REMAINDER_REG
|| class == HIMULT_REG
|| class == SYSTEM_REGS)
return GENERAL_REGS;
return NO_REGS;
}
int
mmix_const_ok_for_letter_p (value, c)
HOST_WIDE_INT value;
int c;
{
return
(c == 'I' ? value >= 0 && value <= 255
: c == 'J' ? value >= 0 && value <= 65535
: c == 'K' ? value <= 0 && value >= -255
: c == 'L' ? mmix_shiftable_wyde_value (value)
: c == 'M' ? value == 0
: c == 'N' ? mmix_shiftable_wyde_value (~value)
: c == 'O' ? (value == 3 || value == 5 || value == 9
|| value == 17)
: 0);
}
int
mmix_const_double_ok_for_letter_p (value, c)
rtx value;
int c;
{
return
(c == 'G' ? value == CONST0_RTX (GET_MODE (value))
: 0);
}
int
mmix_extra_constraint (x, c, strict)
rtx x;
int c;
int strict;
{
HOST_WIDEST_INT value;
if (c == 'U')
return
strict
? strict_memory_address_p (Pmode, x)
: memory_address_p (Pmode, x);
if (c == 'R')
return
GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE
&& mmix_constant_address_p (x)
&& (! TARGET_BASE_ADDRESSES
|| (GET_CODE (x) == LABEL_REF
|| (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_FLAG (x))));
if (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode)
return 0;
value = mmix_intval (x);
if (c == 'S')
return mmix_shiftable_wyde_value (value);
else if (c == 'T')
return mmix_shiftable_wyde_value (~value);
return 0;
}
rtx
mmix_dynamic_chain_address (frame)
rtx frame;
{
return plus_constant (frame, -8);
}
int
mmix_starting_frame_offset ()
{
return
(-8
+ (MMIX_CFUN_HAS_LANDING_PAD
? -16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? -8 : 0)));
}
rtx
mmix_return_addr_rtx (count, frame)
int count;
rtx frame ATTRIBUTE_UNUSED;
{
return count == 0
? (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS
? validize_mem (gen_rtx_MEM (Pmode, plus_constant (frame_pointer_rtx, -16)))
: get_hard_reg_initial_val (Pmode, MMIX_INCOMING_RETURN_ADDRESS_REGNUM))
: NULL_RTX;
}
void
mmix_setup_frame_addresses ()
{
}
int
mmix_initial_elimination_offset (fromreg, toreg)
int fromreg;
int toreg;
{
int regno;
int fp_sp_offset
= (get_frame_size () + current_function_outgoing_args_size + 7) & ~7;
if (fromreg == MMIX_ARG_POINTER_REGNUM
&& toreg == MMIX_FRAME_POINTER_REGNUM)
return 0;
for (regno = MMIX_FIRST_GLOBAL_REGNUM;
regno <= 255;
regno++)
if ((regs_ever_live[regno] && ! call_used_regs[regno])
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
fp_sp_offset += 8;
return fp_sp_offset
+ (MMIX_CFUN_HAS_LANDING_PAD
? 16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? 8 : 0))
+ (fromreg == MMIX_ARG_POINTER_REGNUM ? 0 : 8);
}
rtx
mmix_function_arg (argsp, mode, type, named, incoming)
const CUMULATIVE_ARGS * argsp;
enum machine_mode mode;
tree type;
int named ATTRIBUTE_UNUSED;
int incoming;
{
if (type == void_type_node)
return (argsp->regs < MMIX_MAX_ARGS_IN_REGS)
? gen_rtx_REG (mode,
(incoming
? MMIX_FIRST_INCOMING_ARG_REGNUM
: MMIX_FIRST_ARG_REGNUM) + argsp->regs)
: NULL_RTX;
return (argsp->regs < MMIX_MAX_ARGS_IN_REGS
&& !MUST_PASS_IN_STACK (mode, type)
&& (GET_MODE_BITSIZE (mode) <= 64
|| argsp->lib
|| TARGET_LIBFUNC))
? gen_rtx_REG (mode,
(incoming
? MMIX_FIRST_INCOMING_ARG_REGNUM
: MMIX_FIRST_ARG_REGNUM)
+ argsp->regs)
: NULL_RTX;
}
int
mmix_function_arg_pass_by_reference (argsp, mode, type, named)
const CUMULATIVE_ARGS * argsp;
enum machine_mode mode;
tree type;
int named ATTRIBUTE_UNUSED;
{
return
MUST_PASS_IN_STACK (mode, type)
|| (MMIX_FUNCTION_ARG_SIZE (mode, type) > 8
&& !TARGET_LIBFUNC
&& !argsp->lib);
}
int
mmix_function_arg_regno_p (regno, incoming)
int regno;
int incoming;
{
int first_arg_regnum
= incoming ? MMIX_FIRST_INCOMING_ARG_REGNUM : MMIX_FIRST_ARG_REGNUM;
return regno >= first_arg_regnum
&& regno < first_arg_regnum + MMIX_MAX_ARGS_IN_REGS;
}
rtx
mmix_function_outgoing_value (valtype, func)
tree valtype;
tree func ATTRIBUTE_UNUSED;
{
enum machine_mode mode = TYPE_MODE (valtype);
enum machine_mode cmode;
int first_val_regnum = MMIX_OUTGOING_RETURN_VALUE_REGNUM;
rtx vec[MMIX_MAX_REGS_FOR_VALUE];
int i;
int nregs;
if (TARGET_ABI_GNU
|| GET_MODE_BITSIZE (mode) <= BITS_PER_WORD)
return
gen_rtx_REG (mode, MMIX_OUTGOING_RETURN_VALUE_REGNUM);
cmode = TYPE_MODE (TREE_TYPE (valtype));
nregs = ((GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD);
if (nregs > MMIX_MAX_REGS_FOR_VALUE)
internal_error ("too large function value type, needs %d registers,\
have only %d registers for this", nregs, MMIX_MAX_REGS_FOR_VALUE);
for (i = 0; i < nregs - 1; i++)
vec[i]
= gen_rtx_EXPR_LIST (VOIDmode,
gen_rtx_REG (cmode, first_val_regnum + i),
GEN_INT ((i + 1) * BITS_PER_UNIT));
vec[nregs - 1]
= gen_rtx_EXPR_LIST (VOIDmode,
gen_rtx_REG (cmode, first_val_regnum + nregs - 1),
GEN_INT (0));
return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nregs, vec));
}
int
mmix_function_value_regno_p (regno)
int regno;
{
return regno == MMIX_RETURN_VALUE_REGNUM;
}
int
mmix_eh_return_data_regno (n)
int n ATTRIBUTE_UNUSED;
{
if (n >= 0 && n < 4)
return MMIX_EH_RETURN_DATA_REGNO_START + n;
return INVALID_REGNUM;
}
rtx
mmix_eh_return_stackadj_rtx ()
{
return gen_rtx_REG (Pmode, MMIX_EH_RETURN_STACKADJ_REGNUM);
}
rtx
mmix_eh_return_handler_rtx ()
{
return
gen_rtx_REG (Pmode, MMIX_INCOMING_RETURN_ADDRESS_REGNUM);
}
int
mmix_asm_preferred_eh_data_format (code, global)
int code ATTRIBUTE_UNUSED;
int global ATTRIBUTE_UNUSED;
{
return DW_EH_PE_absptr;
}
static void
mmix_target_asm_function_prologue (stream, framesize)
FILE *stream ATTRIBUTE_UNUSED;
HOST_WIDE_INT framesize ATTRIBUTE_UNUSED;
{
cfun->machine->in_prologue = 1;
}
static void
mmix_target_asm_function_end_prologue (stream)
FILE *stream ATTRIBUTE_UNUSED;
{
cfun->machine->in_prologue = 0;
}
void
mmix_machine_dependent_reorg (first)
rtx first ATTRIBUTE_UNUSED;
{
int regno;
for (regno = MMIX_LAST_STACK_REGISTER_REGNUM;
regno >= 0;
regno--)
if ((regs_ever_live[regno] && !call_used_regs[regno])
|| (regno == MMIX_FRAME_POINTER_REGNUM && frame_pointer_needed))
break;
if (!TARGET_ABI_GNU && regno < current_function_args_info.regs - 1)
{
regno = current_function_args_info.regs - 1;
if (regno > MMIX_RETURN_VALUE_REGNUM - 1)
regno = MMIX_RETURN_VALUE_REGNUM - 1;
}
cfun->machine->highest_saved_stack_register = regno;
}
static void
mmix_target_asm_function_epilogue (stream, locals_size)
FILE *stream;
HOST_WIDE_INT locals_size ATTRIBUTE_UNUSED;
{
fputc ('\n', stream);
}
static void
mmix_asm_output_mi_thunk (stream, fndecl, delta, vcall_offset, func)
FILE * stream;
tree fndecl ATTRIBUTE_UNUSED;
HOST_WIDE_INT delta;
HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED;
tree func;
{
const char *regname = reg_names[MMIX_FIRST_INCOMING_ARG_REGNUM];
if (delta >= 0 && delta < 65536)
fprintf (stream, "\tINCL %s,%d\n", regname, (int)delta);
else if (delta < 0 && delta >= -255)
fprintf (stream, "\tSUBU %s,%s,%d\n", regname, regname, (int)-delta);
else
{
mmix_output_register_setting (stream, 255, delta, 1);
fprintf (stream, "\tADDU %s,%s,$255\n", regname, regname);
}
fprintf (stream, "\tJMP ");
assemble_name (stream, XSTR (XEXP (DECL_RTL (func), 0), 0));
fprintf (stream, "\n");
}
void
mmix_function_profiler (stream, labelno)
FILE *stream ATTRIBUTE_UNUSED;
int labelno ATTRIBUTE_UNUSED;
{
sorry ("function_profiler support for MMIX");
}
void
mmix_setup_incoming_varargs (args_so_farp, mode, vartype, pretend_sizep,
second_time)
CUMULATIVE_ARGS * args_so_farp;
enum machine_mode mode;
tree vartype;
int * pretend_sizep;
int second_time ATTRIBUTE_UNUSED;
{
if (args_so_farp->regs + 1 < MMIX_MAX_ARGS_IN_REGS)
*pretend_sizep = (MMIX_MAX_ARGS_IN_REGS - (args_so_farp->regs + 1)) * 8;
if ((7 + (MMIX_FUNCTION_ARG_SIZE (mode, vartype))) / 8 != 1)
internal_error ("MMIX Internal: Last named vararg would not fit in a register");
}
rtx
mmix_expand_builtin_va_arg (valist, type)
tree valist;
tree type;
{
tree ptr_size = size_int (BITS_PER_WORD / BITS_PER_UNIT);
tree addr_tree, type_size = NULL;
tree align, alignm1;
tree rounded_size;
rtx addr;
addr_tree = valist;
align = size_int (PARM_BOUNDARY / BITS_PER_UNIT);
alignm1 = size_int (PARM_BOUNDARY / BITS_PER_UNIT - 1);
if (type == error_mark_node
|| (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
|| TREE_OVERFLOW (type_size))
rounded_size = size_zero_node;
else
rounded_size = fold (build (MULT_EXPR, sizetype,
fold (build (TRUNC_DIV_EXPR, sizetype,
fold (build (PLUS_EXPR, sizetype,
type_size, alignm1)),
align)),
align));
if (AGGREGATE_TYPE_P (type)
&& GET_MODE_UNIT_SIZE (TYPE_MODE (type)) < 8
&& GET_MODE_UNIT_SIZE (TYPE_MODE (type)) != 0)
{
addr_tree
= build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
size_int ((BITS_PER_WORD / BITS_PER_UNIT)
- GET_MODE_UNIT_SIZE (TYPE_MODE (type))));
}
else if (!integer_zerop (rounded_size))
{
if (!really_constant_p (type_size))
addr_tree
= build1 (INDIRECT_REF, build_pointer_type (type), addr_tree);
else
{
tree addend
= fold (build (COND_EXPR, sizetype,
fold (build (GT_EXPR, sizetype,
rounded_size,
align)),
size_zero_node,
fold (build (MINUS_EXPR, sizetype,
rounded_size,
type_size))));
tree addr_tree1
= fold (build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree,
addend));
addr_tree
= fold (build (COND_EXPR, TREE_TYPE (addr_tree1),
fold (build (GT_EXPR, sizetype,
rounded_size,
ptr_size)),
build1 (INDIRECT_REF, build_pointer_type (type),
addr_tree1),
addr_tree1));
}
}
addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
addr = copy_to_reg (addr);
if (!integer_zerop (rounded_size))
{
tree t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
build (PLUS_EXPR, TREE_TYPE (valist), valist,
ptr_size));
TREE_SIDE_EFFECTS (t) = 1;
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
return addr;
}
int mmix_trampoline_size = 32;
void
mmix_trampoline_template (stream)
FILE * stream;
{
fprintf (stream, "\tGETA $255,1F\n\t");
fprintf (stream, "LDOU %s,$255,0\n\t",
reg_names[MMIX_STATIC_CHAIN_REGNUM]);
fprintf (stream, "LDOU $255,$255,8\n\t");
fprintf (stream, "GO $255,$255,0\n");
fprintf (stream, "1H\tOCTA 0\n\t");
fprintf (stream, "OCTA 0\n");
}
void
mmix_initialize_trampoline (trampaddr, fnaddr, static_chain)
rtx trampaddr;
rtx fnaddr;
rtx static_chain;
{
emit_move_insn (gen_rtx_MEM (DImode, plus_constant (trampaddr, 16)),
static_chain);
emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (trampaddr, 24)),
fnaddr);
emit_insn (gen_sync_icache (validize_mem (gen_rtx_MEM (DImode,
trampaddr)),
GEN_INT (mmix_trampoline_size - 1)));
}
int
mmix_constant_address_p (x)
rtx x;
{
RTX_CODE code = GET_CODE (x);
int addend = 0;
int constant_ok = TARGET_BASE_ADDRESSES != 0;
switch (code)
{
case LABEL_REF:
case SYMBOL_REF:
return 1;
case CONSTANT_P_RTX:
case HIGH:
return constant_ok;
case CONST_INT:
addend = INTVAL (x);
break;
case CONST_DOUBLE:
if (GET_MODE (x) != VOIDmode)
return constant_ok;
addend = CONST_DOUBLE_LOW (x);
break;
case CONST:
if (GET_CODE (XEXP (x, 0)) == PLUS)
{
rtx x0 = XEXP (XEXP (x, 0), 0);
rtx x1 = XEXP (XEXP (x, 0), 1);
if ((GET_CODE (x0) == SYMBOL_REF
|| GET_CODE (x0) == LABEL_REF)
&& (GET_CODE (x1) == CONST_INT
|| (GET_CODE (x1) == CONST_DOUBLE
&& GET_MODE (x1) == VOIDmode)))
addend = mmix_intval (x1);
else
return constant_ok;
}
else
return constant_ok;
break;
default:
return 0;
}
return constant_ok || (addend & 3) == 0;
}
int
mmix_legitimate_address (mode, x, strict_checking)
enum machine_mode mode ATTRIBUTE_UNUSED;
rtx x;
int strict_checking;
{
#define MMIX_REG_OK(X) \
((strict_checking \
&& (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
|| (reg_renumber[REGNO (X)] > 0 \
&& reg_renumber[REGNO (X)] <= MMIX_LAST_GENERAL_REGISTER))) \
|| (!strict_checking \
&& (REGNO (X) <= MMIX_LAST_GENERAL_REGISTER \
|| REGNO (X) >= FIRST_PSEUDO_REGISTER \
|| REGNO (X) == ARG_POINTER_REGNUM)))
if (REG_P (x) && MMIX_REG_OK (x))
return 1;
if (GET_CODE(x) == PLUS)
{
rtx x1 = XEXP (x, 0);
rtx x2 = XEXP (x, 1);
if (! REG_P (x1))
{
rtx tem = x1;
x1 = x2;
x2 = tem;
}
if (!REG_P (x1) || !MMIX_REG_OK (x1))
return TARGET_BASE_ADDRESSES && mmix_constant_address_p (x);
if (REG_P (x2) && MMIX_REG_OK (x2))
return 1;
if (GET_CODE (x2) == CONST_INT
&& CONST_OK_FOR_LETTER_P (INTVAL (x2), 'I'))
return 1;
return 0;
}
return TARGET_BASE_ADDRESSES && mmix_constant_address_p (x);
}
int
mmix_legitimate_constant_p (x)
rtx x;
{
RTX_CODE code = GET_CODE (x);
if (code == CONST_INT || code == CONST_DOUBLE)
return 1;
return CONSTANT_ADDRESS_P (x);
}
enum machine_mode
mmix_select_cc_mode (op, x, y)
RTX_CODE op;
rtx x;
rtx y ATTRIBUTE_UNUSED;
{
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
{
if (op == ORDERED || op == UNORDERED || op == UNGE
|| op == UNGT || op == UNLE || op == UNLT)
return CC_FUNmode;
if (op == EQ || op == NE)
return CC_FPEQmode;
return CC_FPmode;
}
if (op == GTU || op == LTU || op == GEU || op == LEU)
return CC_UNSmode;
return CCmode;
}
int
mmix_reversible_cc_mode (mode)
enum machine_mode mode;
{
return mode != CC_FPmode;
}
int
mmix_rtx_cost_recalculated (x, code, outer_code, costp)
rtx x ATTRIBUTE_UNUSED;
RTX_CODE code ATTRIBUTE_UNUSED;
RTX_CODE outer_code ATTRIBUTE_UNUSED;
int *costp ATTRIBUTE_UNUSED;
{
return 0;
}
int
mmix_address_cost (addr)
rtx addr ATTRIBUTE_UNUSED;
{
return 1;
}
int
mmix_register_move_cost (mode, from, to)
enum machine_mode mode ATTRIBUTE_UNUSED;
enum reg_class from;
enum reg_class to;
{
return (from == GENERAL_REGS && from == to) ? 2 : 3;
}
const char *
mmix_data_section_asm_op ()
{
return "\t.data ! mmixal:= 8H LOC 9B";
}
static void
mmix_encode_section_info (decl, first)
tree decl;
int first;
{
if ((TREE_CODE (decl) == VAR_DECL
&& (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl)))
|| (TREE_CODE (decl) == FUNCTION_DECL && TREE_PUBLIC (decl)))
;
else if (first && DECL_P (decl))
{
const char *str = XSTR (XEXP (DECL_RTL (decl), 0), 0);
int len = strlen (str);
char *newstr;
newstr = (char *) ggc_alloc_string ("", len + 1);
strcpy (newstr + 1, str);
*newstr = '@';
XSTR (XEXP (DECL_RTL (decl), 0), 0) = newstr;
}
if (TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CONSTANT (decl)
|| (TREE_CODE (decl) == VAR_DECL
&& TREE_READONLY (decl)
&& !TREE_SIDE_EFFECTS (decl)
&& (!DECL_INITIAL (decl)
|| TREE_CONSTANT (DECL_INITIAL (decl)))))
{
rtx rtl = (TREE_CODE_CLASS (TREE_CODE (decl)) != 'd'
? TREE_CST_RTL (decl) : DECL_RTL (decl));
SYMBOL_REF_FLAG (XEXP (rtl, 0)) = 1;
}
}
static const char *
mmix_strip_name_encoding (name)
const char *name;
{
for (; (*name == '@' || *name == '*'); name++)
;
return name;
}
void
mmix_asm_file_start (stream)
FILE * stream;
{
ASM_OUTPUT_SOURCE_FILENAME (stream, main_input_filename);
fprintf (stream, "! mmixal:= 8H LOC Data_Section\n");
text_section ();
}
void
mmix_asm_file_end (stream)
FILE * stream ATTRIBUTE_UNUSED;
{
data_section ();
}
void
mmix_asm_output_source_filename (stream, name)
FILE * stream;
const char * name;
{
fprintf (stream, "# 1 ");
OUTPUT_QUOTED_STRING (stream, name);
fprintf (stream, "\n");
}
void
mmix_output_quoted_string (stream, string, length)
FILE * stream;
const char * string;
int length;
{
const char * string_end = string + length;
static const char *const unwanted_chars = "\"[]\\";
while (string < string_end)
{
if (*string
&& (unsigned char) *string < 128
&& !ISCNTRL (*string)
&& strchr (unwanted_chars, *string) == NULL)
{
fputc ('"', stream);
while (*string
&& (unsigned char) *string < 128
&& !ISCNTRL (*string)
&& strchr (unwanted_chars, *string) == NULL
&& string < string_end)
{
fputc (*string, stream);
string++;
}
fputc ('"', stream);
if (string < string_end)
fprintf (stream, ",");
}
if (string < string_end)
{
fprintf (stream, "#%x", *string & 255);
string++;
if (string < string_end)
fprintf (stream, ",");
}
}
}
void
mmix_asm_output_source_line (stream, lineno)
FILE * stream;
int lineno;
{
fprintf (stream, "# %d ", lineno);
OUTPUT_QUOTED_STRING (stream, main_input_filename);
fprintf (stream, "\n");
}
static bool
mmix_assemble_integer (x, size, aligned_p)
rtx x;
unsigned int size;
int aligned_p;
{
if (aligned_p)
switch (size)
{
case 1:
if (GET_CODE (x) != CONST_INT)
{
aligned_p = 0;
break;
}
fputs ("\tBYTE\t", asm_out_file);
mmix_print_operand (asm_out_file, x, 'B');
fputc ('\n', asm_out_file);
return true;
case 2:
if (GET_CODE (x) != CONST_INT)
{
aligned_p = 0;
break;
}
fputs ("\tWYDE\t", asm_out_file);
mmix_print_operand (asm_out_file, x, 'W');
fputc ('\n', asm_out_file);
return true;
case 4:
if (GET_CODE (x) != CONST_INT)
{
aligned_p = 0;
break;
}
fputs ("\tTETRA\t", asm_out_file);
mmix_print_operand (asm_out_file, x, 'L');
fputc ('\n', asm_out_file);
return true;
case 8:
if (GET_CODE (x) == CONST_DOUBLE)
abort ();
assemble_integer_with_op ("\tOCTA\t", x);
return true;
}
return default_assemble_integer (x, size, aligned_p);
}
void
mmix_asm_output_ascii (stream, string, length)
FILE *stream;
const char *string;
int length;
{
while (length > 0)
{
int chunk_size = length > 60 ? 60 : length;
fprintf (stream, "\tBYTE ");
mmix_output_quoted_string (stream, string, chunk_size);
string += chunk_size;
length -= chunk_size;
fprintf (stream, "\n");
}
}
void
mmix_asm_output_aligned_common (stream, name, size, align)
FILE *stream;
const char *name;
int size;
int align;
{
fprintf (stream, "\t.comm\t");
assemble_name (stream, name);
fprintf (stream, ",%u,%u ! mmixal-incompatible COMMON\n",
size, align / BITS_PER_UNIT);
}
void
mmix_asm_output_aligned_local (stream, name, size, align)
FILE * stream;
const char * name;
int size;
int align;
{
data_section ();
ASM_OUTPUT_ALIGN (stream, exact_log2 (align/BITS_PER_UNIT));
assemble_name (stream, name);
fprintf (stream, "\tLOC @+%d\n", size);
}
void
mmix_asm_output_label (stream, name)
FILE *stream;
const char * name;
{
assemble_name (stream, name);
fprintf (stream, "\tIS @\n");
}
void
mmix_asm_declare_register_global (stream, decl, regno, name)
FILE *stream ATTRIBUTE_UNUSED;
tree decl ATTRIBUTE_UNUSED;
int regno ATTRIBUTE_UNUSED;
const char *name ATTRIBUTE_UNUSED;
{
}
void
mmix_asm_weaken_label (stream, name)
FILE * stream ATTRIBUTE_UNUSED;
const char * name ATTRIBUTE_UNUSED;
{
fprintf (stream, "\t.weak ");
assemble_name (stream, name);
fprintf (stream, " ! mmixal-incompatible\n");
}
void
mmix_make_decl_one_only (decl)
tree decl;
{
DECL_WEAK (decl) = 1;
}
void
mmix_asm_output_labelref (stream, name)
FILE *stream;
const char *name;
{
int is_extern = 1;
for (; (*name == '@' || *name == '*'); name++)
if (*name == '@')
is_extern = 0;
asm_fprintf (stream, "%s%U%s",
is_extern && TARGET_TOPLEVEL_SYMBOLS ? ":" : "",
name);
}
void
mmix_asm_output_internal_label (stream, name, num)
FILE * stream;
const char * name;
int num;
{
fprintf (stream, "%s:%d\tIS @\n", name, num);
}
void
mmix_asm_output_def (stream, name, value)
FILE * stream;
const char * name;
const char * value;
{
assemble_name (stream, name);
fprintf (stream, "\tIS ");
assemble_name (stream, value);
fputc ('\n', stream);
}
void
mmix_print_operand (stream, x, code)
FILE * stream;
rtx x;
int code;
{
rtx modified_x = x;
int regno = x != NULL_RTX && REG_P (x) ? REGNO (x) : 0;
switch (code)
{
case '+':
if (TARGET_BRANCH_PREDICT)
{
x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
if (x && INTVAL (XEXP (x, 0)) > REG_BR_PROB_BASE / 2)
putc ('P', stream);
}
return;
case '.':
fprintf (stream, "%d", MMIX_POP_ARGUMENT ());
return;
case 'B':
if (GET_CODE (x) != CONST_INT)
fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x);
fprintf (stream, "%d", (int) (INTVAL (x) & 0xff));
return;
case 'H':
if (regno > MMIX_LAST_GENERAL_REGISTER - 1)
internal_error ("MMIX Internal: Bad register: %d", regno);
fprintf (stream, "%s", reg_names[MMIX_OUTPUT_REGNO (regno)]);
return;
case 'L':
if (GET_CODE (x) == CONST_INT)
{
fprintf (stream, "#%lx",
(unsigned long) (INTVAL (x)
& ((unsigned int) 0x7fffffff * 2 + 1)));
return;
}
if (GET_CODE (x) == SYMBOL_REF)
{
output_addr_const (stream, x);
return;
}
if (regno > MMIX_LAST_GENERAL_REGISTER - 1)
internal_error ("MMIX Internal: Bad register: %d", regno);
fprintf (stream, "%s", reg_names[MMIX_OUTPUT_REGNO (regno) + 1]);
return;
case 'A':
mmix_output_shiftvalue_op_from_str (stream, "ANDN",
~(unsigned HOST_WIDEST_INT)
mmix_intval (x));
return;
case 'i':
mmix_output_shiftvalue_op_from_str (stream, "INC",
(unsigned HOST_WIDEST_INT)
mmix_intval (x));
return;
case 'o':
mmix_output_shiftvalue_op_from_str (stream, "OR",
(unsigned HOST_WIDEST_INT)
mmix_intval (x));
return;
case 's':
mmix_output_shiftvalue_op_from_str (stream, "SET",
(unsigned HOST_WIDEST_INT)
mmix_intval (x));
return;
case 'd':
case 'D':
mmix_output_condition (stream, x, (code == 'D'));
return;
case 'e':
if (TARGET_FCMP_EPSILON)
fprintf (stream, "e");
return;
case 'm':
if (GET_CODE (x) != CONST_INT)
{
fatal_insn ("MMIX Internal: Bad value for 'm', not a CONST_INT",
x);
}
fprintf (stream, HOST_WIDEST_INT_PRINT_DEC,
(HOST_WIDEST_INT) (mmix_intval (x) - 1));
return;
case 'p':
fprintf (stream, "%d",
cfun->machine->highest_saved_stack_register + 1);
return;
case 'r':
if (! REG_P (x))
fatal_insn ("MMIX Internal: Expected a register, not this", x);
mmix_output_destination_register = MMIX_OUTPUT_REGNO (regno);
return;
case 'I':
if (GET_CODE (x) != CONST_INT
&& (GET_CODE (x) != CONST_DOUBLE
|| (GET_MODE (x) != VOIDmode && GET_MODE (x) != DFmode
&& GET_MODE (x) != SFmode)))
fatal_insn ("MMIX Internal: Expected a constant, not this", x);
mmix_output_register_setting (stream,
mmix_output_destination_register,
mmix_intval (x), 0);
return;
case 'U':
if (TARGET_ZERO_EXTEND)
putc ('U', stream);
return;
case 'v':
mmix_output_shifted_value (stream, (HOST_WIDEST_INT) mmix_intval (x));
return;
case 'V':
mmix_output_shifted_value (stream, (HOST_WIDEST_INT) ~mmix_intval (x));
return;
case 'W':
if (GET_CODE (x) != CONST_INT)
fatal_insn ("MMIX Internal: Expected a CONST_INT, not this", x);
fprintf (stream, "#%x", (int) (INTVAL (x) & 0xffff));
return;
case 0:
break;
default:
internal_error ("MMIX Internal: Missing `%c' case in mmix_print_operand", code);
}
switch (GET_CODE (modified_x))
{
case REG:
regno = REGNO (modified_x);
if (regno >= FIRST_PSEUDO_REGISTER)
internal_error ("MMIX Internal: Bad register: %d", regno);
fprintf (stream, "%s", reg_names[MMIX_OUTPUT_REGNO (regno)]);
return;
case MEM:
output_address (XEXP (modified_x, 0));
return;
case CONST_INT:
if (INTVAL (modified_x) > -256 && INTVAL (modified_x) < 256)
fprintf (stream, "%d", (int) (INTVAL (modified_x)));
else
fprintf (stream, "#%x",
(int) (INTVAL (modified_x)) & (unsigned int) ~0);
return;
case CONST_DOUBLE:
mmix_output_octa (stream, mmix_intval (modified_x), 0);
return;
case CONST:
output_addr_const (stream, modified_x);
return;
default:
if (CONSTANT_P (modified_x)
|| GET_CODE (modified_x) == CODE_LABEL)
{
output_addr_const (stream, modified_x);
return;
}
fatal_insn ("MMIX Internal: Cannot decode this operand", x);
}
}
int
mmix_print_operand_punct_valid_p (code)
int code ATTRIBUTE_UNUSED;
{
return code == '+'
|| code == '.';
}
void
mmix_print_operand_address (stream, x)
FILE *stream;
rtx x;
{
if (REG_P (x))
{
fprintf (stream, "%s,0", reg_names[MMIX_OUTPUT_REGNO (REGNO (x))]);
return;
}
else if (GET_CODE (x) == PLUS)
{
rtx x1 = XEXP (x, 0);
rtx x2 = XEXP (x, 1);
if (REG_P (x1))
{
fprintf (stream, "%s,", reg_names[MMIX_OUTPUT_REGNO (REGNO (x1))]);
if (REG_P (x2))
{
fprintf (stream, "%s",
reg_names[MMIX_OUTPUT_REGNO (REGNO (x2))]);
return;
}
else if (GET_CODE (x2) == CONST_INT
&& CONST_OK_FOR_LETTER_P (INTVAL (x2), 'I'))
{
output_addr_const (stream, x2);
return;
}
}
}
if (TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p (x))
{
output_addr_const (stream, x);
return;
}
fatal_insn ("MMIX Internal: This is not a recognized address", x);
}
void
mmix_asm_output_reg_push (stream, regno)
FILE * stream;
int regno;
{
fprintf (stream, "\tSUBU %s,%s,8\n\tSTOU %s,%s,0\n",
reg_names[MMIX_STACK_POINTER_REGNUM],
reg_names[MMIX_STACK_POINTER_REGNUM],
reg_names[MMIX_OUTPUT_REGNO (regno)],
reg_names[MMIX_STACK_POINTER_REGNUM]);
}
void
mmix_asm_output_reg_pop (stream, regno)
FILE * stream;
int regno;
{
fprintf (stream, "\tLDOU %s,%s,0\n\tINCL %s,8\n",
reg_names[MMIX_OUTPUT_REGNO (regno)],
reg_names[MMIX_STACK_POINTER_REGNUM],
reg_names[MMIX_STACK_POINTER_REGNUM]);
}
void
mmix_asm_output_addr_diff_elt (stream, body, value, rel)
FILE *stream;
rtx body ATTRIBUTE_UNUSED;
int value;
int rel;
{
fprintf (stream, "\tTETRA L%d-L%d\n", value, rel);
}
void
mmix_asm_output_addr_vec_elt (stream, value)
FILE *stream;
int value;
{
fprintf (stream, "\tOCTA L:%d\n", value);
}
void
mmix_asm_output_skip (stream, nbytes)
FILE *stream;
int nbytes;
{
fprintf (stream, "\tLOC @+%d\n", nbytes);
}
void
mmix_asm_output_align (stream, power)
FILE *stream;
int power;
{
fprintf (stream, "\t.p2align %d\n", power);
fprintf (stream, "\tLOC @+(%d-@)&%d\n", 1 << power, (1 << power) - 1);
}
int
mmix_dbx_register_number (regno)
int regno;
{
regno = MMIX_OUTPUT_REGNO (regno);
return regno >= 224 ? (regno - 224) : (regno + 48);
}
rtx
mmix_get_hard_reg_initial_val (mode, regno)
enum machine_mode mode;
int regno;
{
return get_hard_reg_initial_val (mode, regno);
}
int
mmix_use_simple_return ()
{
int regno;
int stack_space_to_allocate
= (current_function_outgoing_args_size
+ current_function_pretend_args_size
+ get_frame_size () + 7) & ~7;
if (!TARGET_USE_RETURN_INSN || !reload_completed)
return 0;
for (regno = 255;
regno >= MMIX_FIRST_GLOBAL_REGNUM;
regno--)
if ((((regno != MMIX_FRAME_POINTER_REGNUM || !frame_pointer_needed)
&& regs_ever_live[regno] && !call_used_regs[regno]))
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
return 0;
if (frame_pointer_needed)
stack_space_to_allocate += 8;
if (MMIX_CFUN_HAS_LANDING_PAD)
stack_space_to_allocate += 16;
else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS)
stack_space_to_allocate += 8;
return stack_space_to_allocate == 0;
}
void
mmix_expand_prologue ()
{
HOST_WIDE_INT locals_size = get_frame_size ();
int regno;
HOST_WIDE_INT stack_space_to_allocate
= (current_function_outgoing_args_size
+ current_function_pretend_args_size
+ locals_size + 7) & ~7;
HOST_WIDE_INT offset = -8;
for (regno = 255;
regno >= MMIX_FIRST_GLOBAL_REGNUM;
regno--)
if ((((regno != MMIX_FRAME_POINTER_REGNUM || !frame_pointer_needed)
&& regs_ever_live[regno] && !call_used_regs[regno]))
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
stack_space_to_allocate += 8;
if (frame_pointer_needed)
stack_space_to_allocate += 8;
if (MMIX_CFUN_HAS_LANDING_PAD)
stack_space_to_allocate += 16;
else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS)
stack_space_to_allocate += 8;
if ((stack_space_to_allocate % 8) != 0)
internal_error ("stack frame not a multiple of 8 bytes: %d",
stack_space_to_allocate);
if (current_function_pretend_args_size)
{
int mmix_first_vararg_reg
= (MMIX_FIRST_INCOMING_ARG_REGNUM
+ (MMIX_MAX_ARGS_IN_REGS
- current_function_pretend_args_size / 8));
for (regno
= MMIX_FIRST_INCOMING_ARG_REGNUM + MMIX_MAX_ARGS_IN_REGS - 1;
regno >= mmix_first_vararg_reg;
regno--)
{
if (offset < 0)
{
HOST_WIDE_INT stack_chunk
= stack_space_to_allocate > (256 - 8)
? (256 - 8) : stack_space_to_allocate;
mmix_emit_sp_add (-stack_chunk);
offset += stack_chunk;
stack_space_to_allocate -= stack_chunk;
}
emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)),
gen_rtx_REG (DImode, regno));
offset -= 8;
}
}
if (frame_pointer_needed)
{
rtx insn;
if (offset < 0)
{
HOST_WIDE_INT stack_chunk
= stack_space_to_allocate > (256 - 8 - 8)
? (256 - 8 - 8) : stack_space_to_allocate;
mmix_emit_sp_add (-stack_chunk);
offset += stack_chunk;
stack_space_to_allocate -= stack_chunk;
}
insn = emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)),
hard_frame_pointer_rtx);
RTX_FRAME_RELATED_P (insn) = 1;
insn = emit_insn (gen_adddi3 (hard_frame_pointer_rtx,
stack_pointer_rtx,
GEN_INT (offset + 8)));
RTX_FRAME_RELATED_P (insn) = 1;
offset -= 8;
}
if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS)
{
rtx tmpreg, retreg;
rtx insn;
if (offset < 0)
{
HOST_WIDE_INT stack_chunk
= stack_space_to_allocate > (256 - 8 - 8)
? (256 - 8 - 8) : stack_space_to_allocate;
mmix_emit_sp_add (-stack_chunk);
offset += stack_chunk;
stack_space_to_allocate -= stack_chunk;
}
tmpreg = gen_rtx_REG (DImode, 255);
retreg = gen_rtx_REG (DImode, MMIX_rJ_REGNUM);
emit_move_insn (tmpreg, retreg);
insn = emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)),
tmpreg);
RTX_FRAME_RELATED_P (insn) = 1;
REG_NOTES (insn)
= gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
gen_rtx_SET (VOIDmode,
gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)),
retreg),
REG_NOTES (insn));
offset -= 8;
}
else if (MMIX_CFUN_HAS_LANDING_PAD)
offset -= 8;
if (MMIX_CFUN_HAS_LANDING_PAD)
{
if (offset < 0)
{
HOST_WIDE_INT stack_chunk
= stack_space_to_allocate > (256 - 8 - 8)
? (256 - 8 - 8) : stack_space_to_allocate;
mmix_emit_sp_add (-stack_chunk);
offset += stack_chunk;
stack_space_to_allocate -= stack_chunk;
}
emit_move_insn (gen_rtx_REG (DImode, 255),
gen_rtx_REG (DImode,
MMIX_rO_REGNUM));
emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx, offset)),
gen_rtx_REG (DImode, 255));
offset -= 8;
}
offset -= (locals_size + 7) & ~7;
for (regno = 255;
regno >= MMIX_FIRST_GLOBAL_REGNUM;
regno--)
if (((regno != MMIX_FRAME_POINTER_REGNUM || !frame_pointer_needed)
&& regs_ever_live[regno] && ! call_used_regs[regno])
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
{
rtx insn;
if (offset < 0)
{
HOST_WIDE_INT stack_chunk
= (stack_space_to_allocate > (256 - offset - 8)
? (256 - offset - 8) : stack_space_to_allocate);
mmix_emit_sp_add (-stack_chunk);
offset += stack_chunk;
stack_space_to_allocate -= stack_chunk;
}
insn = emit_move_insn (gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)),
gen_rtx_REG (DImode, regno));
RTX_FRAME_RELATED_P (insn) = 1;
offset -= 8;
}
if (stack_space_to_allocate)
mmix_emit_sp_add (-stack_space_to_allocate);
}
void
mmix_expand_epilogue ()
{
HOST_WIDE_INT locals_size = get_frame_size ();
int regno;
HOST_WIDE_INT stack_space_to_deallocate
= (current_function_outgoing_args_size
+ current_function_pretend_args_size
+ locals_size + 7) & ~7;
int offset = current_function_outgoing_args_size;
for (regno = 255;
regno >= MMIX_FIRST_GLOBAL_REGNUM;
regno--)
if (((regno != MMIX_FRAME_POINTER_REGNUM || !frame_pointer_needed)
&& regs_ever_live[regno] && !call_used_regs[regno])
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
stack_space_to_deallocate += 8;
if (MMIX_CFUN_HAS_LANDING_PAD)
stack_space_to_deallocate += 16;
else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS)
stack_space_to_deallocate += 8;
if (frame_pointer_needed)
stack_space_to_deallocate += 8;
if ((stack_space_to_deallocate % 8) != 0)
internal_error ("stack frame not a multiple of octabyte: %d",
stack_space_to_deallocate);
for (regno = MMIX_FIRST_GLOBAL_REGNUM;
regno <= 255;
regno++)
if (((regno != MMIX_FRAME_POINTER_REGNUM || !frame_pointer_needed)
&& regs_ever_live[regno] && !call_used_regs[regno])
|| IS_MMIX_EH_RETURN_DATA_REG (regno))
{
if (offset > 255)
{
mmix_emit_sp_add (offset);
stack_space_to_deallocate -= offset;
offset = 0;
}
emit_move_insn (gen_rtx_REG (DImode, regno),
gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)));
offset += 8;
}
offset += (locals_size + 7) & ~7;
if (MMIX_CFUN_HAS_LANDING_PAD)
offset += 16;
else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS)
offset += 8;
if (frame_pointer_needed)
{
if (offset > 255)
{
mmix_emit_sp_add (offset);
stack_space_to_deallocate -= offset;
offset = 0;
}
emit_move_insn (hard_frame_pointer_rtx,
gen_rtx_MEM (DImode,
plus_constant (stack_pointer_rtx,
offset)));
offset += 8;
}
if (stack_space_to_deallocate != 0)
mmix_emit_sp_add (stack_space_to_deallocate);
if (current_function_calls_eh_return)
emit_insn (gen_adddi3 (stack_pointer_rtx, stack_pointer_rtx,
gen_rtx_REG (DImode,
MMIX_EH_RETURN_STACKADJ_REGNUM)));
}
void
mmix_output_register_setting (stream, regno, value, do_begin_end)
FILE *stream;
int regno;
HOST_WIDEST_INT value;
int do_begin_end;
{
if (do_begin_end)
fprintf (stream, "\t");
if (mmix_shiftable_wyde_value ((unsigned HOST_WIDEST_INT) value))
{
mmix_output_shiftvalue_op_from_str (stream, "SET",
(unsigned HOST_WIDEST_INT)
value);
fprintf (stream, " %s,", reg_names[regno]);
mmix_output_shifted_value (stream, (unsigned HOST_WIDEST_INT) value);
}
else if (mmix_shiftable_wyde_value (-(unsigned HOST_WIDEST_INT) value))
{
mmix_output_shiftvalue_op_from_str (stream, "SET",
-(unsigned HOST_WIDEST_INT)
value);
fprintf (stream, " %s,", reg_names[regno]);
mmix_output_shifted_value (stream, -(unsigned HOST_WIDEST_INT) value);
fprintf (stream, "\n\tNEGU %s,0,%s", reg_names[regno],
reg_names[regno]);
}
else if (mmix_shiftable_wyde_value (~(unsigned HOST_WIDEST_INT) value))
{
mmix_output_shiftvalue_op_from_str (stream, "SET",
~(unsigned HOST_WIDEST_INT)
value);
fprintf (stream, " %s,", reg_names[regno]);
mmix_output_shifted_value (stream, ~(unsigned HOST_WIDEST_INT) value);
fprintf (stream, "\n\tNOR %s,%s,0", reg_names[regno],
reg_names[regno]);
}
else
{
static const char *const higher_parts[] = {"L", "ML", "MH", "H"};
const char *op = "SET";
const char *line_begin = "";
int insns = 0;
int i;
HOST_WIDEST_INT tmpvalue = value;
for (i = 0; i < 4 && tmpvalue != 0; i++)
{
if (tmpvalue & 65535)
insns++;
tmpvalue >>= 16;
}
if (TARGET_BASE_ADDRESSES && insns == 3)
{
fprintf (stream, "LDA %s,", reg_names[regno]);
mmix_output_octa (stream, value, 0);
}
else
{
for (i = 0; i < 4 && value != 0; i++)
{
if (value & 65535)
{
fprintf (stream, "%s%s%s %s,#%x", line_begin, op,
higher_parts[i], reg_names[regno],
(int) (value & 65535));
op = "INC";
line_begin = "\n\t";
}
value >>= 16;
}
}
}
if (do_begin_end)
fprintf (stream, "\n");
}
int
mmix_shiftable_wyde_value (value)
unsigned HOST_WIDEST_INT value;
{
int i;
int has_candidate = 0;
for (i = 0; i < 4; i++)
{
if (value & 65535)
{
if (has_candidate)
return 0;
else
has_candidate = 1;
}
value >>= 16;
}
return 1;
}
int
mmix_symbolic_or_address_operand (op, mode)
rtx op;
enum machine_mode mode;
{
switch (GET_CODE (op))
{
case SYMBOL_REF:
case LABEL_REF:
return 1;
case CONST:
op = XEXP (op, 0);
if ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
|| GET_CODE (XEXP (op, 0)) == LABEL_REF)
&& (GET_CODE (XEXP (op, 1)) == CONST_INT
|| (GET_CODE (XEXP (op, 1)) == CONST_DOUBLE
&& GET_MODE (XEXP (op, 1)) == VOIDmode)))
return 1;
default:
return address_operand (op, mode);
}
}
int
mmix_reg_or_constant_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return register_operand (op, mode)
|| (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)
|| GET_CODE (op) == CONST_INT;
}
int
mmix_reg_cc_operand (op, mode)
rtx op;
enum machine_mode mode;
{
if (mode == VOIDmode)
mode = GET_MODE (op);
return register_operand (op, mode)
&& (mode == CCmode || mode == CC_UNSmode || mode == CC_FPmode
|| mode == CC_FPEQmode || mode == CC_FUNmode);
}
int
mmix_foldable_comparison_operator (op, mode)
rtx op;
enum machine_mode mode;
{
RTX_CODE code = GET_CODE (op);
if (mode == VOIDmode)
mode = GET_MODE (op);
if (mode == VOIDmode && GET_RTX_CLASS (GET_CODE (op)) == '<')
mode = GET_MODE (XEXP (op, 0));
return ((mode == CCmode || mode == DImode)
&& (code == NE || code == EQ || code == GE || code == GT
|| code == LE))
|| (mode == CC_UNSmode && (code == GTU || code == LEU));
}
int
mmix_comparison_operator (op, mode)
rtx op;
enum machine_mode mode;
{
RTX_CODE code = GET_CODE (op);
if (mode == VOIDmode)
mode = GET_MODE (op);
if (mode == VOIDmode && GET_RTX_CLASS (GET_CODE (op)) == '<')
mode = GET_MODE (XEXP (op, 0));
return
(mode == VOIDmode && GET_RTX_CLASS (GET_CODE (op)) == '<')
|| (mode == CC_FUNmode
&& (code == ORDERED || code == UNORDERED))
|| (mode == CC_FPmode
&& (code == GT || code == LT))
|| (mode == CC_FPEQmode
&& (code == NE || code == EQ))
|| (mode == CC_UNSmode
&& (code == GEU || code == GTU || code == LEU || code == LTU))
|| (mode == CCmode
&& (code == NE || code == EQ || code == GE || code == GT
|| code == LE || code == LT))
|| (mode == DImode
&& (code == NE || code == EQ || code == GE || code == GT
|| code == LE || code == LT || code == LEU || code == GTU));
}
int
mmix_reg_or_0_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return
op == CONST0_RTX (mode == VOIDmode ? GET_MODE (op) : mode)
|| register_operand (op, mode);
}
int
mmix_reg_or_8bit_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return register_operand (op, mode)
|| (GET_CODE (op) == CONST_INT
&& CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'));
}
int
mmix_valid_comparison (code, mode, op)
RTX_CODE code;
enum machine_mode mode;
rtx op;
{
if (mode == VOIDmode && op != NULL_RTX)
mode = GET_MODE (op);
if (mode == CCmode || mode == CC_UNSmode || mode == DImode)
return 1;
if ((mode == CC_FPmode || mode == DFmode)
&& (code == GT || code == LT))
return 1;
if ((mode == CC_FPEQmode || mode == DFmode)
&& (code == EQ || code == NE))
return 1;
if ((mode == CC_FUNmode || mode == DFmode)
&& (code == ORDERED || code == UNORDERED))
return 1;
return 0;
}
rtx
mmix_gen_compare_reg (code, x, y)
RTX_CODE code;
rtx x, y;
{
enum machine_mode ccmode = SELECT_CC_MODE (code, x, y);
rtx cc_reg;
enum machine_mode mode
= GET_MODE (x) == VOIDmode
? GET_MODE (y)
: GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT ? DFmode : DImode;
if (! mmix_valid_comparison (code, mode, x))
return NULL_RTX;
cc_reg = gen_reg_rtx (ccmode);
if (! REG_P (x) && ! REG_P (y))
x = force_reg (mode, x);
if (! REG_P (y)
&& (GET_CODE (y) != CONST_INT
|| ! CONST_OK_FOR_LETTER_P (INTVAL (y), 'I')))
y = force_reg (mode, y);
emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
gen_rtx_COMPARE (ccmode, x, y)));
return cc_reg;
}
static void
mmix_emit_sp_add (offset)
HOST_WIDE_INT offset;
{
rtx insn;
if (offset < 0)
{
if (offset > -255)
insn = emit_insn (gen_adddi3 (stack_pointer_rtx,
stack_pointer_rtx,
GEN_INT (offset)));
else
{
rtx tmpr = gen_rtx_REG (DImode, 255);
RTX_FRAME_RELATED_P (emit_move_insn (tmpr, GEN_INT (offset))) = 1;
insn = emit_insn (gen_adddi3 (stack_pointer_rtx,
stack_pointer_rtx, tmpr));
}
RTX_FRAME_RELATED_P (insn) = 1;
}
else
{
if (CONST_OK_FOR_LETTER_P (offset, 'L'))
emit_insn (gen_adddi3 (stack_pointer_rtx,
stack_pointer_rtx,
GEN_INT (offset)));
else
{
rtx tmpr = gen_rtx_REG (DImode, 255);
emit_move_insn (tmpr, GEN_INT (offset));
insn = emit_insn (gen_adddi3 (stack_pointer_rtx,
stack_pointer_rtx, tmpr));
}
}
}
static void
mmix_output_shiftvalue_op_from_str (stream, mainop, value)
FILE *stream;
const char *mainop;
HOST_WIDEST_INT value;
{
static const char *const op_part[] = {"L", "ML", "MH", "H"};
int i;
if (! mmix_shiftable_wyde_value (value))
{
char s[sizeof ("0xffffffffffffffff")];
sprintf (s, HOST_WIDEST_INT_PRINT_HEX, value);
internal_error ("MMIX Internal: %s is not a shiftable int", s);
}
for (i = 0; i < 4; i++)
{
if (value & 0xffff)
{
fprintf (stream, "%s%s", mainop, op_part[i]);
return;
}
value >>= 16;
}
fprintf (stream, "%sL", mainop);
}
static void
mmix_output_octa (stream, value, do_begin_end)
FILE *stream;
HOST_WIDEST_INT value;
int do_begin_end;
{
char hex_format[sizeof (HOST_WIDEST_INT_PRINT_HEX)];
if (do_begin_end)
fprintf (stream, "\tOCTA ");
strcpy (hex_format, HOST_WIDEST_INT_PRINT_HEX);
hex_format[0] = '#';
hex_format[1] = '0';
if ((value < (HOST_WIDEST_INT) 0 && value > (HOST_WIDEST_INT) -10000)
|| (value >= (HOST_WIDEST_INT) 0 && value <= (HOST_WIDEST_INT) 16384))
fprintf (stream, "%d", (int) value);
else if (value > (HOST_WIDEST_INT) 0
&& value < ((HOST_WIDEST_INT) 1 << 31) * 2)
fprintf (stream, "#%x", (unsigned int) value);
else
fprintf (stream, hex_format, value);
if (do_begin_end)
fprintf (stream, "\n");
}
static void
mmix_output_shifted_value (stream, value)
FILE * stream;
HOST_WIDEST_INT value;
{
int i;
if (! mmix_shiftable_wyde_value (value))
{
char s[16+2+1];
sprintf (s, HOST_WIDEST_INT_PRINT_HEX, value);
internal_error ("MMIX Internal: %s is not a shiftable int", s);
}
for (i = 0; i < 4; i++)
{
if (value & 0xffff)
{
fprintf (stream, "#%x", (int) (value & 0xffff));
return;
}
value >>= 16;
}
fprintf (stream, "0");
}
static void
mmix_output_condition (stream, x, reversed)
FILE *stream;
rtx x;
int reversed;
{
struct cc_conv
{
RTX_CODE cc;
const char *const normal;
const char *const reversed;
};
struct cc_type_conv
{
enum machine_mode cc_mode;
const struct cc_conv *const convs;
};
#undef CCEND
#define CCEND {NIL, NULL, NULL}
static const struct cc_conv cc_fun_convs[]
= {{ORDERED, "Z", "P"},
{UNORDERED, "P", "Z"},
CCEND};
static const struct cc_conv cc_fp_convs[]
= {{GT, "P", NULL},
{LT, "N", NULL},
CCEND};
static const struct cc_conv cc_fpeq_convs[]
= {{NE, "Z", "P"},
{EQ, "P", "Z"},
CCEND};
static const struct cc_conv cc_uns_convs[]
= {{GEU, "NN", "N"},
{GTU, "P", "NP"},
{LEU, "NP", "P"},
{LTU, "N", "NN"},
CCEND};
static const struct cc_conv cc_signed_convs[]
= {{NE, "NZ", "Z"},
{EQ, "Z", "NZ"},
{GE, "NN", "N"},
{GT, "P", "NP"},
{LE, "NP", "P"},
{LT, "N", "NN"},
CCEND};
static const struct cc_conv cc_di_convs[]
= {{NE, "NZ", "Z"},
{EQ, "Z", "NZ"},
{GE, "NN", "N"},
{GT, "P", "NP"},
{LE, "NP", "P"},
{LT, "N", "NN"},
{GTU, "NZ", "Z"},
{LEU, "Z", "NZ"},
CCEND};
#undef CCEND
static const struct cc_type_conv cc_convs[]
= {{CC_FUNmode, cc_fun_convs},
{CC_FPmode, cc_fp_convs},
{CC_FPEQmode, cc_fpeq_convs},
{CC_UNSmode, cc_uns_convs},
{CCmode, cc_signed_convs},
{DImode, cc_di_convs}};
size_t i;
int j;
enum machine_mode mode = GET_MODE (XEXP (x, 0));
RTX_CODE cc = GET_CODE (x);
for (i = 0; i < ARRAY_SIZE (cc_convs); i++)
{
if (mode == cc_convs[i].cc_mode)
{
for (j = 0; cc_convs[i].convs[j].cc != NIL; j++)
if (cc == cc_convs[i].convs[j].cc)
{
const char *mmix_cc
= (reversed ? cc_convs[i].convs[j].reversed
: cc_convs[i].convs[j].normal);
if (mmix_cc == NULL)
fatal_insn ("MMIX Internal: Trying to output invalidly\
reversed condition:", x);
fprintf (stream, "%s", mmix_cc);
return;
}
fatal_insn ("MMIX Internal: What's the CC of this?", x);
}
}
fatal_insn ("MMIX Internal: What is the CC of this?", x);
}
static HOST_WIDEST_INT
mmix_intval (x)
rtx x;
{
unsigned HOST_WIDEST_INT retval;
if (GET_CODE (x) == CONST_INT)
return INTVAL (x);
if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == VOIDmode)
{
if (sizeof (HOST_WIDE_INT) < sizeof (HOST_WIDEST_INT))
{
retval = (unsigned) CONST_DOUBLE_LOW (x) / 2;
retval *= 2;
retval |= CONST_DOUBLE_LOW (x) & 1;
retval |=
(unsigned HOST_WIDEST_INT) CONST_DOUBLE_HIGH (x)
<< (HOST_BITS_PER_LONG);
}
else
retval = CONST_DOUBLE_HIGH (x);
return retval;
}
if (GET_CODE (x) == CONST_DOUBLE)
{
REAL_VALUE_TYPE value;
REAL_VALUE_FROM_CONST_DOUBLE (value, x);
if (GET_MODE (x) == DFmode)
{
long bits[2];
REAL_VALUE_TO_TARGET_DOUBLE (value, bits);
if (sizeof (long) < sizeof (HOST_WIDEST_INT))
{
retval = (unsigned long) bits[1] / 2;
retval *= 2;
retval |= (unsigned long) bits[1] & 1;
retval
|= (unsigned HOST_WIDEST_INT) bits[0]
<< (sizeof (bits[0]) * 8);
}
else
retval = (unsigned long) bits[1];
return retval;
}
else if (GET_MODE (x) == SFmode)
{
long bits;
REAL_VALUE_TO_TARGET_SINGLE (value, bits);
return (unsigned long) bits;
}
}
fatal_insn ("MMIX Internal: This is not a constant:", x);
}