Subversion Repositories openrisc_me

/* Definitions of target machine for GNU compiler, for MMIX.

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Contributed by Hans-Peter Nilsson (hp@bitrange.com)

This file is part of GCC.

GCC 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 3, or (at your option)

any later version.

GCC 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 GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.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"

/* 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.  Before any whole-function

   analysis, df_regs_ever_live_p () isn't initialized.  We know it's up-to-date

   after reload_completed; it may contain incorrect information some time

   before that.  Within a RTL sequence (after a call to start_sequence,

   such as in RTL expanders), leaf_function_p doesn't see all insns

   (perhaps any insn).  But regs_ever_live is up-to-date when

   leaf_function_p () isn't, so we "or" them together to get accurate

   information.  FIXME: Some tweak to leaf_function_p might be

   preferable.  */

#define MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS                 \

 (flag_exceptions                                               \

  && ((reload_completed && df_regs_ever_live_p (MMIX_rJ_REGNUM))        \

      || !leaf_function_p ()))

#define IS_MMIX_EH_RETURN_DATA_REG(REGNO)       \

 (crtl->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))

/* For the default ABI, we rename registers at output-time to fill the gap

   between the (statically partitioned) saved registers and call-clobbered

   registers.  In effect this makes unused call-saved registers to be used

   as call-clobbered registers.  The benefit comes from keeping the number

   of local registers (value of rL) low, since there's a cost of

   increasing rL and clearing unused (unset) registers with lower numbers.

   Don't translate while outputting the prologue.  */

#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))

/* The %d in "POP %d,0".  */

#define MMIX_POP_ARGUMENT()                                             \

 ((! TARGET_ABI_GNU                                                     \

   && crtl->return_rtx != NULL                          \

   && ! cfun->returns_struct)                           \

  ? (GET_CODE (crtl->return_rtx) == PARALLEL                    \

     ? GET_NUM_ELEM (XVEC (crtl->return_rtx, 0)) : 1)    \

  : 0)

/* The canonical saved comparison operands for non-cc0 machines, set in

   the compare expander.  */

rtx mmix_compare_op0;

rtx mmix_compare_op1;

/* Declarations of locals.  */

/* Intermediate for insn output.  */

static int mmix_output_destination_register;

static void mmix_output_shiftvalue_op_from_str

  (FILE *, const char *, HOST_WIDEST_INT);

static void mmix_output_shifted_value (FILE *, HOST_WIDEST_INT);

static void mmix_output_condition (FILE *, rtx, int);

static HOST_WIDEST_INT mmix_intval (rtx);

static void mmix_output_octa (FILE *, HOST_WIDEST_INT, int);

static bool mmix_assemble_integer (rtx, unsigned int, int);

static struct machine_function *mmix_init_machine_status (void);

static void mmix_encode_section_info (tree, rtx, int);

static const char *mmix_strip_name_encoding (const char *);

static void mmix_emit_sp_add (HOST_WIDE_INT offset);

static void mmix_target_asm_function_prologue (FILE *, HOST_WIDE_INT);

static void mmix_target_asm_function_end_prologue (FILE *);

static void mmix_target_asm_function_epilogue (FILE *, HOST_WIDE_INT);

static bool mmix_legitimate_address_p (enum machine_mode, rtx, bool);

static void mmix_reorg (void);

static void mmix_asm_output_mi_thunk

  (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);

static void mmix_setup_incoming_varargs

  (CUMULATIVE_ARGS *, enum machine_mode, tree, int *, int);

static void mmix_file_start (void);

static void mmix_file_end (void);

static bool mmix_rtx_costs (rtx, int, int, int *, bool);

static rtx mmix_struct_value_rtx (tree, int);

static enum machine_mode mmix_promote_function_mode (const_tree,

                                                     enum machine_mode,

                                                     int *, const_tree, int);

static bool mmix_pass_by_reference (CUMULATIVE_ARGS *,

                                    enum machine_mode, const_tree, bool);

static bool mmix_frame_pointer_required (void);

static void mmix_asm_trampoline_template (FILE *);

static void mmix_trampoline_init (rtx, tree, rtx);

