Subversion Repositories openrisc_me

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

   Copyright (C) 2000, 2001, 2002, 2004, 2005, 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/>.  */

#ifndef GCC_MMIX_H

#define GCC_MMIX_H

/* First, some local helper macros.  Note that the "default" value of

   FIXED_REGISTERS, CALL_USED_REGISTERS, REG_ALLOC_ORDER and

   REG_CLASS_CONTENTS depend on these values.  */

#define MMIX_RESERVED_GNU_ARG_0_REGNUM 231

#define MMIX_FIRST_ARG_REGNUM \

  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 16)

#define MMIX_FIRST_INCOMING_ARG_REGNUM \

  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 0)

#define MMIX_MAX_ARGS_IN_REGS 16

/* FIXME: This one isn't fully implemented yet.  Return values larger than

   one register are passed by reference in MMIX_STRUCT_VALUE_REGNUM by the

   caller, except for return values of type "complex".  */

#define MMIX_MAX_REGS_FOR_VALUE 16

#define MMIX_RETURN_VALUE_REGNUM \

  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 15)

#define MMIX_OUTGOING_RETURN_VALUE_REGNUM \

  (TARGET_ABI_GNU ? MMIX_RESERVED_GNU_ARG_0_REGNUM : 0)

#define MMIX_STRUCT_VALUE_REGNUM 251

#define MMIX_STATIC_CHAIN_REGNUM 252

#define MMIX_FRAME_POINTER_REGNUM 253

#define MMIX_STACK_POINTER_REGNUM 254

#define MMIX_LAST_GENERAL_REGISTER 255

#define MMIX_INCOMING_RETURN_ADDRESS_REGNUM MMIX_rJ_REGNUM

#define MMIX_HIMULT_REGNUM 258

#define MMIX_REMAINDER_REGNUM MMIX_rR_REGNUM

#define MMIX_ARG_POINTER_REGNUM 261

#define MMIX_rO_REGNUM 262

#define MMIX_LAST_STACK_REGISTER_REGNUM 31

/* Four registers; "ideally, these registers should be call-clobbered", so

   just grab a bunch of the common clobbered registers.  FIXME: Last

   registers of return-value should be used, with an error if there's a

   return-value (that collides in size).  */

#define MMIX_EH_RETURN_DATA_REGNO_START (MMIX_STRUCT_VALUE_REGNUM - 4)

/* Try to keep the definitions from running away on their own.  */

#if (MMIX_EH_RETURN_DATA_REGNO_START \

     != MMIX_RESERVED_GNU_ARG_0_REGNUM + MMIX_MAX_ARGS_IN_REGS)

 #error MMIX register definition inconsistency

#endif

#if (MMIX_MAX_REGS_FOR_VALUE + MMIX_MAX_ARGS_IN_REGS > 32)

 #error MMIX parameters and return values bad, more than 32 registers

#endif

/* This chosen as "a call-clobbered hard register that is otherwise

   untouched by the epilogue".  */

#define MMIX_EH_RETURN_STACKADJ_REGNUM MMIX_STATIC_CHAIN_REGNUM

#ifdef REG_OK_STRICT

# define MMIX_REG_OK_STRICT 1

#else

# define MMIX_REG_OK_STRICT 0

#endif

#define MMIX_FUNCTION_ARG_SIZE(MODE, TYPE) \

 ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) : int_size_in_bytes (TYPE))

/* Per-function machine data.  This is normally an opaque type just

   defined and used in the tm.c file, but we need to see the definition in

   mmix.md too.  */

struct GTY(()) machine_function

 {

   int has_landing_pad;

   int highest_saved_stack_register;

   int in_prologue;

 };

/* For these target macros, there is no generic documentation here.  You

   should read `Using and Porting GCC' for that.  Only comments specific

   to the MMIX target are here.

   There are however references to the specific texinfo node (comments

   with "Node:"), so there should be little or nothing amiss.  Probably

   the opposite, since we don't have to care about old littering and

   soon outdated generic comments.  */

/* Node: Driver */

/* User symbols are in the same name-space as built-in symbols, but we

   don't need the built-in symbols, so remove those and instead apply

   stricter operand checking.  Don't warn when expanding insns.  */

#define ASM_SPEC "-no-predefined-syms -x"

/* Pass on -mset-program-start=N and -mset-data-start=M to the linker.

   Provide default program start 0x100 unless -mno-set-program-start.

   Don't do this if linking relocatably, with -r.  For a final link,

   produce mmo, unless ELF is requested or when linking relocatably.  */

