| /* Definitions of target machine for GNU compiler, for MMIX. |
| Copyright (C) 2000, 2001 Free Software Foundation, Inc. |
| Contributed by Hans-Peter Nilsson (hp@bitrange.com) |
| |
| This file is part of GNU CC. |
| |
| GNU CC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU CC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU CC; see the file COPYING. If not, write to |
| the Free Software Foundation, 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. */ |
| |
| #include "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" |
| |
| /* First some local helper definitions. */ |
| #define MMIX_FIRST_GLOBAL_REGNUM 32 |
| |
| /* We'd need a current_function_has_landing_pad. It's marked as such when |
| a nonlocal_goto_receiver is expanded. Not just a C++ thing, but |
| mostly. */ |
| #define MMIX_CFUN_HAS_LANDING_PAD (cfun->machine->has_landing_pad != 0) |
| |
| /* We have no means to tell DWARF 2 about the register stack, so we need |
| to store the return address on the stack if an exception can get into |
| this function. FIXME: Narrow condition. */ |
| #define MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS \ |
| (flag_exceptions && ! 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)) |
| |
| /* The canonical saved comparison operands for non-cc0 machines, set in |
| the compare expander. */ |
| rtx mmix_compare_op0; |
| rtx mmix_compare_op1; |
| |
| /* We ignore some options with arguments. They are passed to the linker, |
| but also ends up here because they start with "-m". We tell the driver |
| to store them in a variable we don't inspect. */ |
| const char *mmix_cc1_ignored_option; |
| |
| /* Declarations of locals. */ |
| |
| /* This is used in the prologue for what number to pass in a PUSHJ or |
| PUSHGO insn. */ |
| static int mmix_highest_saved_stack_register; |
| |
| /* Intermediate for insn output. */ |
| 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 void mmix_init_machine_status PARAMS ((struct function *)); |
| |
| extern void mmix_target_asm_function_prologue |
| PARAMS ((FILE *, HOST_WIDE_INT)); |
| extern void mmix_target_asm_function_epilogue |
| PARAMS ((FILE *, HOST_WIDE_INT)); |
| |
| |
| /* Target structure macros. Listed by node. See `Using and Porting GCC' |
| for a general description. */ |
| |
| /* Node: Function Entry */ |
| |
| #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_EPILOGUE |
| #define TARGET_ASM_FUNCTION_EPILOGUE mmix_target_asm_function_epilogue |
| |
| struct gcc_target targetm = TARGET_INITIALIZER; |
| |
| /* Functions that are expansions for target macros. |
| See Target Macros in `Using and Porting GCC'. */ |
| |
| /* OVERRIDE_OPTIONS. */ |
| |
| void |
| mmix_override_options () |
| { |
| /* Should we err or should we warn? Hmm. At least we must neutralize |
| it. For example the wrong kind of case-tables will be generated with |
| PIC; we use absolute address items for mmixal compatibility. FIXME: |
| They could be relative if we just elide them to after all pertinent |
| labels. */ |
| if (flag_pic) |
| { |
| warning ("-f%s not supported: ignored", (flag_pic > 1) ? "PIC" : "pic"); |
| flag_pic = 0; |
| } |
| |
| /* All other targets add GC roots from their override_options function, |
| so play along. */ |
| ggc_add_rtx_root (&mmix_compare_op0, 1); |
| ggc_add_rtx_root (&mmix_compare_op1, 1); |
| } |
| |
| /* INIT_EXPANDERS. */ |
| |
| void |
| mmix_init_expanders () |
| { |
| init_machine_status = mmix_init_machine_status; |
| } |
| |
| /* Set the per-function data. */ |
| |
| static void |
| mmix_init_machine_status (f) |
| struct function *f; |
| { |
| f->machine = xcalloc (1, sizeof (struct machine_function)); |
| } |
| |
| /* DATA_ALIGNMENT. |
| We have trouble getting the address of stuff that is located at other |
| than 32-bit alignments (GETA requirements), so try to give everything |
| at least 32-bit alignment. */ |
| |
| int |
| mmix_data_alignment (type, basic_align) |
| tree type ATTRIBUTE_UNUSED; |
| int basic_align; |
| { |
| if (basic_align < 32) |
| return 32; |
| |
| return basic_align; |
| } |
| |
| /* CONSTANT_ALIGNMENT. */ |
| |
| int |
| mmix_constant_alignment (constant, basic_align) |
| tree constant ATTRIBUTE_UNUSED; |
| int basic_align; |
| { |
| if (basic_align < 32) |
| return 32; |
| |
| return basic_align; |
| } |
| |
| /* LOCAL_ALIGNMENT. */ |
| |
| int |
| mmix_local_alignment (type, basic_align) |
| tree type ATTRIBUTE_UNUSED; |
| int basic_align; |
| { |
| if (basic_align < 32) |
| return 32; |
| |
| return basic_align; |
| } |
| |
| /* CONDITIONAL_REGISTER_USAGE. */ |
| |
| 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]; |
| |
| /* Change the default from the mmixware ABI. For the GNU ABI, |
| $15..$30 are call-saved just as $0..$14. There must be one |
| call-clobbered local register for the "hole" describing number of |
| saved local registers saved by PUSHJ/PUSHGO during the function |
| call, receiving the return value at return. So best is to use |
| the highest, $31. It's already marked call-clobbered for the |
| mmixware ABI. */ |
| for (i = 15; i <= 30; i++) |
| call_used_regs[i] = 0; |
| } |
| |
| /* Step over the ":" in special register names. */ |
| if (! TARGET_TOPLEVEL_SYMBOLS) |
| for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) |
| if (reg_names[i][0] == ':') |
| reg_names[i]++; |
| } |
| |
| /* PREFERRED_RELOAD_CLASS. |
| We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */ |
| |
| enum reg_class |
| mmix_preferred_reload_class (x, class) |
| rtx x ATTRIBUTE_UNUSED; |
| enum reg_class class; |
| { |
| /* FIXME: Revisit. */ |
| return GET_CODE (x) == MOD && GET_MODE (x) == DImode |
| ? REMAINDER_REG : class; |
| } |
| |
| /* PREFERRED_OUTPUT_RELOAD_CLASS. |
| We need to extend the reload class of REMAINDER_REG and HIMULT_REG. */ |
| |
| enum reg_class |
| mmix_preferred_output_reload_class (x, class) |
| rtx x ATTRIBUTE_UNUSED; |
| enum reg_class class; |
| { |
| /* FIXME: Revisit. */ |
| return GET_CODE (x) == MOD && GET_MODE (x) == DImode |
| ? REMAINDER_REG : class; |
| } |
| |
| /* SECONDARY_RELOAD_CLASS. |
| We need to reload regs of REMAINDER_REG and HIMULT_REG elsewhere. */ |
| |
| enum reg_class |
| mmix_secondary_reload_class (class, mode, x, in_p) |
| enum reg_class class; |
| enum machine_mode mode; |
| rtx x; |
| int in_p; |
| { |
| if (class == REMAINDER_REG |
| || class == HIMULT_REG |
| || class == SYSTEM_REGS) |
| return GENERAL_REGS; |
| |
| if (mode != DImode || in_p) |
| return NO_REGS; |
| |
| /* We have to help reload. */ |
| if (mode == DImode && GET_CODE (x) == MEM |
| && ! address_operand (XEXP (x, 0), GET_MODE (x))) |
| return GENERAL_REGS; |
| |
| /* FIXME: Optimize this; there are lots of PLUS:es that don't need a |
| reload register. */ |
| if (GET_CODE (x) == PLUS) |
| return GENERAL_REGS; |
| |
| return NO_REGS; |
| } |
| |
| /* CONST_OK_FOR_LETTER_P. */ |
| |
| 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); |
| } |
| |
| /* CONST_DOUBLE_OK_FOR_LETTER_P. */ |
| |
| int |
| mmix_const_double_ok_for_letter_p (value, c) |
| rtx value; |
| int c; |
| { |
| return |
| (c == 'G' ? value == CONST0_RTX (GET_MODE (value)) |
| : 0); |
| } |
| |
| /* EXTRA_CONSTRAINT. |
| We need this since our constants are not always expressible as |
| CONST_INT:s, but rather often as CONST_DOUBLE:s. */ |
| |
| int |
| mmix_extra_constraint (x, c) |
| rtx x; |
| int c; |
| { |
| HOST_WIDEST_INT value; |
| |
| if (c == 'U') |
| return address_operand (x, Pmode); |
| |
| if (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode) |
| return 0; |
| |
| value = mmix_intval (x); |
| |
| /* We used to map Q->J, R->K, S->L, T->N, U->O, but we don't have to any |
| more ('U' taken for address_operand). Some letters map outside of |
| CONST_INT, though; we still use 'S' and 'T'. */ |
| if (c == 'S') |
| return mmix_shiftable_wyde_value (value); |
| else if (c == 'T') |
| return mmix_shiftable_wyde_value (~value); |
| return 0; |
| } |
| |
| /* DYNAMIC_CHAIN_ADDRESS. */ |
| |
| rtx |
| mmix_dynamic_chain_address (frame) |
| rtx frame; |
| { |
| /* FIXME: the frame-pointer is stored at offset -8 from the current |
| frame-pointer. Unfortunately, the caller assumes that a |
| frame-pointer is present for *all* previous frames. There should be |
| a way to say that that cannot be done, like for RETURN_ADDR_RTX. */ |
| return plus_constant (frame, -8); |
| } |
| |
| /* STARTING_FRAME_OFFSET. */ |
| |
| int |
| mmix_starting_frame_offset () |
| { |
| /* The old frame pointer is in the slot below the new one, so |
| FIRST_PARM_OFFSET does not need to depend on whether the |
| frame-pointer is needed or not. We have to adjust for the register |
| stack pointer being located below the saved frame pointer. |
| Similarly, we store the return address on the stack too, for |
| exception handling, and always if we save the register stack pointer. */ |
| return |
| (-8 |
| + (MMIX_CFUN_HAS_LANDING_PAD |
| ? -16 : (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS ? -8 : 0))); |
| } |
| |
| /* RETURN_ADDR_RTX. */ |
| |
| rtx |
| mmix_return_addr_rtx (count, frame) |
| int count; |
| rtx frame ATTRIBUTE_UNUSED; |
| { |
| return count == 0 |
| ? (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS |
| /* FIXME: Set frame_alias_set on the following. */ |
| ? 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; |
| } |
| |
| /* SETUP_FRAME_ADDRESSES. */ |
| |
| void |
| mmix_setup_frame_addresses () |
| { |
| /* Nothing needed at the moment. */ |
| } |
| |
| /* The difference between the (imaginary) frame pointer and the stack |
| pointer. Used to eliminate the frame pointer. */ |
| |
| 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; |
| |
| /* There is no actual difference between these two. */ |
| if (fromreg == MMIX_ARG_POINTER_REGNUM |
| && toreg == MMIX_FRAME_POINTER_REGNUM) |
| return 0; |
| |
| /* The difference is the size of local variables plus the size of |
| outgoing function arguments that would normally be passed as |
| registers but must be passed on stack because we're out of |
| function-argument registers. Only global saved registers are |
| counted; the others go on the register stack. |
| |
| The frame-pointer is counted too if it is what is eliminated, as we |
| need to balance the offset for it from STARTING_FRAME_OFFSET. |
| |
| Also add in the slot for the register stack pointer we save if we |
| have a landing pad. |
| |
| Unfortunately, we can't access $0..$14, from unwinder code easily, so |
| store the return address in a frame slot too. FIXME: Only for |
| non-leaf functions. FIXME: Always with a landing pad, because it's |
| hard to know whether we need the other at the time we know we need |
| the offset for one (and have to state it). It's a kludge until we |
| can express the register stack in the EH frame info. |
| |
| We have to do alignment here; get_frame_size will not return a |
| multiple of STACK_BOUNDARY. FIXME: Add note in manual. */ |
| |
| 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); |
| } |
| |
| /* Return an rtx for a function argument to go in a register, and 0 for |
| one that must go on stack. */ |
| |
| 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; |
| { |
| /* Handling of the positional dummy parameter for varargs gets nasty. |
| Check execute/991216-3 and function.c:assign_params. We have to say |
| that the dummy parameter goes on stack in order to get the correct |
| offset when va_start and va_arg is applied. FIXME: Should do TRT by |
| itself in the gcc core. */ |
| if ((! named && incoming && current_function_varargs) || argsp->now_varargs) |
| return NULL_RTX; |
| |
| /* Last-argument marker. */ |
| 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; |
| } |
| |
| /* Returns nonzero for everything that goes by reference, 0 for |
| everything that goes by value. */ |
| |
| 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; |
| { |
| /* FIXME: Check: I'm not sure the MUST_PASS_IN_STACK check is |
| necessary. */ |
| return |
| MUST_PASS_IN_STACK (mode, type) |
| || (MMIX_FUNCTION_ARG_SIZE (mode, type) > 8 |
| && !TARGET_LIBFUNC |
| && !argsp->lib); |
| } |
| |
| /* Return nonzero if regno is a register number where a parameter is |
| passed, and 0 otherwise. */ |
| |
| 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; |
| } |
| |
| /* FUNCTION_OUTGOING_VALUE. */ |
| |
| 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; |
| |
| /* Return values that fit in a register need no special handling. |
| There's no register hole when parameters are passed in global |
| registers. */ |
| if (TARGET_ABI_GNU |
| || GET_MODE_BITSIZE (mode) <= BITS_PER_WORD) |
| return |
| gen_rtx_REG (mode, MMIX_OUTGOING_RETURN_VALUE_REGNUM); |
| |
| /* A complex type, made up of components. */ |
| cmode = TYPE_MODE (TREE_TYPE (valtype)); |
| nregs = ((GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD); |
| |
| /* We need to take care of the effect of the register hole on return |
| values of large sizes; the last register will appear as the first |
| register, with the rest shifted. (For complex modes, this is just |
| swapped registers.) */ |
| |
| 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); |
| |
| /* FIXME: Maybe we should handle structure values like this too |
| (adjusted for BLKmode), perhaps for both ABI:s. */ |
| 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)); |
| } |
| |
| /* EH_RETURN_DATA_REGNO. */ |
| |
| 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; |
| } |
| |
| /* EH_RETURN_STACKADJ_RTX. */ |
| |
| rtx |
| mmix_eh_return_stackadj_rtx () |
| { |
| return gen_rtx_REG (Pmode, MMIX_EH_RETURN_STACKADJ_REGNUM); |
| } |
| |
| /* EH_RETURN_HANDLER_RTX. */ |
| |
| rtx |
| mmix_eh_return_handler_rtx () |
| { |
| return |
| gen_rtx_REG (Pmode, MMIX_INCOMING_RETURN_ADDRESS_REGNUM); |
| } |
| |
| /* ASM_PREFERRED_EH_DATA_FORMAT. */ |
| |
| int |
| mmix_asm_preferred_eh_data_format (code, global) |
| int code ATTRIBUTE_UNUSED; |
| int global ATTRIBUTE_UNUSED; |
| { |
| /* This is the default (was at 2001-07-20). Revisit when needed. */ |
| return DW_EH_PE_absptr; |
| } |
| |
| /* Emit the function prologue. For simplicity while the port is still |
| in a flux, we do it as text rather than the now preferred RTL way, |
| as (define_insn "function_prologue"). |
| |
| FIXME: Translate to RTL and/or optimize some of the DWARF 2 stuff. */ |
| |
| void |
| mmix_target_asm_function_prologue (stream, locals_size) |
| FILE *stream; |
| HOST_WIDE_INT locals_size; |
| { |
| int regno; |
| int stack_space_to_allocate |
| = (current_function_outgoing_args_size |
| + current_function_pretend_args_size |
| + (int) locals_size + 8 + 7) & ~7; |
| int offset = -8; |
| int empty_stack_frame |
| = (current_function_outgoing_args_size == 0 |
| && locals_size == 0 |
| && current_function_pretend_args_size == 0 |
| && current_function_varargs == 0 |
| && current_function_stdarg == 0); |
| int doing_dwarf = dwarf2out_do_frame (); |
| long cfa_offset = 0; |
| |
| /* Guard our assumptions. Very low priority FIXME. */ |
| if (locals_size != (int) locals_size) |
| error ("stack frame too big"); |
| |
| /* Add room needed to save global non-register-stack registers. */ |
| for (regno = 255; |
| regno >= MMIX_FIRST_GLOBAL_REGNUM; |
| regno--) |
| /* Note that we assume that the frame-pointer-register is one of these |
| registers, in which case we don't count it here. */ |
| 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 we do have a frame-pointer, add room for it. */ |
| if (frame_pointer_needed) |
| stack_space_to_allocate += 8; |
| |
| /* If we have a non-local label, we need to be able to unwind to it, so |
| store the current register stack pointer. Also store the return |
| address if we do that. */ |
| if (MMIX_CFUN_HAS_LANDING_PAD) |
| stack_space_to_allocate += 16; |
| else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS) |
| /* If we do have a saved return-address slot, add room for it. */ |
| stack_space_to_allocate += 8; |
| |
| /* Make sure we don't get an unaligned stack. */ |
| 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) |
| { |
| int stack_chunk |
| = stack_space_to_allocate > (256 - 8) |
| ? (256 - 8) : stack_space_to_allocate; |
| |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_chunk); |
| |
| if (doing_dwarf) |
| { |
| /* Each call to dwarf2out_def_cfa overrides the previous |
| setting; they don't accumulate. We must keep track |
| of the offset ourselves. */ |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| offset += stack_chunk; |
| stack_space_to_allocate -= stack_chunk; |
| } |
| |
| fprintf (stream, "\tSTOU %s,%s,%d\n", reg_names[regno], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset); |
| |
| /* These registers aren't actually saved (as in "will be |
| restored"), so don't tell DWARF2 they're saved. */ |
| |
| offset -= 8; |
| } |
| } |
| |
| /* In any case, skip over the return-address slot. FIXME: Not needed |
| now. */ |
| offset -= 8; |
| |
| /* Store the frame-pointer. */ |
| |
| if (frame_pointer_needed) |
| { |
| empty_stack_frame = 0; |
| |
| if (offset < 0) |
| { |
| /* Get 8 less than otherwise, since we need to reach offset + 8. */ |
| int stack_chunk |
| = stack_space_to_allocate > (256 - 8 - 8) |
| ? (256 - 8 - 8) : stack_space_to_allocate; |
| |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_chunk); |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| offset += stack_chunk; |
| stack_space_to_allocate -= stack_chunk; |
| } |
| |
| fprintf (stream, "\tSTOU %s,%s,%d\n\tADDU %s,%s,%d\n", |
| reg_names[MMIX_FRAME_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset, |
| reg_names[MMIX_FRAME_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset + 8); |
| if (doing_dwarf) |
| dwarf2out_reg_save ("", MMIX_FRAME_POINTER_REGNUM, |
| -cfa_offset + offset); |
| |
| offset -= 8; |
| } |
| |
| if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS) |
| { |
| /* Store the return-address, if one is needed on the stack. */ |
| empty_stack_frame = 0; |
| |
| if (offset < 0) |
| { |
| /* Get 8 less than otherwise, since we need to reach offset + 8. */ |
| int stack_chunk |
| = stack_space_to_allocate > (256 - 8 - 8) |
| ? (256 - 8 - 8) : stack_space_to_allocate; |
| |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_chunk); |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| offset += stack_chunk; |
| stack_space_to_allocate -= stack_chunk; |
| } |
| |
| fprintf (stream, "\tGET $255,rJ\n\tSTOU $255,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset); |
| if (doing_dwarf) |
| dwarf2out_return_save ("", -cfa_offset + offset); |
| offset -= 8; |
| } |
| else if (MMIX_CFUN_HAS_LANDING_PAD) |
| offset -= 8; |
| |
| if (MMIX_CFUN_HAS_LANDING_PAD) |
| { |
| /* Store the register defining the numbering of local registers, so |
| we know how long to unwind the register stack. */ |
| |
| empty_stack_frame = 0; |
| |
| if (offset < 0) |
| { |
| /* Get 8 less than otherwise, since we need to reach offset + 8. */ |
| int stack_chunk |
| = stack_space_to_allocate > (256 - 8 - 8) |
| ? (256 - 8 - 8) : stack_space_to_allocate; |
| |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_chunk); |
| offset += stack_chunk; |
| stack_space_to_allocate -= stack_chunk; |
| |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| } |
| |
| /* We don't tell dwarf2 about this one; we just have it to unwind |
| the register stack at landing pads. FIXME: It's a kludge because |
| we can't describe the effect of the PUSHJ and PUSHGO insns on the |
| register stack at the moment. Best thing would be to handle it |
| like stack-pointer offsets. Better: some hook into dwarf2out.c |
| to produce DW_CFA_expression:s that specify the increment of rO, |
| and unwind it at eh_return (preferred) or at the landing pad. |
| Then saves to $0..$G-1 could be specified through that register. */ |
| |
| fprintf (stream, "\tGET $255,rO\n\tSTOU $255,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], offset); |
| |
| offset -= 8; |
| } |
| |
| /* After the return-address and the frame-pointer, we have the local |
| variables. They're the ones that may have an "unaligned" size. */ |
| offset -= (locals_size + 7) & ~7; |
| |
| /* Now store all registers that are global, i.e. not saved by the |
| register file machinery. |
| |
| It is assumed that the frame-pointer is one of these registers, so it |
| is explicitly excluded in the count. */ |
| |
| 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)) |
| { |
| empty_stack_frame = 0; |
| |
| if (offset < 0) |
| { |
| int stack_chunk; |
| |
| /* Since the local variables go above, we may get a large |
| offset here. */ |
| if (offset < -248) |
| { |
| /* We're not going to access the locals area in the |
| prologue, so we'll just silently subtract the slab we |
| will not access. */ |
| stack_chunk = |
| stack_space_to_allocate > (256 - offset - 8) |
| ? (256 - offset - 8) : stack_space_to_allocate; |
| |
| mmix_output_register_setting (stream, 255, stack_chunk, 1); |
| fprintf (stream, "\tSUBU %s,%s,$255\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| } |
| else |
| { |
| stack_chunk = stack_space_to_allocate > (256 - 8) |
| ? (256 - 8) : stack_space_to_allocate; |
| |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], stack_chunk); |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_chunk; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| } |
| |
| offset += stack_chunk; |
| stack_space_to_allocate -= stack_chunk; |
| } |
| |
| fprintf (stream, "\tSTOU %s,%s,%d\n", reg_names[regno], |
| reg_names[MMIX_STACK_POINTER_REGNUM], offset); |
| if (doing_dwarf) |
| dwarf2out_reg_save ("", regno, -cfa_offset + offset); |
| offset -= 8; |
| } |
| |
| /* Finally, allocate room for local vars (if they weren't allocated for |
| above) and outgoing args. This might be any number of bytes (well, |
| we assume it fits in a host-int). |
| Don't allocate (the return-address slot) if the stack frame is empty. */ |
| if (stack_space_to_allocate && ! empty_stack_frame) |
| { |
| if (stack_space_to_allocate < 256) |
| { |
| fprintf (stream, "\tSUBU %s,%s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_space_to_allocate); |
| } |
| else |
| { |
| mmix_output_register_setting (stream, 255, |
| stack_space_to_allocate, 1); |
| fprintf (stream, "\tSUBU %s,%s,$255\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| |
| if (doing_dwarf) |
| { |
| cfa_offset += stack_space_to_allocate; |
| dwarf2out_def_cfa ("", MMIX_STACK_POINTER_REGNUM, |
| cfa_offset); |
| } |
| } |
| |
| /* We put the number of the highest saved register-file register in a |
| location convenient for the call-patterns to output. Note that we |
| don't tell dwarf2 about these registers, since it can't restore them |
| anyway. */ |
| for (regno = MMIX_LAST_REGISTER_FILE_REGNUM; |
| regno >= 0; |
| regno--) |
| if ((regs_ever_live[regno] && !call_used_regs[regno]) |
| || (regno == MMIX_FRAME_POINTER_REGNUM && frame_pointer_needed)) |
| break; |
| |
| mmix_highest_saved_stack_register = regno; |
| |
| /* FIXME: A kludge for the MMIXware ABI. The return value comes back in |
| L of the caller, not just the register number of the X field of |
| PUSH{J,GO}. So we need to make L agree with that number if there's a |
| function call in this function that returns a value but takes no |
| parameters (if there were parameters, L would be set to at least the |
| first parameter register, $16). A real solution includes a pass to |
| test that settings of $15 (MMIX_RETURN_VALUE_REGNUM for the MMIXware |
| ABI) dominate all function calls that return a value. This could be |
| done in the planned machine_dep_reorg pass to rename all registers. */ |
| if (! TARGET_ABI_GNU && cfun->machine->has_call_value_without_parameters) |
| fprintf (stream, "\tSET %s,%s\n", |
| reg_names[MMIX_RETURN_VALUE_REGNUM], |
| reg_names[MMIX_RETURN_VALUE_REGNUM]); |
| } |
| |
| /* TARGET_ASM_FUNCTION_EPILOGUE. */ |
| |
| void |
| mmix_target_asm_function_epilogue (stream, locals_size) |
| FILE *stream; |
| HOST_WIDE_INT locals_size; |
| |
| { |
| int regno; |
| int stack_space_to_deallocate |
| = (current_function_outgoing_args_size |
| + current_function_pretend_args_size |
| + (int) locals_size + 8 + 7) & ~7; |
| |
| /* The assumption that locals_size fits in an int is asserted in |
| mmix_target_asm_function_prologue. */ |
| |
| /* The first address to access is beyond the outgoing_args area. */ |
| int offset = current_function_outgoing_args_size; |
| int empty_stack_frame |
| = (current_function_outgoing_args_size == 0 |
| && locals_size == 0 |
| && current_function_pretend_args_size == 0 |
| && ! MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS |
| && ! MMIX_CFUN_HAS_LANDING_PAD); |
| |
| /* Add the space for global non-register-stack registers. |
| It is assumed that the frame-pointer register can be one of these |
| registers, in which case it is excluded from the count when needed. */ |
| 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; |
| |
| /* Add in the space for register stack-pointer. If so, always add room |
| for the saved PC. */ |
| if (MMIX_CFUN_HAS_LANDING_PAD) |
| stack_space_to_deallocate += 16; |
| else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS) |
| /* If we have a saved return-address slot, add it in. */ |
| stack_space_to_deallocate += 8; |
| |
| /* Add in the frame-pointer. */ |
| if (frame_pointer_needed) |
| stack_space_to_deallocate += 8; |
| |
| /* Make sure we don't get an unaligned stack. */ |
| if ((stack_space_to_deallocate % 8) != 0) |
| internal_error ("stack frame not a multiple of octabyte: %d", |
| stack_space_to_deallocate); |
| |
| /* We will add back small offsets to the stack pointer as we go. |
| First, we restore all registers that are global, i.e. not saved by |
| the register file machinery. */ |
| |
| 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)) |
| { |
| empty_stack_frame = 0; |
| |
| if (offset > 255) |
| { |
| if (offset > 65535) |
| { |
| /* There's better support for incrementing than |
| decrementing, so we might be able to optimize this as |
| we see a need. */ |
| mmix_output_register_setting (stream, 255, offset, 1); |
| fprintf (stream, "\tADDU %s,%s,$255\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| else |
| fprintf (stream, "\tINCL %s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], offset); |
| |
| stack_space_to_deallocate -= offset; |
| offset = 0; |
| } |
| |
| fprintf (stream, "\tLDOU %s,%s,%d\n", |
| reg_names[regno], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset); |
| offset += 8; |
| } |
| |
| /* Here is where the local variables were. As in the prologue, they |
| might be of an unaligned size. */ |
| offset += (locals_size + 7) & ~7; |
| |
| |
| /* The saved register stack pointer is just below the frame-pointer |
| register. We don't need to restore it "manually"; the POP |
| instruction does that. */ |
| if (MMIX_CFUN_HAS_LANDING_PAD) |
| offset += 16; |
| else if (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS) |
| /* The return-address slot is just below the frame-pointer register. |
| We don't need to restore it because we don't really use it. */ |
| offset += 8; |
| |
| /* Get back the old frame-pointer-value. */ |
| if (frame_pointer_needed) |
| { |
| empty_stack_frame = 0; |
| |
| if (offset > 255) |
| { |
| if (offset > 65535) |
| { |
| /* There's better support for incrementing than |
| decrementing, so we might be able to optimize this as |
| we see a need. */ |
| mmix_output_register_setting (stream, 255, offset, 1); |
| fprintf (stream, "\tADDU %s,%s,$255\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| else |
| fprintf (stream, "\tINCL %s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], offset); |
| |
| stack_space_to_deallocate -= offset; |
| offset = 0; |
| } |
| |
| fprintf (stream, "\tLDOU %s,%s,%d\n", |
| reg_names[MMIX_FRAME_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| offset); |
| offset += 8; |
| } |
| |
| /* Do not deallocate the return-address slot if the stack frame is |
| empty, because then it was never allocated. */ |
| if (! empty_stack_frame) |
| { |
| /* We do not need to restore pretended incoming args, just add |
| back offset to sp. */ |
| if (stack_space_to_deallocate > 65535) |
| { |
| /* There's better support for incrementing than decrementing, so |
| we might be able to optimize this as we see a need. */ |
| mmix_output_register_setting (stream, 255, |
| stack_space_to_deallocate, 1); |
| fprintf (stream, "\tADDU %s,%s,$255\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| else |
| fprintf (stream, "\tINCL %s,%d\n", |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| stack_space_to_deallocate); |
| } |
| |
| if (current_function_calls_eh_return) |
| /* Adjustment the (normal) stack-pointer to that of the receiver. |
| FIXME: It would be nice if we could also adjust the register stack |
| here, but we need to express it through DWARF 2 too. */ |
| fprintf (stream, "\tADDU %s,%s,%s\n", |
| reg_names [MMIX_STACK_POINTER_REGNUM], |
| reg_names [MMIX_STACK_POINTER_REGNUM], |
| reg_names [MMIX_EH_RETURN_STACKADJ_REGNUM]); |
| |
| /* The extra \n is so we have a blank line between the assembly code of |
| separate functions. */ |
| fprintf (stream, "\tPOP %d,0\n\n", |
| (! 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); |
| } |
| |
| /* ASM_OUTPUT_MI_THUNK. */ |
| |
| void |
| mmix_asm_output_mi_thunk (stream, fndecl, delta, func) |
| FILE * stream; |
| tree fndecl ATTRIBUTE_UNUSED; |
| int delta; |
| tree func; |
| { |
| /* If you define STRUCT_VALUE to 0, rather than use STRUCT_VALUE_REGNUM, |
| (i.e. pass location of structure to return as invisible first |
| argument) you need to tweak this code too. */ |
| const char *regname = reg_names[MMIX_FIRST_INCOMING_ARG_REGNUM]; |
| |
| if (delta >= 0 && delta < 65536) |
| asm_fprintf (stream, "\tINCL %s,%d\n", delta, regname); |
| else if (delta < 0 && delta >= -255) |
| asm_fprintf (stream, "\tSUBU %s,%s,%d\n", regname, regname, -delta); |
| else |
| { |
| mmix_output_register_setting (stream, 255, delta, 1); |
| asm_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"); |
| } |
| |
| /* FUNCTION_PROFILER. */ |
| |
| void |
| mmix_function_profiler (stream, labelno) |
| FILE *stream ATTRIBUTE_UNUSED; |
| int labelno ATTRIBUTE_UNUSED; |
| { |
| sorry ("function_profiler support for MMIX"); |
| } |
| |
| /* SETUP_INCOMING_VARARGS. */ |
| |
| 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; |
| { |
| /* For stdarg, the last named variable has been handled, but |
| args_so_farp has not been advanced for it. For varargs, the current |
| argument is to be counted to the anonymous ones. */ |
| if (current_function_stdarg) |
| { |
| if (args_so_farp->regs + 1 < MMIX_MAX_ARGS_IN_REGS) |
| *pretend_sizep |
| = (MMIX_MAX_ARGS_IN_REGS - (args_so_farp->regs + 1)) * 8; |
| } |
| else if (current_function_varargs) |
| { |
| if (args_so_farp->regs < MMIX_MAX_ARGS_IN_REGS) |
| *pretend_sizep |
| = (MMIX_MAX_ARGS_IN_REGS - args_so_farp->regs) * 8; |
| |
| /* For varargs, we get here when we see the last named parameter, |
| which will actually be passed on stack. So make the next call |
| (there will be one) to FUNCTION_ARG return 0, to count it on |
| stack, so va_arg for it will get right. FIXME: The GCC core |
| should provide TRT. */ |
| args_so_farp->now_varargs = 1; |
| } |
| else |
| internal_error ("neither varargs or stdarg in mmix_setup_incoming_varargs"); |
| |
| |
| /* We assume that one argument takes up one register here. That should |
| be true until we start messing with multi-reg parameters. */ |
| if ((7 + (MMIX_FUNCTION_ARG_SIZE (mode, vartype))) / 8 != 1) |
| internal_error ("MMIX Internal: Last named vararg would not fit in a register"); |
| } |
| |
| /* EXPAND_BUILTIN_VA_ARG. */ |
| |
| /* This is modified from the "standard" implementation of va_arg: read the |
| value from the current (padded) address and increment by the (padded) |
| size. The difference for MMIX is that if the type is |
| pass-by-reference, then perform an indirection. */ |
| |
| rtx |
| mmix_expand_builtin_va_arg (valist, type) |
| tree valist; |
| tree type; |
| { |
| tree addr_tree, t; |
| HOST_WIDE_INT align; |
| HOST_WIDE_INT rounded_size; |
| rtx addr; |
| |
| /* Compute the rounded size of the type. */ |
| align = PARM_BOUNDARY / BITS_PER_UNIT; |
| rounded_size = (((int_size_in_bytes (type) + align - 1) / align) * align); |
| |
| /* Get AP. */ |
| addr_tree = valist; |
| |
| if (AGGREGATE_TYPE_P (type) |
| && GET_MODE_UNIT_SIZE (TYPE_MODE (type)) < 8 |
| && GET_MODE_UNIT_SIZE (TYPE_MODE (type)) != 0) |
| { |
| /* Adjust for big-endian the location of aggregates passed in a |
| register, but where the aggregate is accessed in a shorter mode |
| than the natural register mode (i.e. it is accessed as SFmode(?), |
| SImode, HImode or QImode rather than DImode or DFmode(?)). FIXME: |
| Or should we adjust the mode in which the aggregate is read, to be |
| a register size mode? (Hum, nah, a small offset is generally |
| cheaper than a wider memory access on MMIX.) */ |
| addr_tree |
| = build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree, |
| build_int_2 ((BITS_PER_WORD / BITS_PER_UNIT) |
| - GET_MODE_UNIT_SIZE (TYPE_MODE (type)), 0)); |
| } |
| else |
| { |
| HOST_WIDE_INT adj; |
| adj = TREE_INT_CST_LOW (TYPE_SIZE (type)) / BITS_PER_UNIT; |
| if (rounded_size > align) |
| adj = rounded_size; |
| |
| addr_tree = build (PLUS_EXPR, TREE_TYPE (addr_tree), addr_tree, |
| build_int_2 (rounded_size - adj, 0)); |
| |
| /* If this type is larger than what fits in a register, then it is |
| passed by reference. */ |
| if (rounded_size > BITS_PER_WORD / BITS_PER_UNIT) |
| { |
| tree type_ptr = build_pointer_type (type); |
| addr_tree = build1 (INDIRECT_REF, type_ptr, addr_tree); |
| } |
| } |
| |
| addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL); |
| addr = copy_to_reg (addr); |
| |
| /* Compute new value for AP. For MMIX, it is always advanced by the |
| size of a register. */ |
| t = build (MODIFY_EXPR, TREE_TYPE (valist), valist, |
| build (PLUS_EXPR, TREE_TYPE (valist), valist, |
| build_int_2 (BITS_PER_WORD / BITS_PER_UNIT, 0))); |
| TREE_SIDE_EFFECTS (t) = 1; |
| expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL); |
| |
| return addr; |
| } |
| |
| /* TRAMPOLINE_SIZE. */ |
| /* Four 4-byte insns plus two 8-byte values. */ |
| int mmix_trampoline_size = 32; |
| |
| |
| /* TRAMPOLINE_TEMPLATE. */ |
| |
| void |
| mmix_trampoline_template (stream) |
| FILE * stream; |
| { |
| /* Read a value from to static-chain, jump somewhere. The static chain |
| is stored at offset 16, and the function address is stored at offset |
| 24. */ |
| /* FIXME: GCC copies this using *intsize* (tetra), when it should use |
| register size (octa). */ |
| 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"); |
| } |
| |
| /* INITIALIZE_TRAMPOLINE. */ |
| /* Set the static chain and function pointer field in the trampoline. |
| We also SYNCID here to be sure (doesn't matter in the simulator, but |
| some day it will). */ |
| |
| 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))); |
| } |
| |
| /* We must exclude constant addresses that have an increment that is not a |
| multiple of four bytes because of restrictions of the GETA |
| instruction. FIXME: No, I don't think so. Just add a constraint. */ |
| |
| int |
| mmix_constant_address_p (x) |
| rtx x; |
| { |
| RTX_CODE code = GET_CODE (x); |
| int addend = 0; |
| |
| if (code == LABEL_REF || code == SYMBOL_REF) |
| return 1; |
| |
| if (code == CONSTANT_P_RTX || code == HIGH) |
| /* FIXME: Don't know how to dissect these. Avoid them for now. */ |
| return 0; |
| |
| switch (code) |
| { |
| case LABEL_REF: |
| case SYMBOL_REF: |
| return 1; |
| |
| case PLUS: |
| /* Can we get a naked PLUS? */ |
| case CONSTANT_P_RTX: |
| case HIGH: |
| /* FIXME: Don't know how to dissect these. Avoid them for now. */ |
| return 0; |
| |
| case CONST_INT: |
| addend = INTVAL (x); |
| break; |
| |
| case CONST_DOUBLE: |
| if (GET_MODE (x) != VOIDmode) |
| /* Strange that we got here. FIXME: Check if we do. */ |
| return 0; |
| addend = CONST_DOUBLE_LOW (x); |
| break; |
| |
| case CONST: |
| /* Note that expressions with arithmetic on forward references don't |
| work in mmixal. People using gcc assembly code with mmixal might |
| need to move arrays and such to before the point of use. */ |
| 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 0; |
| } |
| else |
| return 0; |
| break; |
| |
| default: |
| return 0; |
| } |
| |
| return (addend & 3) == 0; |
| } |
| |
| /* Return 1 if the address is OK, otherwise 0. |
| Used by GO_IF_LEGITIMATE_ADDRESS. */ |
| |
| 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))) |
| |
| /* We only accept: |
| (mem reg) |
| (mem (plus reg reg)) |
| (mem (plus reg 0..255)). */ |
| |
| |
| /* (mem reg) */ |
| 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); |
| |
| /* Try swapping the order. FIXME: Do we need this? */ |
| if (! REG_P (x1)) |
| { |
| rtx tem = x1; |
| x1 = x2; |
| x2 = tem; |
| } |
| |
| /* (mem (plus (reg) (?))) */ |
| if (!REG_P (x1) || !MMIX_REG_OK (x1)) |
| return 0; |
| |
| /* (mem (plus (reg) (reg))) */ |
| if (REG_P (x2) && MMIX_REG_OK (x2)) |
| return 1; |
| |
| /* (mem (plus (reg) (0..255))) */ |
| if (GET_CODE (x2) == CONST_INT |
| && CONST_OK_FOR_LETTER_P (INTVAL (x2), 'I')) |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| /* LEGITIMATE_CONSTANT_P. */ |
| |
| int |
| mmix_legitimate_constant_p (x) |
| rtx x; |
| { |
| RTX_CODE code = GET_CODE (x); |
| |
| /* We must allow any number due to the way the cse passes works; if we |
| do not allow any number here, general_operand will fail, and insns |
| will fatally fail recognition instead of "softly". */ |
| if (code == CONST_INT || code == CONST_DOUBLE) |
| return 1; |
| |
| return CONSTANT_ADDRESS_P (x); |
| } |
| |
| /* SELECT_CC_MODE. */ |
| |
| enum machine_mode |
| mmix_select_cc_mode (op, x, y) |
| RTX_CODE op; |
| rtx x; |
| rtx y ATTRIBUTE_UNUSED; |
| { |
| /* We use CCmode, CC_UNSmode, CC_FPmode, CC_FPEQmode and CC_FUNmode to |
| output different compare insns. Note that we do not check the |
| validity of the comparison here. */ |
| |
| 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; |
| } |
| |
| /* CANONICALIZE_COMPARISON. |
| FIXME: Check if the number adjustments trig. */ |
| |
| void |
| mmix_canonicalize_comparison (codep, op0p, op1p) |
| RTX_CODE * codep; |
| rtx * op0p ATTRIBUTE_UNUSED; |
| rtx * op1p; |
| { |
| /* Change -1 to zero, if possible. */ |
| if ((*codep == LE || *codep == GT) |
| && GET_CODE (*op1p) == CONST_INT |
| && *op1p == constm1_rtx) |
| { |
| *codep = *codep == LE ? LT : GE; |
| *op1p = const0_rtx; |
| } |
| |
| /* Fix up 256 to 255, if possible. */ |
| if ((*codep == LT || *codep == LTU || *codep == GE || *codep == GEU) |
| && GET_CODE (*op1p) == CONST_INT |
| && INTVAL (*op1p) == 256) |
| { |
| /* FIXME: Remove when I know this trigs. */ |
| fatal_insn ("oops, not debugged; fixing up value:", *op1p); |
| *codep = *codep == LT ? LE : *codep == LTU ? LEU : *codep |
| == GE ? GT : GTU; |
| *op1p = GEN_INT (255); |
| } |
| } |
| |
| /* REVERSIBLE_CC_MODE. */ |
| |
| int |
| mmix_reversible_cc_mode (mode) |
| enum machine_mode mode; |
| { |
| /* That is, all integer and the EQ, NE, ORDERED and UNORDERED float |
| cmpares. */ |
| return mode != CC_FPmode; |
| } |
| |
| /* DEFAULT_RTX_COSTS. */ |
| |
| 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; |
| { |
| /* For the time being, this is just a stub and we'll accept the |
| generic calculations, until we can do measurements, at least. |
| Say we did not modify any calculated costs. */ |
| return 0; |
| } |
| |
| /* ADDRESS_COST. */ |
| |
| int |
| mmix_address_cost (addr) |
| rtx addr ATTRIBUTE_UNUSED; |
| { |
| /* There's no difference in the address costs and we have lots of |
| registers. Some targets use constant 0, many others use 1 to say |
| this. Let's start with 1. */ |
| return 1; |
| } |
| |
| /* REGISTER_MOVE_COST. */ |
| |
| 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; |
| } |
| |
| /* Note that we don't have a TEXT_SECTION_ASM_OP, because it has to be a |
| compile-time constant; it's used in an asm in crtstuff.c, compiled for |
| the target. */ |
| |
| /* DATA_SECTION_ASM_OP. */ |
| |
| const char * |
| mmix_data_section_asm_op () |
| { |
| return "\t.data ! mmixal:= 8H LOC 9B"; |
| } |
| |
| /* SELECT_SECTION. |
| The meat is from elfos.h, which we will eventually consider using. */ |
| |
| void |
| mmix_select_section (decl, reloc, align) |
| tree decl; |
| int reloc; |
| int align ATTRIBUTE_UNUSED; |
| { |
| if (TREE_CODE (decl) == STRING_CST) |
| { |
| if (! flag_writable_strings) |
| const_section (); |
| else |
| data_section (); |
| } |
| else if (TREE_CODE (decl) == VAR_DECL) |
| { |
| if ((flag_pic && reloc) |
| || !TREE_READONLY (decl) || TREE_SIDE_EFFECTS (decl) |
| || !DECL_INITIAL (decl) |
| || (DECL_INITIAL (decl) != error_mark_node |
| && !TREE_CONSTANT (DECL_INITIAL (decl)))) |
| data_section (); |
| else |
| const_section (); |
| } |
| else if (TREE_CODE (decl) == CONSTRUCTOR) |
| { |
| if ((flag_pic && reloc) |
| || !TREE_READONLY (decl) || TREE_SIDE_EFFECTS (decl) |
| || ! TREE_CONSTANT (decl)) |
| data_section (); |
| else |
| const_section (); |
| } |
| else |
| const_section (); |
| } |
| |
| /* ENCODE_SECTION_INFO. */ |
| |
| void |
| mmix_encode_section_info (decl) |
| tree decl; |
| { |
| /* Test for an external declaration, and do nothing if it is one. */ |
| if ((TREE_CODE (decl) == VAR_DECL |
| && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl)) |
| && ! TREE_STATIC (decl)) |
| || (TREE_CODE (decl) == FUNCTION_DECL |
| && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl)))) |
| ; |
| else if (DECL_P (decl)) |
| { |
| /* For non-visible declarations, add a "@" prefix, which we skip |
| when the label is output. If the label does not have this |
| prefix, a ":" is output. |
| |
| Note that this does not work for data that is declared extern and |
| later defined as static. If there's code in between, that code |
| will refer to the extern declaration. And vice versa. Until we |
| can get rid of mmixal, we have to assume that code is well-behaved |
| or come up with a contorted scheme to work around bad code. */ |
| |
| const char *str = XSTR (XEXP (DECL_RTL (decl), 0), 0); |
| int len = strlen (str); |
| char *newstr; |
| |
| /* Doing as rs6000 seems safe; always use ggc. Except don't copy |
| the suspected off-by-one bug. |
| FIXME: Is it still there? yes 2001-08-23 |
| Why is the return type of ggc_alloc_string const? */ |
| newstr = (char *) ggc_alloc_string ("", len + 2); |
| |
| strcpy (newstr + 1, str); |
| *newstr = '@'; |
| XSTR (XEXP (DECL_RTL (decl), 0), 0) = newstr; |
| } |
| |
| /* FIXME: Later on, add SYMBOL_REF_FLAG for things that we can reach |
| from here via GETA, to check in LEGITIMATE_CONSTANT_P. Needs to have |
| different options for the cases where we want *all* to be assumed |
| reachable via GETA, or all constant symbols, or just text symbols in |
| this file, or perhaps just the constant pool. */ |
| } |
| |
| /* STRIP_NAME_ENCODING. */ |
| |
| const char * |
| mmix_strip_name_encoding (name) |
| const char *name; |
| { |
| for (; (*name == '@' || *name == '*'); name++) |
| ; |
| |
| return name; |
| } |
| |
| /* UNIQUE_SECTION. |
| The meat is from elfos.h, which we should consider using. */ |
| |
| void |
| mmix_unique_section (decl, reloc) |
| tree decl; |
| int reloc; |
| { |
| int len; |
| int sec; |
| const char *name; |
| char *string; |
| const char *prefix; |
| static const char *const prefixes[4][2] = |
| { |
| { ".text.", ".gnu.linkonce.t." }, |
| { ".rodata.", ".gnu.linkonce.r." }, |
| { ".data.", ".gnu.linkonce.d." }, |
| { ".bss.", ".gnu.linkonce.b." } |
| }; |
| |
| if (TREE_CODE (decl) == FUNCTION_DECL) |
| sec = 0; |
| else if (DECL_INITIAL (decl) == 0 |
| || DECL_INITIAL (decl) == error_mark_node) |
| sec = 3; |
| else if (DECL_READONLY_SECTION (decl, reloc)) |
| sec = 1; |
| else |
| sec = 2; |
| |
| name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); |
| /* Strip off any encoding in name. */ |
| STRIP_NAME_ENCODING (name, name); |
| prefix = prefixes[sec][DECL_ONE_ONLY (decl)]; |
| len = strlen (name) + strlen (prefix); |
| string = alloca (len + 1); |
| |
| sprintf (string, "%s%s", prefix, name); |
| |
| DECL_SECTION_NAME (decl) = build_string (len, string); |
| } |
| |
| /* ASM_FILE_START. */ |
| |
| void |
| mmix_asm_file_start (stream) |
| FILE * stream; |
| { |
| /* We just emit a little comment for the time being. FIXME: Perhaps add |
| -mstandalone and some segment and prefix setup here. */ |
| ASM_OUTPUT_SOURCE_FILENAME (stream, main_input_filename); |
| |
| fprintf (stream, "! mmixal:= 8H LOC Data_Section\n"); |
| |
| /* Make sure each file starts with the text section. */ |
| text_section (); |
| } |
| |
| /* ASM_FILE_END. */ |
| |
| void |
| mmix_asm_file_end (stream) |
| FILE * stream ATTRIBUTE_UNUSED; |
| { |
| /* Make sure each file ends with the data section. */ |
| data_section (); |
| } |
| |
| /* ASM_IDENTIFY_GCC. */ |
| |
| void |
| mmix_asm_identify_gcc (stream) |
| FILE * stream; |
| { |
| /* No real need for the time being. May be useful to GDB later on. */ |
| fprintf (stream, "# Compiled by GCC version %s\n", |
| version_string); |
| } |
| |
| /* ASM_OUTPUT_SOURCE_FILENAME. */ |
| |
| void |
| mmix_asm_output_source_filename (stream, name) |
| FILE * stream; |
| const char * name; |
| { |
| fprintf (stream, "# 1 "); |
| OUTPUT_QUOTED_STRING (stream, name); |
| fprintf (stream, "\n"); |
| } |
| |
| /* OUTPUT_QUOTED_STRING. */ |
| |
| 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 = "\"[]\\"; |
| |
| /* Output "any character except newline and double quote character". We |
| play it safe and avoid all control characters too. We also do not |
| want [] as characters, should input be passed through m4 with [] as |
| quotes. Further, we avoid "\", because the GAS port handles it as a |
| quoting character. */ |
| 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, ","); |
| } |
| } |
| } |
| |
| /* ASM_OUTPUT_SOURCE_LINE. */ |
| |
| 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"); |
| } |
| |
| /* ASM_OUTPUT_DOUBLE. */ |
| |
| void |
| mmix_asm_output_double (stream, valuep) |
| FILE * stream; |
| REAL_VALUE_TYPE * valuep; |
| { |
| unsigned long bits[2]; |
| HOST_WIDEST_INT value; |
| |
| REAL_VALUE_TO_TARGET_DOUBLE (*valuep, (long *) bits); |
| value |
| = (((HOST_WIDEST_INT) bits[0]) << 32) | (HOST_WIDEST_INT) bits[1]; |
| mmix_output_octa (stream, value, 1); |
| } |
| |
| /* ASM_OUTPUT_FLOAT. */ |
| |
| void |
| mmix_asm_output_float (stream, valuep) |
| FILE * stream; |
| REAL_VALUE_TYPE * valuep; |
| { |
| unsigned long bits; |
| |
| REAL_VALUE_TO_TARGET_SINGLE (*valuep, bits); |
| |
| fprintf (stream, "\tTETRA #%lx\n", |
| (unsigned long) (bits |
| & (((unsigned HOST_WIDEST_INT) (1 << 31) - 1) * 2 |
| + 1))); |
| } |
| |
| /* Target hook for assembling integer objects. Use mmix_print_operand |
| for WYDE and TETRA. Use mmix_output_octa to output 8-byte |
| CONST_DOUBLEs. */ |
| |
| static bool |
| mmix_assemble_integer (x, size, aligned_p) |
| rtx x; |
| unsigned int size; |
| int aligned_p; |
| { |
| if (aligned_p) |
| switch (size) |
| { |
| case 1: |
| fputs ("\tBYTE\t", asm_out_file); |
| mmix_print_operand (asm_out_file, x, 'B'); |
| fputc ('\n', asm_out_file); |
| return true; |
| |
| case 2: |
| fputs ("\tWYDE\t", asm_out_file); |
| mmix_print_operand (asm_out_file, x, 'W'); |
| fputc ('\n', asm_out_file); |
| return true; |
| |
| case 4: |
| 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) |
| mmix_output_octa (asm_out_file, mmix_intval (x), 0); |
| else |
| assemble_integer_with_op ("\tOCTA\t", x); |
| return true; |
| } |
| return default_assemble_integer (x, size, aligned_p); |
| } |
| |
| /* ASM_OUTPUT_ASCII. */ |
| |
| 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"); |
| } |
| } |
| |
| /* ASM_OUTPUT_ALIGNED_COMMON. */ |
| |
| void |
| mmix_asm_output_aligned_common (stream, name, size, align) |
| FILE *stream; |
| const char *name; |
| int size; |
| int align; |
| { |
| /* This is mostly the elfos.h one. There doesn't seem to be a way to |
| express this in a mmixal-compatible way. */ |
| fprintf (stream, "\t.comm\t"); |
| assemble_name (stream, name); |
| fprintf (stream, ",%u,%u ! mmixal-incompatible COMMON\n", |
| size, align / BITS_PER_UNIT); |
| } |
| |
| /* ASM_OUTPUT_ALIGNED_LOCAL. */ |
| |
| 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); |
| } |
| |
| /* ASM_OUTPUT_LABEL. */ |
| |
| void |
| mmix_asm_output_label (stream, name) |
| FILE *stream; |
| const char * name; |
| { |
| assemble_name (stream, name); |
| fprintf (stream, "\tIS @\n"); |
| } |
| |
| /* ASM_DECLARE_REGISTER_GLOBAL. */ |
| |
| 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; |
| { |
| /* Nothing to do here, but there *will* be, therefore the framework is |
| here. */ |
| } |
| |
| /* ASM_GLOBALIZE_LABEL. */ |
| |
| void |
| mmix_asm_globalize_label (stream, name) |
| FILE * stream ATTRIBUTE_UNUSED; |
| const char * name ATTRIBUTE_UNUSED; |
| { |
| asm_fprintf (stream, "\t.global "); |
| assemble_name (stream, name); |
| putc ('\n', stream); |
| } |
| |
| /* ASM_WEAKEN_LABEL. */ |
| |
| void |
| mmix_asm_weaken_label (stream, name) |
| FILE * stream ATTRIBUTE_UNUSED; |
| const char * name ATTRIBUTE_UNUSED; |
| { |
| asm_fprintf (stream, "\t.weak "); |
| assemble_name (stream, name); |
| asm_fprintf (stream, " ! mmixal-incompatible\n"); |
| } |
| |
| /* MAKE_DECL_ONE_ONLY. */ |
| |
| void |
| mmix_make_decl_one_only (decl) |
| tree decl; |
| { |
| DECL_WEAK (decl) = 1; |
| } |
| |
| /* ASM_OUTPUT_LABELREF. |
| Strip GCC's '*' and our own '@'. No order is assumed. */ |
| |
| void |
| mmix_asm_output_labelref (stream, name) |
| FILE *stream; |
| const char *name; |
| { |
| int is_extern = 0; |
| |
| for (; (*name == '@' || *name == '*'); name++) |
| if (*name == '@') |
| is_extern = 1; |
| |
| asm_fprintf (stream, "%s%U%s", |
| is_extern && TARGET_TOPLEVEL_SYMBOLS ? ":" : "", |
| name); |
| } |
| |
| /* ASM_OUTPUT_INTERNAL_LABEL. */ |
| |
| void |
| mmix_asm_output_internal_label (stream, name, num) |
| FILE * stream; |
| const char * name; |
| int num; |
| { |
| fprintf (stream, "%s:%d\tIS @\n", name, num); |
| } |
| |
| /* ASM_OUTPUT_DEF. */ |
| |
| 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); |
| } |
| |
| /* ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL. */ |
| |
| void |
| mmix_asm_output_define_label_difference_symbol (stream, symbol, hi, lo) |
| FILE *stream; |
| const char *symbol; |
| const char *hi; |
| const char *lo; |
| { |
| assemble_name (stream, symbol); |
| fprintf (stream, "\tIS\t"); |
| assemble_name (stream, hi); |
| fputc ('-', stream); |
| assemble_name (stream, lo); |
| fprintf (stream, "\n"); |
| } |
| |
| /* PRINT_OPERAND. */ |
| |
| void |
| mmix_print_operand (stream, x, code) |
| FILE * stream; |
| rtx x; |
| int code; |
| { |
| /* When we add support for different codes later, we can, when needed, |
| drop through to the main handler with a modified operand. */ |
| rtx modified_x = x; |
| |
| switch (code) |
| { |
| /* Unrelated codes are in alphabetic order. */ |
| |
| 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': |
| /* Highpart. Must be general register, and not the last one, as |
| that one cannot be part of a consecutive register pair. */ |
| if (REGNO (x) > MMIX_LAST_GENERAL_REGISTER - 1) |
| internal_error ("MMIX Internal: Bad register: %d", REGNO (x)); |
| |
| /* This is big-endian, so the high-part is the first one. */ |
| fprintf (stream, "%s", reg_names[REGNO (x)]); |
| return; |
| |
| case 'L': |
| /* Lowpart. Must be CONST_INT or general register, and not the last |
| one, as that one cannot be part of a consecutive register pair. */ |
| 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 (x) > MMIX_LAST_GENERAL_REGISTER - 1) |
| internal_error ("MMIX Internal: Bad register: %d", REGNO (x)); |
| |
| /* This is big-endian, so the low-part is + 1. */ |
| fprintf (stream, "%s", reg_names[REGNO (x) + 1]); |
| return; |
| |
| /* Can't use 'a' because that's a generic modifier for address |
| output. */ |
| 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': |
| /* Output an extra "e" to make fcmpe, fune. */ |
| if (TARGET_FCMP_EPSILON) |
| fprintf (stream, "e"); |
| return; |
| |
| case 'm': |
| /* Output the number minus 1. */ |
| 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': |
| /* Store the number of registers we want to save. This was setup |
| by the prologue. The actual operand contains the number of |
| registers to pass, but we don't use it currently. Anyway, we |
| need to output the number of saved registers here. */ |
| if (TARGET_ABI_GNU) |
| fprintf (stream, "%d", mmix_highest_saved_stack_register + 1); |
| else |
| /* FIXME: Get the effect of renaming $16, $17.. to the first |
| unused call-saved reg. */ |
| fprintf (stream, "15"); |
| return; |
| |
| case 'r': |
| /* Store the register to output a constant to. */ |
| if (! REG_P (x)) |
| fatal_insn ("MMIX Internal: Expected a register, not this", x); |
| mmix_output_destination_register = REGNO (x); |
| return; |
| |
| case 'I': |
| /* Output the constant. Note that we use this for floats as well. */ |
| 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': |
| /* An U for unsigned, if TARGET_ZERO_EXTEND. Ignore the operand. */ |
| 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: |
| /* Nothing to do. */ |
| break; |
| |
| default: |
| /* Presumably there's a missing case above if we get here. */ |
| internal_error ("MMIX Internal: Missing `%c' case in mmix_print_operand", code); |
| } |
| |
| switch (GET_CODE (modified_x)) |
| { |
| case REG: |
| if (REGNO (modified_x) >= FIRST_PSEUDO_REGISTER) |
| internal_error ("MMIX Internal: Bad register: %d", REGNO (modified_x)); |
| fprintf (stream, "%s", reg_names[REGNO (modified_x)]); |
| return; |
| |
| case MEM: |
| output_address (XEXP (modified_x, 0)); |
| return; |
| |
| case CONST_INT: |
| /* For -2147483648, mmixal complains that the constant does not fit |
| in 4 bytes, so let's output it as hex. Take care to handle hosts |
| where HOST_WIDE_INT is longer than an int. |
| |
| Print small constants +-255 using decimal. */ |
| |
| 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: |
| /* Do somewhat as CONST_INT. */ |
| mmix_output_octa (stream, mmix_intval (modified_x), 0); |
| return; |
| |
| case CONST: |
| output_addr_const (stream, modified_x); |
| return; |
| |
| default: |
| /* No need to test for all strange things. Let output_addr_const do |
| it for us. */ |
| if (CONSTANT_P (modified_x) |
| /* Strangely enough, this is not included in CONSTANT_P. |
| FIXME: Ask/check about sanity here. */ |
| || GET_CODE (modified_x) == CODE_LABEL) |
| { |
| output_addr_const (stream, modified_x); |
| return; |
| } |
| |
| /* We need the original here. */ |
| fatal_insn ("MMIX Internal: Cannot decode this operand", x); |
| } |
| } |
| |
| /* PRINT_OPERAND_PUNCT_VALID_P. */ |
| |
| int |
| mmix_print_operand_punct_valid_p (code) |
| int code ATTRIBUTE_UNUSED; |
| { |
| /* None at the moment. */ |
| return 0; |
| } |
| |
| /* PRINT_OPERAND_ADDRESS. */ |
| |
| void |
| mmix_print_operand_address (stream, x) |
| FILE *stream; |
| rtx x; |
| { |
| if (REG_P (x)) |
| { |
| /* I find the generated assembly code harder to read without |
| the ",0". */ |
| fprintf (stream, "%s,0",reg_names[REGNO (x)]); |
| return; |
| } |
| else if (GET_CODE (x) == PLUS) |
| { |
| rtx x1 = XEXP (x, 0); |
| rtx x2 = XEXP (x, 1); |
| |
| /* Try swap the order. FIXME: Do we need this? */ |
| if (! REG_P (x1)) |
| { |
| rtx tem = x1; |
| x1 = x2; |
| x2 = tem; |
| } |
| |
| if (REG_P (x1)) |
| { |
| fprintf (stream, "%s,", reg_names[REGNO (x1)]); |
| |
| if (REG_P (x2)) |
| { |
| fprintf (stream, "%s", reg_names[REGNO (x2)]); |
| return; |
| } |
| else if (GET_CODE (x2) == CONST_INT |
| && CONST_OK_FOR_LETTER_P (INTVAL (x2), 'I')) |
| { |
| output_addr_const (stream, x2); |
| return; |
| } |
| } |
| } |
| |
| fatal_insn ("MMIX Internal: This is not a recognized address", x); |
| } |
| |
| /* ASM_OUTPUT_REG_PUSH. */ |
| |
| 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[regno], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| |
| /* ASM_OUTPUT_REG_POP. */ |
| |
| 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[regno], |
| reg_names[MMIX_STACK_POINTER_REGNUM], |
| reg_names[MMIX_STACK_POINTER_REGNUM]); |
| } |
| |
| /* ASM_OUTPUT_ADDR_DIFF_ELT. */ |
| |
| 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); |
| } |
| |
| /* ASM_OUTPUT_ADDR_VEC_ELT. */ |
| |
| void |
| mmix_asm_output_addr_vec_elt (stream, value) |
| FILE *stream; |
| int value; |
| { |
| fprintf (stream, "\tOCTA L:%d\n", value); |
| } |
| |
| /* ASM_OUTPUT_SKIP. */ |
| |
| void |
| mmix_asm_output_skip (stream, nbytes) |
| FILE *stream; |
| int nbytes; |
| { |
| fprintf (stream, "\tLOC @+%d\n", nbytes); |
| } |
| |
| /* ASM_OUTPUT_ALIGN. */ |
| |
| void |
| mmix_asm_output_align (stream, power) |
| FILE *stream; |
| int power; |
| { |
| /* We need to record the needed alignment of this section in the object, |
| so we have to output an alignment directive. Use a .p2align (not |
| .align) so people will never have to wonder about whether the |
| argument is in number of bytes or the log2 thereof. We do it in |
| addition to the LOC directive, so nothing needs tweaking when |
| copy-pasting assembly into mmixal. */ |
| fprintf (stream, "\t.p2align %d\n", power); |
| fprintf (stream, "\tLOC @+(%d-@)&%d\n", 1 << power, (1 << power) - 1); |
| } |
| |
| /* DBX_REGISTER_NUMBER. */ |
| |
| int |
| mmix_dbx_register_number (regno) |
| int regno; |
| { |
| /* FIXME: Implement final register renumbering if necessary. (Use |
| target state in cfun). */ |
| |
| /* We need to renumber registers to get the number of the return address |
| register in the range 0..255. It is also space-saving if registers |
| mentioned in the call-frame information (which uses this function by |
| defaulting DWARF_FRAME_REGNUM to DBX_REGISTER_NUMBER) are numbered |
| 0 .. 63. So map 224 .. 256+15 -> 0 .. 47 and 0 .. 223 -> 48..223+48. */ |
| return regno >= 224 ? (regno - 224) : (regno + 48); |
| } |
| |
| /* End of target macro support functions. |
| |
| Now MMIX's own functions. First the exported ones. */ |
| |
| /* Output an optimal sequence for setting a register to a specific |
| constant. Used in an alternative for const_ints in movdi, and when |
| using large stack-frame offsets. |
| |
| Use do_begin_end to say if a line-starting TAB and newline before the |
| first insn and after the last insn is wanted. */ |
| |
| 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)) |
| { |
| /* First, the one-insn cases. */ |
| 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)) |
| { |
| /* We do this to get a bit more legible assembly code. The next |
| alternative is mostly redundant with this. */ |
| |
| 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)) |
| { |
| /* Slightly more expensive, the two-insn cases. */ |
| |
| /* FIXME: We could of course also test if 0..255-N or ~(N | 1..255) |
| is shiftable, or any other one-insn transformation of the value. |
| FIXME: Check first if the value is "shiftable" by two loading |
| with two insns, since it makes more readable assembly code (if |
| anyone else cares). */ |
| |
| 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 |
| { |
| /* The generic case. 2..4 insns. */ |
| static const char *const higher_parts[] = {"L", "ML", "MH", "H"}; |
| const char *op = "SET"; |
| const char *line_begin = ""; |
| int i; |
| |
| /* Output pertinent parts of the 4-wyde sequence. |
| Still more to do if we want this to be optimal, but hey... |
| Note that the zero case has been handled above. */ |
| 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)); |
| /* The first one sets the rest of the bits to 0, the next |
| ones add set bits. */ |
| op = "INC"; |
| line_begin = "\n\t"; |
| } |
| |
| value >>= 16; |
| } |
| } |
| |
| if (do_begin_end) |
| fprintf (stream, "\n"); |
| } |
| |
| /* Return 1 if value is 0..65535*2**(16*N) for N=0..3. |
| else return 0. */ |
| |
| int |
| mmix_shiftable_wyde_value (value) |
| unsigned HOST_WIDEST_INT value; |
| { |
| /* Shift by 16 bits per group, stop when we've found two groups with |
| nonzero bits. */ |
| 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; |
| } |
| |
| /* True if this is an address_operand or a symbolic operand. */ |
| |
| 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; |
| /* FALLTHROUGH */ |
| default: |
| return address_operand (op, mode); |
| } |
| } |
| |
| /* True if this is a register or CONST_INT (or CONST_DOUBLE for DImode). |
| We could narrow the value down with a couple of predicated, but that |
| doesn't seem to be worth it at the moment. */ |
| |
| 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; |
| } |
| |
| /* True if this is a register with a condition-code mode. */ |
| |
| 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); |
| } |
| |
| /* True if this is a foldable comparison operator |
| - one where a the result of (compare:CC (reg) (const_int 0)) can be |
| replaced by (reg). */ |
| |
| 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)) |
| /* FIXME: This may be a stupid trick. What happens when GCC wants to |
| reverse the condition? Can it do that by itself? Maybe it can |
| even reverse the condition to fit a foldable one in the first |
| place? */ |
| || (mode == CC_UNSmode && (code == GTU || code == LEU)); |
| } |
| |
| /* Like comparison_operator, but only true if this comparison operator is |
| applied to a valid mode. Needed to avoid jump.c generating invalid |
| code with -ffast-math (gcc.dg/20001228-1.c). */ |
| |
| int |
| mmix_comparison_operator (op, mode) |
| rtx op; |
| enum machine_mode mode; |
| { |
| RTX_CODE code = GET_CODE (op); |
| |
| /* Comparison operators usually don't have a mode, but let's try and get |
| one anyway for the day that changes. */ |
| if (mode == VOIDmode) |
| mode = GET_MODE (op); |
| |
| /* Get the mode from the first operand if we don't have one. */ |
| if (mode == VOIDmode && GET_RTX_CLASS (GET_CODE (op)) == '<') |
| mode = GET_MODE (XEXP (op, 0)); |
| |
| /* FIXME: This needs to be kept in sync with the tables in |
| mmix_output_condition. */ |
| 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)); |
| } |
| |
| /* True if this is a register or 0 (int or float). */ |
| |
| int |
| mmix_reg_or_0_operand (op, mode) |
| rtx op; |
| enum machine_mode mode; |
| { |
| /* FIXME: Is mode calculation necessary and correct? */ |
| return |
| op == CONST0_RTX (mode == VOIDmode ? GET_MODE (op) : mode) |
| || register_operand (op, mode); |
| } |
| |
| /* True if this is a register or an int 0..255. */ |
| |
| 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')); |
| } |
| |
| /* True if this is a register or an int 0..256. We include 256, |
| because it can be canonicalized into 255 for comparisons, which is |
| currently the only use of this predicate. |
| FIXME: Check that this happens and does TRT. */ |
| |
| int |
| mmix_reg_or_8bit_or_256_operand (op, mode) |
| rtx op; |
| enum machine_mode mode; |
| { |
| return mmix_reg_or_8bit_operand (op, mode) |
| || (GET_CODE (op) == CONST_INT && INTVAL (op) == 256); |
| } |
| |
| /* Returns zero if code and mode is not a valid condition from a |
| compare-type insn. Nonzero if it is. The parameter op, if non-NULL, |
| is the comparison of mode is CC-somethingmode. */ |
| |
| 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); |
| |
| /* We don't care to look at these, they should always be valid. */ |
| 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; |
| } |
| |
| /* X and Y are two things to compare using CODE. Emit a compare insn if |
| possible and return the rtx for the cc-reg in the proper mode, or |
| NULL_RTX if this is not a valid comparison. */ |
| |
| 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; |
| |
| /* FIXME: Do we get constants here? Of double mode? */ |
| 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); |
| |
| /* FIXME: Can we avoid emitting a compare insn here? */ |
| if (! REG_P (x) && ! REG_P (y)) |
| x = force_reg (mode, x); |
| |
| CANONICALIZE_COMPARISON (code, x, y); |
| |
| /* If it's not quite right yet, put y in a register. */ |
| 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; |
| } |
| |
| /* Local (static) helper functions. */ |
| |
| /* Print operator suitable for doing something with a shiftable |
| wyde. The type of operator is passed as a asm output modifier. */ |
| |
| 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++) |
| { |
| /* We know we're through when we find one-bits in the low |
| 16 bits. */ |
| if (value & 0xffff) |
| { |
| fprintf (stream, "%s%s", mainop, op_part[i]); |
| return; |
| } |
| value >>= 16; |
| } |
| |
| /* No bits set? Then it must have been zero. */ |
| fprintf (stream, "%sL", mainop); |
| } |
| |
| /* Print a 64-bit value, optionally prefixed by assembly pseudo. */ |
| |
| static void |
| mmix_output_octa (stream, value, do_begin_end) |
| FILE *stream; |
| HOST_WIDEST_INT value; |
| int do_begin_end; |
| { |
| /* Snipped from final.c:output_addr_const. We need to avoid the |
| presumed universal "0x" prefix. We can do it by replacing "0x" with |
| "#0" here; we must avoid a space in the operands and no, the zero |
| won't cause the number to be assumed in octal format. */ |
| 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'; |
| |
| /* Provide a few alternative output formats depending on the number, to |
| improve legibility of assembler output. */ |
| 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"); |
| } |
| |
| /* Print the presumed shiftable wyde argument shifted into place (to |
| be output with an operand). */ |
| |
| 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++) |
| { |
| /* We know we're through when we find one-bits in the low 16 bits. */ |
| if (value & 0xffff) |
| { |
| fprintf (stream, "#%x", (int) (value & 0xffff)); |
| return; |
| } |
| |
| value >>= 16; |
| } |
| |
| /* No bits set? Then it must have been zero. */ |
| fprintf (stream, "0"); |
| } |
| |
| /* Output an MMIX condition name corresponding to an operator |
| and operands: |
| (comparison_operator [(comparison_operator ...) (const_int 0)]) |
| which means we have to look at *two* operators. |
| |
| The argument "reversed" refers to reversal of the condition (not the |
| same as swapping the arguments). */ |
| |
| static void |
| mmix_output_condition (stream, x, reversed) |
| FILE *stream; |
| rtx x; |
| int reversed; |
| { |
| struct cc_conv |
| { |
| RTX_CODE cc; |
| |
| /* The normal output cc-code. */ |
| const char *const normal; |
| |
| /* The reversed cc-code, or NULL if invalid. */ |
| const char *const reversed; |
| }; |
| |
| struct cc_type_conv |
| { |
| enum machine_mode cc_mode; |
| |
| /* Terminated with {NIL, NULL, NULL} */ |
| 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}}; |
| |
| unsigned int i; |
| int j; |
| |
| enum machine_mode mode = GET_MODE (XEXP (x, 0)); |
| RTX_CODE cc = GET_CODE (x); |
| |
| for (i = 0; i < sizeof (cc_convs)/sizeof(*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); |
| } |
| |
| /* Return the bit-value for a const_int or const_double. */ |
| |
| static HOST_WIDEST_INT |
| mmix_intval (x) |
| rtx x; |
| { |
| unsigned HOST_WIDEST_INT retval; |
| |
| if (GET_CODE (x) == CONST_INT) |
| return INTVAL (x); |
| |
| /* We make a little song and dance because converting to long long in |
| gcc-2.7.2 is broken. I still want people to be able to use it for |
| cross-compilation to MMIX. */ |
| 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; |
| |
| /* FIXME: This macro is not in the manual but should be. */ |
| 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); |
| } |
| |
| /* |
| * Local variables: |
| * eval: (c-set-style "gnu") |
| * indent-tabs-mode: t |
| * End: |
| */ |