/* 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_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

#undef TARGET_ASM_FILE_START

#define TARGET_ASM_FILE_START mmix_file_start

#undef TARGET_ASM_FILE_START_FILE_DIRECTIVE

#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true

#undef TARGET_ASM_FILE_END

#define TARGET_ASM_FILE_END mmix_file_end

#undef TARGET_RTX_COSTS

#define TARGET_RTX_COSTS mmix_rtx_costs

#undef TARGET_ADDRESS_COST

#define TARGET_ADDRESS_COST hook_int_rtx_bool_0

#undef TARGET_MACHINE_DEPENDENT_REORG

#define TARGET_MACHINE_DEPENDENT_REORG mmix_reorg

#undef TARGET_PROMOTE_FUNCTION_MODE

#define TARGET_PROMOTE_FUNCTION_MODE mmix_promote_function_mode

#undef TARGET_STRUCT_VALUE_RTX

#define TARGET_STRUCT_VALUE_RTX mmix_struct_value_rtx

#undef TARGET_SETUP_INCOMING_VARARGS

#define TARGET_SETUP_INCOMING_VARARGS mmix_setup_incoming_varargs

#undef TARGET_PASS_BY_REFERENCE

#define TARGET_PASS_BY_REFERENCE mmix_pass_by_reference

#undef TARGET_CALLEE_COPIES

#define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true

#undef TARGET_DEFAULT_TARGET_FLAGS

#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT

#undef TARGET_LEGITIMATE_ADDRESS_P

#define TARGET_LEGITIMATE_ADDRESS_P     mmix_legitimate_address_p

#undef TARGET_FRAME_POINTER_REQUIRED

#define TARGET_FRAME_POINTER_REQUIRED mmix_frame_pointer_required

#undef TARGET_ASM_TRAMPOLINE_TEMPLATE

#define TARGET_ASM_TRAMPOLINE_TEMPLATE mmix_asm_trampoline_template

#undef TARGET_TRAMPOLINE_INIT

#define TARGET_TRAMPOLINE_INIT mmix_trampoline_init

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 (void)

{

  /* 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 (0, "-f%s not supported: ignored", (flag_pic > 1) ? "PIC" : "pic");

      flag_pic = 0;

    }

}

/* INIT_EXPANDERS.  */

void

mmix_init_expanders (void)

{

  init_machine_status = mmix_init_machine_status;

}

/* Set the per-function data.  */

static struct machine_function *

mmix_init_machine_status (void)

{

  return GGC_CNEW (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 (tree type ATTRIBUTE_UNUSED, int basic_align)

{

  if (basic_align < 32)

    return 32;

  return basic_align;

}

/* CONSTANT_ALIGNMENT.  */

int

mmix_constant_alignment (tree constant ATTRIBUTE_UNUSED, int basic_align)

{

  if (basic_align < 32)

    return 32;

  return basic_align;

}

/* LOCAL_ALIGNMENT.  */

int

mmix_local_alignment (tree type ATTRIBUTE_UNUSED, int basic_align)

{

  if (basic_align < 32)

    return 32;

  return basic_align;

}

/* CONDITIONAL_REGISTER_USAGE.  */

void

mmix_conditional_register_usage (void)

{

  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" that holds the

         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;

      /* "Unfix" the parameter registers.  */

      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;

    }

  /* 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]++;

}

/* INCOMING_REGNO and OUTGOING_REGNO worker function.

   Those two macros must only be applied to function argument

   registers.  FIXME: for their current use in gcc, it'd be better

   with an explicit specific additional FUNCTION_INCOMING_ARG_REGNO_P

   a'la FUNCTION_ARG / FUNCTION_INCOMING_ARG instead of forcing the

   target to commit to a fixed mapping and for any unspecified

   register use.  */

int

mmix_opposite_regno (int regno, int incoming)

{

  if (!mmix_function_arg_regno_p (regno, incoming))

    return regno;

  return

    regno - (incoming

             ? MMIX_FIRST_INCOMING_ARG_REGNUM - MMIX_FIRST_ARG_REGNUM

             : MMIX_FIRST_ARG_REGNUM - MMIX_FIRST_INCOMING_ARG_REGNUM);

}

/* LOCAL_REGNO.

   All registers that are part of the register stack and that will be

   saved are local.  */

int

mmix_local_regno (int regno)

{

  return regno <= MMIX_LAST_STACK_REGISTER_REGNUM && !call_used_regs[regno];

}

/* PREFERRED_RELOAD_CLASS.

   We need to extend the reload class of REMAINDER_REG and HIMULT_REG.  */

enum reg_class

mmix_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, enum reg_class rclass)

{

  /* FIXME: Revisit.  */

  return GET_CODE (x) == MOD && GET_MODE (x) == DImode

    ? REMAINDER_REG : rclass;

}

/* 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 (rtx x ATTRIBUTE_UNUSED,

                                    enum reg_class rclass)

{

  /* FIXME: Revisit.  */

  return GET_CODE (x) == MOD && GET_MODE (x) == DImode

    ? REMAINDER_REG : rclass;

}

/* SECONDARY_RELOAD_CLASS.

   We need to reload regs of REMAINDER_REG and HIMULT_REG elsewhere.  */

enum reg_class