#define LINK_SPEC \

 "%{mset-program-start=*:--defsym __.MMIX.start..text=%*}\

  %{mset-data-start=*:--defsym __.MMIX.start..data=%*}\

  %{!mset-program-start=*:\

    %{!mno-set-program-start:\

     %{!r:--defsym __.MMIX.start..text=0x100}}}\

  %{!melf:%{!r:-m mmo}}%{melf|r:-m elf64mmix}"

/* FIXME: There's no provision for profiling here.  */

#define STARTFILE_SPEC  \

  "crti%O%s crtbegin%O%s"

#define ENDFILE_SPEC "crtend%O%s crtn%O%s"

/* Node: Run-time Target */

/* Define __LONG_MAX__, since we're advised not to change glimits.h.  */

#define TARGET_CPU_CPP_BUILTINS()                               \

  do                                                            \

    {                                                           \

      builtin_define ("__mmix__");                              \

      builtin_define ("__MMIX__");                              \

      if (TARGET_ABI_GNU)                                       \

        builtin_define ("__MMIX_ABI_GNU__");                    \

      else                                                      \

        builtin_define ("__MMIX_ABI_MMIXWARE__");               \

    }                                                           \

  while (0)

extern int target_flags;

#define TARGET_DEFAULT \

 (MASK_BRANCH_PREDICT | MASK_BASE_ADDRESSES | MASK_USE_RETURN_INSN)

/* Unfortunately, this must not reference anything in "mmix.c".  */

#define TARGET_VERSION \

  fprintf (stderr, " (MMIX)")

#define OVERRIDE_OPTIONS mmix_override_options ()

#define OPTIMIZATION_OPTIONS(LEVEL, SIZE)       \

  do                                            \

    {                                           \

      if (LEVEL >= 1)                           \

        flag_regmove = TRUE;                    \

                                                \

      if (SIZE || LEVEL > 1)                    \

        {                                       \

          flag_omit_frame_pointer = TRUE;       \

        }                                       \

    }                                           \

  while (0)

/* This one will have to wait a little bit; right now we can't debug

   neither with or without a frame-pointer.  */

/* #define CAN_DEBUG_WITHOUT_FP */

/* Node: Per-Function Data */

#define INIT_EXPANDERS mmix_init_expanders ()

/* Node: Storage Layout */

/* I see no bit-field instructions.  Anyway, the common order is from low

   to high, as the power of two, hence little-endian.  */

#define BITS_BIG_ENDIAN 0

#define BYTES_BIG_ENDIAN 1

#define WORDS_BIG_ENDIAN 1

#define FLOAT_WORDS_BIG_ENDIAN 1

#define UNITS_PER_WORD 8

/* We need to align everything to 64 bits that can affect the alignment

   of other types.  Since address N is interpreted in MMIX as (N modulo

   access_size), we must align.  */

#define PARM_BOUNDARY 64

#define STACK_BOUNDARY 64

#define FUNCTION_BOUNDARY 32

#define BIGGEST_ALIGNMENT 64

/* This one is only used in the ADA front end.  */

#define MINIMUM_ATOMIC_ALIGNMENT 8

/* Copied from elfos.h.  */

#define MAX_OFILE_ALIGNMENT (32768 * 8)

#define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \

 mmix_data_alignment (TYPE, BASIC_ALIGN)

#define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \

 mmix_constant_alignment (CONSTANT, BASIC_ALIGN)

#define LOCAL_ALIGNMENT(TYPE, BASIC_ALIGN) \

 mmix_local_alignment (TYPE, BASIC_ALIGN)

/* Following other ports, this seems to most commonly be the word-size,

   so let's do that here too.  */

#define EMPTY_FIELD_BOUNDARY 64

/* We chose to have this low solely for similarity with the alpha.  It has

   nothing to do with passing the tests dg/c99-scope-2 and

   execute/align-1.c.  Nothing.  Though the tests seem wrong.  Padding of

   the structure is automatically added to get alignment when needed if we

   set this to just byte-boundary.  */

#define STRUCTURE_SIZE_BOUNDARY 8

/* The lower bits are ignored.  */

#define STRICT_ALIGNMENT 1

/* Node: Type Layout */

/* It might seem more natural to have 64-bit ints on a 64-bit machine,

   but then an occasional MMIX programmer needs to know how to put a lot

   of __attribute__ stuff to get to the 8, 16 and 32-bit modes rather

   than the "intuitive" char, short and int types.  */

#define INT_TYPE_SIZE 32

#define SHORT_TYPE_SIZE 16