mmix_secondary_reload_class (enum reg_class rclass,

                             enum machine_mode mode ATTRIBUTE_UNUSED,

                             rtx x ATTRIBUTE_UNUSED,

                             int in_p ATTRIBUTE_UNUSED)

{

  if (rclass == REMAINDER_REG

      || rclass == HIMULT_REG

      || rclass == SYSTEM_REGS)

    return GENERAL_REGS;

  return NO_REGS;

}

/* CONST_OK_FOR_LETTER_P.  */

int

mmix_const_ok_for_letter_p (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 (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 (rtx x, int c, int strict)

{

  HOST_WIDEST_INT value;

  /* When checking for an address, we need to handle strict vs. non-strict

     register checks.  Don't use address_operand, but instead its

     equivalent (its callee, which it is just a wrapper for),

     memory_operand_p and the strict-equivalent strict_memory_address_p.  */

  if (c == 'U')

    return

      strict

      ? strict_memory_address_p (Pmode, x)

      : memory_address_p (Pmode, x);

  /* R asks whether x is to be loaded with GETA or something else.  Right

     now, only a SYMBOL_REF and LABEL_REF can fit for

     TARGET_BASE_ADDRESSES.

     Only constant symbolic addresses apply.  With TARGET_BASE_ADDRESSES,

     we just allow straight LABEL_REF or SYMBOL_REFs with SYMBOL_REF_FLAG

     set right now; only function addresses and code labels.  If we change

     to let SYMBOL_REF_FLAG be set on other symbols, we have to check

     inside CONST expressions.  When TARGET_BASE_ADDRESSES is not in

     effect, a "raw" constant check together with mmix_constant_address_p

     is all that's needed; we want all constant addresses to be loaded

     with GETA then.  */

  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);

  /* 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, 'R' similarly).  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 (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 (void)

{

  /* 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 (int count, rtx frame ATTRIBUTE_UNUSED)

{

  return count == 0

    ? (MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS

       /* FIXME: Set frame_alias_set on the following.  (Why?)

          See mmix_initial_elimination_offset for the reason we can't use

          get_hard_reg_initial_val for both.  Always using a stack slot

          and not a register would be suboptimal.  */

       ? 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 (void)

{

  /* 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 (int fromreg, int toreg)

{

  int regno;

  int fp_sp_offset

    = (get_frame_size () + crtl->outgoing_args_size + 7) & ~7;

  /* There is no actual offset between these two virtual values, but for

     the frame-pointer, we have the old one in the stack position below

     it, so the offset for the frame-pointer to the stack-pointer is one

     octabyte larger.  */

  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 ((df_regs_ever_live_p (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 (const CUMULATIVE_ARGS *argsp,

                   enum machine_mode mode,

                   tree type,

                   int named ATTRIBUTE_UNUSED,

                   int incoming)

{

  /* 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

          && !targetm.calls.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.  */

static bool

mmix_pass_by_reference (CUMULATIVE_ARGS *argsp, enum machine_mode mode,

                        const_tree type, bool named ATTRIBUTE_UNUSED)

{

  /* FIXME: Check: I'm not sure the must_pass_in_stack check is

     necessary.  */

  if (targetm.calls.must_pass_in_stack (mode, type))

    return true;

  if (MMIX_FUNCTION_ARG_SIZE (mode, type) > 8

      && !TARGET_LIBFUNC

      && (!argsp || !argsp->lib))

    return true;

  return false;

}

/* Return nonzero if regno is a register number where a parameter is

   passed, and 0 otherwise.  */

int

mmix_function_arg_regno_p (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 (const_tree valtype, const_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);

  if (COMPLEX_MODE_P (mode))

    /* A complex type, made up of components.  */

    cmode = TYPE_MODE (TREE_TYPE (valtype));

  else

    {

      /* Of the other larger-than-register modes, we only support

         scalar mode TImode.  (At least, that's the only one that's

         been rudimentally tested.)  Make sure we're alerted for

         unexpected cases.  */

      if (mode != TImode)

        sorry ("support for mode %qs", GET_MODE_NAME (mode));

      /* In any case, we will fill registers to the natural size.  */

      cmode = DImode;

    }

  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),

                         const0_rtx);

  return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nregs, vec));

}

/* FUNCTION_VALUE_REGNO_P.  */

int

mmix_function_value_regno_p (int regno)

{

  return regno == MMIX_RETURN_VALUE_REGNUM;

}

/* EH_RETURN_DATA_REGNO. */

int

mmix_eh_return_data_regno (int n)

{

  if (n >= 0 && n < 4)

    return MMIX_EH_RETURN_DATA_REGNO_START + n;

  return INVALID_REGNUM;

}

/* EH_RETURN_STACKADJ_RTX. */