#define LONG_LONG_TYPE_SIZE 64

#define FLOAT_TYPE_SIZE 32

#define DOUBLE_TYPE_SIZE 64

#define LONG_DOUBLE_TYPE_SIZE 64

#define DEFAULT_SIGNED_CHAR 1

/* Node: Register Basics */

/* We tell GCC about all 256 general registers, and we also include

   rD, rE, rH, rJ, rR and rO (in that order) so we can describe what insns

   clobber them.  We use a faked register for the argument pointer.  It is

   always eliminated towards the frame-pointer or the stack-pointer, never

   output in assembly.  Any fixed register would do for this, like $255,

   but future debugging is easier when using a separate register.  It

   counts as a global register for pseudorandom reasons.  */

#define FIRST_PSEUDO_REGISTER 263

/* We treat general registers with no assigned purpose as fixed.  The

   stack pointer, $254, is also fixed.  Register $255 is referred to as a

   temporary register in the MMIX papers, and used as such in mmixal, so

   it should not be used as a stack pointer.  We set it to fixed, and use

   it "manually" at times of despair.  */

#define FIXED_REGISTERS \

 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, \

   1, 1, 0, 0, 0, 1, 1 \

 }

/* General registers are fixed and therefore "historically" marked

   call-used.  (FIXME: This has changed).  Registers $15..$31 are

   call-clobbered; we'll put arguments in $16 and up, and we need $15 for

   the MMIX register-stack "hole".  */

#define CALL_USED_REGISTERS \

 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \

   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, \

   1, 1, 1, 1, 1, 1, 1 \

 }

#define CONDITIONAL_REGISTER_USAGE mmix_conditional_register_usage ()

#define INCOMING_REGNO(OUT) mmix_opposite_regno (OUT, 0)

#define OUTGOING_REGNO(IN) mmix_opposite_regno (IN, 1)

/* Defining LOCAL_REGNO is necessary in presence of prologue/epilogue,

   else GCC will be confused that those registers aren't saved and

   restored.  */

#define LOCAL_REGNO(REGNO) mmix_local_regno (REGNO)

/* Node: Allocation Order */

/* We should allocate registers from 0 to 31 by increasing number, because

   I think that's what people expect.  Beyond that, just use

   call-clobbered global registers first, then call-clobbered special

   registers.  Last, the fixed registers.  */

#define MMIX_MMIXWARE_ABI_REG_ALLOC_ORDER       \

 { 0, 1, 2, 3, 4, 5, 6, 7,                       \

   8, 9, 10, 11, 12, 13, 14, 15,                \

   16, 17, 18, 19, 20, 21, 22, 23,              \

   24, 25, 26, 27, 28, 29, 30, 31,              \

                                                \

   252, 251, 250, 249, 248, 247,                \

                                                \

   253,                                         \

                                                \

   258, 260, 259,                               \

                                                \

   32, 33, 34, 35, 36, 37, 38, 39,              \

   40, 41, 42, 43, 44, 45, 46, 47,              \

   48, 49, 50, 51, 52, 53, 54, 55,              \

   56, 57, 58, 59, 60, 61, 62, 63,              \

   64, 65, 66, 67, 68, 69, 70, 71,              \

   72, 73, 74, 75, 76, 77, 78, 79,              \

   80, 81, 82, 83, 84, 85, 86, 87,              \

   88, 89, 90, 91, 92, 93, 94, 95,              \

   96, 97, 98, 99, 100, 101, 102, 103,          \

   104, 105, 106, 107, 108, 109, 110, 111,      \

   112, 113, 114, 115, 116, 117, 118, 119,      \

   120, 121, 122, 123, 124, 125, 126, 127,      \

   128, 129, 130, 131, 132, 133, 134, 135,      \

   136, 137, 138, 139, 140, 141, 142, 143,      \

   144, 145, 146, 147, 148, 149, 150, 151,      \

   152, 153, 154, 155, 156, 157, 158, 159,      \

   160, 161, 162, 163, 164, 165, 166, 167,      \

   168, 169, 170, 171, 172, 173, 174, 175,      \

   176, 177, 178, 179, 180, 181, 182, 183,      \

   184, 185, 186, 187, 188, 189, 190, 191,      \

   192, 193, 194, 195, 196, 197, 198, 199,      \

   200, 201, 202, 203, 204, 205, 206, 207,      \

   208, 209, 210, 211, 212, 213, 214, 215,      \

   216, 217, 218, 219, 220, 221, 222, 223,      \

   224, 225, 226, 227, 228, 229, 230, 231,      \

   232, 233, 234, 235, 236, 237, 238, 239,      \

   240, 241, 242, 243, 244, 245, 246,           \

                                                \

   254, 255, 256, 257, 261, 262                 \

 }

/* As a convenience, we put this nearby, for ease of comparison.

   First, call-clobbered registers in reverse order of assignment as

   parameters (also the top ones; not because they're parameters, but

   for continuity).

   Second, saved registers that go on the register-stack.

   Third, special registers rH, rR and rJ.  They should not normally be

   allocated, but since they're call-clobbered, it is cheaper to use one

   of them than using a call-saved register for a call-clobbered use,

   assuming it is referenced a very limited number of times.  Other global

   and fixed registers come next; they are never allocated.  */

#define MMIX_GNU_ABI_REG_ALLOC_ORDER            \

 { 252, 251, 250, 249, 248, 247, 246,           \

   245, 244, 243, 242, 241, 240, 239, 238,      \

   237, 236, 235, 234, 233, 232, 231,           \

                                                \

   0, 1, 2, 3, 4, 5, 6, 7,                       \

   8, 9, 10, 11, 12, 13, 14, 15,                \

   16, 17, 18, 19, 20, 21, 22, 23,              \

   24, 25, 26, 27, 28, 29, 30, 31,              \

                                                \

   253,                                         \

                                                \

   258, 260, 259,                               \

                                                \

   32, 33, 34, 35, 36, 37, 38, 39,              \

   40, 41, 42, 43, 44, 45, 46, 47,              \

   48, 49, 50, 51, 52, 53, 54, 55,              \

   56, 57, 58, 59, 60, 61, 62, 63,              \

   64, 65, 66, 67, 68, 69, 70, 71,              \

   72, 73, 74, 75, 76, 77, 78, 79,              \

   80, 81, 82, 83, 84, 85, 86, 87,              \

   88, 89, 90, 91, 92, 93, 94, 95,              \

   96, 97, 98, 99, 100, 101, 102, 103,          \

   104, 105, 106, 107, 108, 109, 110, 111,      \

   112, 113, 114, 115, 116, 117, 118, 119,      \

   120, 121, 122, 123, 124, 125, 126, 127,      \

   128, 129, 130, 131, 132, 133, 134, 135,      \

   136, 137, 138, 139, 140, 141, 142, 143,      \

   144, 145, 146, 147, 148, 149, 150, 151,      \

   152, 153, 154, 155, 156, 157, 158, 159,      \

   160, 161, 162, 163, 164, 165, 166, 167,      \

   168, 169, 170, 171, 172, 173, 174, 175,      \

   176, 177, 178, 179, 180, 181, 182, 183,      \

   184, 185, 186, 187, 188, 189, 190, 191,      \

   192, 193, 194, 195, 196, 197, 198, 199,      \

   200, 201, 202, 203, 204, 205, 206, 207,      \

   208, 209, 210, 211, 212, 213, 214, 215,      \

   216, 217, 218, 219, 220, 221, 222, 223,      \

   224, 225, 226, 227, 228, 229, 230,           \

                                                \

   254, 255, 256, 257, 261, 262                 \

 }

/* The default one.  */

#define REG_ALLOC_ORDER MMIX_MMIXWARE_ABI_REG_ALLOC_ORDER

/* Node: Values in Registers */

#define HARD_REGNO_NREGS(REGNO, MODE)                   \

   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)         \

    / UNITS_PER_WORD)

#define HARD_REGNO_MODE_OK(REGNO, MODE) 1

/* Note that no register can really be accessed in single-float mode, so

   we *can* say 1 here.  FIXME:  Will TRT happen for single-float, or do

   we have to punt to libgcc1.asm?  */

#define MODES_TIEABLE_P(MODE1, MODE2) 1

/* Node: Leaf Functions */

/* (empty) */

/* Node: Register Classes */

enum reg_class

 {

   NO_REGS, GENERAL_REGS, REMAINDER_REG, HIMULT_REG,

   SYSTEM_REGS, ALL_REGS, LIM_REG_CLASSES

 };

#define N_REG_CLASSES (int) LIM_REG_CLASSES

#define REG_CLASS_NAMES                                         \

 {"NO_REGS", "GENERAL_REGS", "REMAINDER_REG", "HIMULT_REG",     \

  "SYSTEM_REGS", "ALL_REGS"}

/* Note that the contents of each item is always 32 bits.  */

#define REG_CLASS_CONTENTS                      \

 {{0, 0, 0, 0, 0, 0, 0, 0, 0},                   \

  {~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0x20},       \

  {0, 0, 0, 0, 0, 0, 0, 0, 0x10},               \

  {0, 0, 0, 0, 0, 0, 0, 0, 4},                  \

  {0, 0, 0, 0, 0, 0, 0, 0, 0x7f},               \

  {~0, ~0, ~0, ~0, ~0, ~0, ~0, ~0, 0x7f}}

#define REGNO_REG_CLASS(REGNO)                                  \

 ((REGNO) <= MMIX_LAST_GENERAL_REGISTER                         \

  || (REGNO) == MMIX_ARG_POINTER_REGNUM                         \

  ? GENERAL_REGS                                                \

  : (REGNO) == MMIX_REMAINDER_REGNUM ? REMAINDER_REG            \

  : (REGNO) == MMIX_HIMULT_REGNUM ? HIMULT_REG : SYSTEM_REGS)

#define BASE_REG_CLASS GENERAL_REGS

#define INDEX_REG_CLASS GENERAL_REGS

#define REG_CLASS_FROM_LETTER(CHAR)             \

 ((CHAR) == 'x' ? SYSTEM_REGS                   \

  : (CHAR) == 'y' ? REMAINDER_REG               \

  : (CHAR) == 'z' ? HIMULT_REG : NO_REGS)

#define REGNO_OK_FOR_BASE_P(REGNO)                              \

 ((REGNO) <= MMIX_LAST_GENERAL_REGISTER                         \

  || (REGNO) == MMIX_ARG_POINTER_REGNUM                         \

  || (reg_renumber[REGNO] > 0                                    \

      && reg_renumber[REGNO] <= MMIX_LAST_GENERAL_REGISTER))

#define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P (REGNO)

#define PREFERRED_RELOAD_CLASS(X, CLASS) \

 mmix_preferred_reload_class (X, CLASS)

#define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \

 mmix_preferred_output_reload_class (X, CLASS)

#define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \

 mmix_secondary_reload_class (CLASS, MODE, X, 1)

#define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \

 mmix_secondary_reload_class (CLASS, MODE, X, 0)

#define CLASS_MAX_NREGS(CLASS, MODE) HARD_REGNO_NREGS (CLASS, MODE)

#define CONST_OK_FOR_LETTER_P(VALUE, C) \

 mmix_const_ok_for_letter_p (VALUE, C)

#define EXTRA_CONSTRAINT(VALUE, C)      \

 mmix_extra_constraint (VALUE, C, MMIX_REG_OK_STRICT)

/* Do we need anything serious here?  Yes, any FLOT constant.  */

#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                  \

 mmix_const_double_ok_for_letter_p (VALUE, C)

/* Node: Frame Layout */

#define STACK_GROWS_DOWNWARD

#define FRAME_GROWS_DOWNWARD 1

#define STARTING_FRAME_OFFSET \

  mmix_starting_frame_offset ()

#define FIRST_PARM_OFFSET(FUNDECL) 0

#define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) \

 mmix_dynamic_chain_address (FRAMEADDR)

/* FIXME: It seems RETURN_ADDR_OFFSET is undocumented.  */

#define SETUP_FRAME_ADDRESSES() \

 mmix_setup_frame_addresses ()

#define RETURN_ADDR_RTX(COUNT, FRAME)           \

 mmix_return_addr_rtx (COUNT, FRAME)

/* It's in rJ before we store it somewhere.  */

#define INCOMING_RETURN_ADDR_RTX \

 gen_rtx_REG (Pmode, MMIX_INCOMING_RETURN_ADDRESS_REGNUM)

/* FIXME: This does not seem properly documented or cross-indexed.

   Nowhere except in the code does it say it *has* to be in the range

   0..255, or else it will be truncated.  That goes for the default too.  */

#define DWARF_FRAME_RETURN_COLUMN \

 DWARF_FRAME_REGNUM (MMIX_INCOMING_RETURN_ADDRESS_REGNUM)

/* No return address is stored there.  */

#define INCOMING_FRAME_SP_OFFSET 0

/* Node: Stack Checking */

/* (empty) */

/* Node: Exception Handling */

#define EH_RETURN_DATA_REGNO(N) \

 mmix_eh_return_data_regno (N)

#define EH_RETURN_STACKADJ_RTX \

 mmix_eh_return_stackadj_rtx ()

#define EH_RETURN_HANDLER_RTX \

 mmix_eh_return_handler_rtx ()

#define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \

 mmix_asm_preferred_eh_data_format (CODE, GLOBAL)