Subversion Repositories openrisc_me

/* Definitions of target machine for GNU compiler, for the HP Spectrum.

   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.

   Contributed by Michael Tiemann (tiemann@cygnus.com) of Cygnus Support

   and Tim Moore (moore@defmacro.cs.utah.edu) of the Center for

   Software Science at the University of Utah.

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

enum cmp_type                           /* comparison type */

{

  CMP_SI,                               /* compare integers */

  CMP_SF,                               /* compare single precision floats */

  CMP_DF,                               /* compare double precision floats */

  CMP_MAX                               /* max comparison type */

};

/* For long call handling.  */

extern unsigned long total_code_bytes;

/* Which processor to schedule for.  */

enum processor_type

{

  PROCESSOR_700,

  PROCESSOR_7100,

  PROCESSOR_7100LC,

  PROCESSOR_7200,

  PROCESSOR_7300,

  PROCESSOR_8000

};

/* For -mschedule= option.  */

extern enum processor_type pa_cpu;

/* For -munix= option.  */

extern int flag_pa_unix;

#define pa_cpu_attr ((enum attr_cpu)pa_cpu)

/* Print subsidiary information on the compiler version in use.  */

#define TARGET_VERSION fputs (" (hppa)", stderr);

#define TARGET_PA_10 (!TARGET_PA_11 && !TARGET_PA_20)

/* Generate code for the HPPA 2.0 architecture in 64bit mode.  */

#ifndef TARGET_64BIT

#define TARGET_64BIT 0

#endif

/* Generate code for ELF32 ABI.  */

#ifndef TARGET_ELF32

#define TARGET_ELF32 0

#endif

/* Generate code for SOM 32bit ABI.  */

#ifndef TARGET_SOM

#define TARGET_SOM 0

#endif

/* HP-UX UNIX features.  */

#ifndef TARGET_HPUX

#define TARGET_HPUX 0

#endif

/* HP-UX 10.10 UNIX 95 features.  */

#ifndef TARGET_HPUX_10_10

#define TARGET_HPUX_10_10 0

#endif

/* HP-UX 11i multibyte and UNIX 98 extensions.  */

#ifndef TARGET_HPUX_11_11

#define TARGET_HPUX_11_11 0

#endif

/* The following three defines are potential target switches.  The current

   defines are optimal given the current capabilities of GAS and GNU ld.  */

/* Define to a C expression evaluating to true to use long absolute calls.

   Currently, only the HP assembler and SOM linker support long absolute

   calls.  They are used only in non-pic code.  */

#define TARGET_LONG_ABS_CALL (TARGET_SOM && !TARGET_GAS)

/* Define to a C expression evaluating to true to use long pic symbol

   difference calls.  This is a call variant similar to the long pic

   pc-relative call.  Long pic symbol difference calls are only used with

   the HP SOM linker.  Currently, only the HP assembler supports these

   calls.  GAS doesn't allow an arbitrary difference of two symbols.  */

#define TARGET_LONG_PIC_SDIFF_CALL (!TARGET_GAS)

/* Define to a C expression evaluating to true to use long pic

   pc-relative calls.  Long pic pc-relative calls are only used with

   GAS.  Currently, they are usable for calls within a module but

   not for external calls.  */

#define TARGET_LONG_PIC_PCREL_CALL 0

/* Define to a C expression evaluating to true to use SOM secondary

   definition symbols for weak support.  Linker support for secondary

   definition symbols is buggy prior to HP-UX 11.X.  */

#define TARGET_SOM_SDEF 0

/* Define to a C expression evaluating to true to save the entry value

   of SP in the current frame marker.  This is normally unnecessary.

   However, the HP-UX unwind library looks at the SAVE_SP callinfo flag.

   HP compilers don't use this flag but it is supported by the assembler.

   We set this flag to indicate that register %r3 has been saved at the

   start of the frame.  Thus, when the HP unwind library is used, we

   need to generate additional code to save SP into the frame marker.  */

#define TARGET_HPUX_UNWIND_LIBRARY 0

#ifndef TARGET_DEFAULT

#define TARGET_DEFAULT (MASK_GAS | MASK_JUMP_IN_DELAY | MASK_BIG_SWITCH)

#endif

#ifndef TARGET_CPU_DEFAULT

#define TARGET_CPU_DEFAULT 0

#endif

#ifndef TARGET_SCHED_DEFAULT

#define TARGET_SCHED_DEFAULT PROCESSOR_8000

#endif

/* Support for a compile-time default CPU, et cetera.  The rules are:

   --with-schedule is ignored if -mschedule is specified.

   --with-arch is ignored if -march is specified.  */

#define OPTION_DEFAULT_SPECS \

  {"arch", "%{!march=*:-march=%(VALUE)}" }, \

  {"schedule", "%{!mschedule=*:-mschedule=%(VALUE)}" }

/* Specify the dialect of assembler to use.  New mnemonics is dialect one

   and the old mnemonics are dialect zero.  */

#define ASSEMBLER_DIALECT (TARGET_PA_20 ? 1 : 0)

#define OVERRIDE_OPTIONS override_options ()

/* Override some settings from dbxelf.h.  */

/* We do not have to be compatible with dbx, so we enable gdb extensions

   by default.  */

#define DEFAULT_GDB_EXTENSIONS 1

/* This used to be zero (no max length), but big enums and such can

   cause huge strings which killed gas.

   We also have to avoid lossage in dbxout.c -- it does not compute the

   string size accurately, so we are real conservative here.  */

#undef DBX_CONTIN_LENGTH

#define DBX_CONTIN_LENGTH 3000

/* GDB always assumes the current function's frame begins at the value

   of the stack pointer upon entry to the current function.  Accessing

   local variables and parameters passed on the stack is done using the

   base of the frame + an offset provided by GCC.

   For functions which have frame pointers this method works fine;

   the (frame pointer) == (stack pointer at function entry) and GCC provides

   an offset relative to the frame pointer.

   This loses for functions without a frame pointer; GCC provides an offset

   which is relative to the stack pointer after adjusting for the function's

   frame size.  GDB would prefer the offset to be relative to the value of

   the stack pointer at the function's entry.  Yuk!  */

#define DEBUGGER_AUTO_OFFSET(X) \

  ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) \

    + (frame_pointer_needed ? 0 : compute_frame_size (get_frame_size (), 0)))

#define DEBUGGER_ARG_OFFSET(OFFSET, X) \

  ((GET_CODE (X) == PLUS ? OFFSET : 0) \

    + (frame_pointer_needed ? 0 : compute_frame_size (get_frame_size (), 0)))

#define TARGET_CPU_CPP_BUILTINS()                               \

do {                                                            \

     builtin_assert("cpu=hppa");                                \

     builtin_assert("machine=hppa");                            \

     builtin_define("__hppa");                                  \

     builtin_define("__hppa__");                                \

     if (TARGET_PA_20)                                          \

       builtin_define("_PA_RISC2_0");                           \

     else if (TARGET_PA_11)                                     \

       builtin_define("_PA_RISC1_1");                           \

     else                                                       \

       builtin_define("_PA_RISC1_0");                           \

} while (0)

/* An old set of OS defines for various BSD-like systems.  */

#define TARGET_OS_CPP_BUILTINS()                                \

  do                                                            \

    {                                                           \

        builtin_define_std ("REVARGV");                         \

        builtin_define_std ("hp800");                           \

        builtin_define_std ("hp9000");                          \

        builtin_define_std ("hp9k8");                           \

        if (!c_dialect_cxx () && !flag_iso)                     \

          builtin_define ("hppa");                              \

        builtin_define_std ("spectrum");                        \

        builtin_define_std ("unix");                            \

        builtin_assert ("system=bsd");                          \

        builtin_assert ("system=unix");                         \

    }                                                           \

  while (0)

#define CC1_SPEC "%{pg:} %{p:}"

#define LINK_SPEC "%{mlinker-opt:-O} %{!shared:-u main} %{shared:-b}"

/* We don't want -lg.  */

#ifndef LIB_SPEC

#define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"

#endif

/* This macro defines command-line switches that modify the default

   target name.

   The definition is be an initializer for an array of structures.  Each

   array element has have three elements: the switch name, one of the

   enumeration codes ADD or DELETE to indicate whether the string should be

   inserted or deleted, and the string to be inserted or deleted.  */

#define MODIFY_TARGET_NAME {{"-32", DELETE, "64"}, {"-64", ADD, "64"}}

/* Make gcc agree with <machine/ansi.h> */

#define SIZE_TYPE "unsigned int"

#define PTRDIFF_TYPE "int"

#define WCHAR_TYPE "unsigned int"

#define WCHAR_TYPE_SIZE 32

/* Show we can debug even without a frame pointer.  */

#define CAN_DEBUG_WITHOUT_FP

/* target machine storage layout */

typedef struct machine_function GTY(())

{

  /* Flag indicating that a .NSUBSPA directive has been output for

     this function.  */

  int in_nsubspa;

} machine_function;

/* Define this macro if it is advisable to hold scalars in registers

   in a wider mode than that declared by the program.  In such cases,

   the value is constrained to be within the bounds of the declared

   type, but kept valid in the wider mode.  The signedness of the

   extension may differ from that of the type.  */

#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \

  if (GET_MODE_CLASS (MODE) == MODE_INT \

      && GET_MODE_SIZE (MODE) < UNITS_PER_WORD)         \

    (MODE) = word_mode;

/* Define this if most significant bit is lowest numbered

   in instructions that operate on numbered bit-fields.  */

#define BITS_BIG_ENDIAN 1

/* Define this if most significant byte of a word is the lowest numbered.  */

/* That is true on the HP-PA.  */

#define BYTES_BIG_ENDIAN 1

/* Define this if most significant word of a multiword number is lowest

   numbered.  */

#define WORDS_BIG_ENDIAN 1

#define MAX_BITS_PER_WORD 64

/* Width of a word, in units (bytes).  */

#define UNITS_PER_WORD (TARGET_64BIT ? 8 : 4)

/* Minimum number of units in a word.  If this is undefined, the default

   is UNITS_PER_WORD.  Otherwise, it is the constant value that is the

   smallest value that UNITS_PER_WORD can have at run-time.

   FIXME: This needs to be 4 when TARGET_64BIT is true to suppress the

   building of various TImode routines in libgcc.  The HP runtime

   specification doesn't provide the alignment requirements and calling

   conventions for TImode variables.  */

#define MIN_UNITS_PER_WORD 4

/* The widest floating point format supported by the hardware.  Note that

   setting this influences some Ada floating point type sizes, currently

   required for GNAT to operate properly.  */

#define WIDEST_HARDWARE_FP_SIZE 64

/* Allocation boundary (in *bits*) for storing arguments in argument list.  */

#define PARM_BOUNDARY BITS_PER_WORD

/* Largest alignment required for any stack parameter, in bits.

   Don't define this if it is equal to PARM_BOUNDARY */

#define MAX_PARM_BOUNDARY BIGGEST_ALIGNMENT

/* Boundary (in *bits*) on which stack pointer is always aligned;

   certain optimizations in combine depend on this.

   The HP-UX runtime documents mandate 64-byte and 16-byte alignment for

   the stack on the 32 and 64-bit ports, respectively.  However, we

   are only guaranteed that the stack is aligned to BIGGEST_ALIGNMENT

   in main.  Thus, we treat the former as the preferred alignment.  */

#define STACK_BOUNDARY BIGGEST_ALIGNMENT

#define PREFERRED_STACK_BOUNDARY (TARGET_64BIT ? 128 : 512)

/* Allocation boundary (in *bits*) for the code of a function.  */

#define FUNCTION_BOUNDARY BITS_PER_WORD

/* Alignment of field after `int : 0' in a structure.  */

#define EMPTY_FIELD_BOUNDARY 32

/* Every structure's size must be a multiple of this.  */

#define STRUCTURE_SIZE_BOUNDARY 8

/* A bit-field declared as `int' forces `int' alignment for the struct.  */

#define PCC_BITFIELD_TYPE_MATTERS 1

/* No data type wants to be aligned rounder than this.  */

#define BIGGEST_ALIGNMENT (2 * BITS_PER_WORD)

/* Get around hp-ux assembler bug, and make strcpy of constants fast.  */

#define CONSTANT_ALIGNMENT(CODE, TYPEALIGN) \

  ((TYPEALIGN) < 32 ? 32 : (TYPEALIGN))

/* Make arrays of chars word-aligned for the same reasons.  */

#define DATA_ALIGNMENT(TYPE, ALIGN)             \

  (TREE_CODE (TYPE) == ARRAY_TYPE               \

   && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \

   && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))

/* Set this nonzero if move instructions will actually fail to work

   when given unaligned data.  */

#define STRICT_ALIGNMENT 1

/* Value is 1 if it is a good idea to tie two pseudo registers

   when one has mode MODE1 and one has mode MODE2.

   If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,

   for any hard reg, then this must be 0 for correct output.  */

#define MODES_TIEABLE_P(MODE1, MODE2) \

  (GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2))

/* Specify the registers used for certain standard purposes.

   The values of these macros are register numbers.  */

/* The HP-PA pc isn't overloaded on a register that the compiler knows about.  */

/* #define PC_REGNUM  */

/* Register to use for pushing function arguments.  */

#define STACK_POINTER_REGNUM 30

/* Base register for access to local variables of the function.  */

#define FRAME_POINTER_REGNUM 3

/* Value should be nonzero if functions must have frame pointers.  */

#define FRAME_POINTER_REQUIRED \

  (current_function_calls_alloca)

/* Don't allow hard registers to be renamed into r2 unless r2

   is already live or already being saved (due to eh).  */

#define HARD_REGNO_RENAME_OK(OLD_REG, NEW_REG) \

  ((NEW_REG) != 2 || regs_ever_live[2] || current_function_calls_eh_return)

/* C statement to store the difference between the frame pointer

   and the stack pointer values immediately after the function prologue.

   Note, we always pretend that this is a leaf function because if

   it's not, there's no point in trying to eliminate the

   frame pointer.  If it is a leaf function, we guessed right!  */

#define INITIAL_FRAME_POINTER_OFFSET(VAR) \

  do {(VAR) = - compute_frame_size (get_frame_size (), 0);} while (0)

/* Base register for access to arguments of the function.  */

#define ARG_POINTER_REGNUM (TARGET_64BIT ? 29 : 3)

/* Register in which static-chain is passed to a function.  */

#define STATIC_CHAIN_REGNUM (TARGET_64BIT ? 31 : 29)

/* Register used to address the offset table for position-independent

   data references.  */

#define PIC_OFFSET_TABLE_REGNUM \

  (flag_pic ? (TARGET_64BIT ? 27 : 19) : INVALID_REGNUM)

#define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 1

/* Function to return the rtx used to save the pic offset table register

   across function calls.  */

extern struct rtx_def *hppa_pic_save_rtx (void);

#define DEFAULT_PCC_STRUCT_RETURN 0

/* Register in which address to store a structure value

   is passed to a function.  */

#define PA_STRUCT_VALUE_REGNUM 28

/* Describe how we implement __builtin_eh_return.  */

#define EH_RETURN_DATA_REGNO(N) \

  ((N) < 3 ? (N) + 20 : (N) == 3 ? 31 : INVALID_REGNUM)

#define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, 29)

#define EH_RETURN_HANDLER_RTX \

  gen_rtx_MEM (word_mode,                                               \

               gen_rtx_PLUS (word_mode, frame_pointer_rtx,              \

                             TARGET_64BIT ? GEN_INT (-16) : GEN_INT (-20)))

/* Offset from the frame pointer register value to the top of stack.  */

#define FRAME_POINTER_CFA_OFFSET(FNDECL) 0

/* A C expression whose value is RTL representing the location of the

   incoming return address at the beginning of any function, before the

   prologue.  You only need to define this macro if you want to support

   call frame debugging information like that provided by DWARF 2.  */

#define INCOMING_RETURN_ADDR_RTX (gen_rtx_REG (word_mode, 2))

#define DWARF_FRAME_RETURN_COLUMN (DWARF_FRAME_REGNUM (2))

/* A C expression whose value is an integer giving a DWARF 2 column

   number that may be used as an alternate return column.  This should

   be defined only if DWARF_FRAME_RETURN_COLUMN is set to a general

   register, but an alternate column needs to be used for signal frames.

   Column 0 is not used but unfortunately its register size is set to

   4 bytes (sizeof CCmode) so it can't be used on 64-bit targets.  */

#define DWARF_ALT_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER

/* This macro chooses the encoding of pointers embedded in the exception

   handling sections.  If at all possible, this should be defined such

   that the exception handling section will not require dynamic relocations,

   and so may be read-only.

   Because the HP assembler auto aligns, it is necessary to use

   DW_EH_PE_aligned.  It's not possible to make the data read-only

   on the HP-UX SOM port since the linker requires fixups for label

   differences in different sections to be word aligned.  However,

   the SOM linker can do unaligned fixups for absolute pointers.

   We also need aligned pointers for global and function pointers.

   Although the HP-UX 64-bit ELF linker can handle unaligned pc-relative

   fixups, the runtime doesn't have a consistent relationship between

   text and data for dynamically loaded objects.  Thus, it's not possible

   to use pc-relative encoding for pointers on this target.  It may be

   possible to use segment relative encodings but GAS doesn't currently

   have a mechanism to generate these encodings.  For other targets, we

   use pc-relative encoding for pointers.  If the pointer might require

   dynamic relocation, we make it indirect.  */

#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL)                       \

  (TARGET_GAS && !TARGET_HPUX                                           \

   ? (DW_EH_PE_pcrel                                                    \

      | ((GLOBAL) || (CODE) == 2 ? DW_EH_PE_indirect : 0)                \

      | (TARGET_64BIT ? DW_EH_PE_sdata8 : DW_EH_PE_sdata4))             \

   : (!TARGET_GAS || (GLOBAL) || (CODE) == 2                            \

      ? DW_EH_PE_aligned : DW_EH_PE_absptr))

/* Handle special EH pointer encodings.  Absolute, pc-relative, and

   indirect are handled automatically.  We output pc-relative, and

   indirect pc-relative ourself since we need some special magic to

   generate pc-relative relocations, and to handle indirect function

   pointers.  */

#define ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX(FILE, ENCODING, SIZE, ADDR, DONE) \

  do {                                                                  \

    if (((ENCODING) & 0x70) == DW_EH_PE_pcrel)                          \

      {                                                                 \

        fputs (integer_asm_op (SIZE, FALSE), FILE);                     \

        if ((ENCODING) & DW_EH_PE_indirect)                             \

          output_addr_const (FILE, get_deferred_plabel (ADDR));         \

        else                                                            \

          assemble_name (FILE, XSTR ((ADDR), 0));                        \

        fputs ("+8-$PIC_pcrel$0", FILE);                                \

        goto DONE;                                                      \

      }                                                                 \

    } while (0)

/* The letters I, J, K, L and M in a register constraint string

   can be used to stand for particular ranges of immediate operands.

   This macro defines what the ranges are.

   C is the letter, and VALUE is a constant value.

   Return 1 if VALUE is in the range specified by C.

   `I' is used for the 11 bit constants.

   `J' is used for the 14 bit constants.

   `K' is used for values that can be moved with a zdepi insn.

   `L' is used for the 5 bit constants.

   `M' is used for 0.

   `N' is used for values with the least significant 11 bits equal to zero

                          and when sign extended from 32 to 64 bits the

                          value does not change.

   `O' is used for numbers n such that n+1 is a power of 2.

   */

#define CONST_OK_FOR_LETTER_P(VALUE, C)  \

  ((C) == 'I' ? VAL_11_BITS_P (VALUE)                                   \

   : (C) == 'J' ? VAL_14_BITS_P (VALUE)                                 \

   : (C) == 'K' ? zdepi_cint_p (VALUE)                                  \

   : (C) == 'L' ? VAL_5_BITS_P (VALUE)                                  \

   : (C) == 'M' ? (VALUE) == 0                                           \

   : (C) == 'N' ? (((VALUE) & (((HOST_WIDE_INT) -1 << 31) | 0x7ff)) == 0 \

                   || (((VALUE) & (((HOST_WIDE_INT) -1 << 31) | 0x7ff)) \

                       == (HOST_WIDE_INT) -1 << 31))                    \

   : (C) == 'O' ? (((VALUE) & ((VALUE) + 1)) == 0)                       \

   : (C) == 'P' ? and_mask_p (VALUE)                                    \

   : 0)

/* Similar, but for floating or large integer constants, and defining letters

   G and H.   Here VALUE is the CONST_DOUBLE rtx itself.

   For PA, `G' is the floating-point constant zero.  `H' is undefined.  */

#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                          \

  ((C) == 'G' ? (GET_MODE_CLASS (GET_MODE (VALUE)) == MODE_FLOAT        \

                 && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))           \

   : 0)

/* The class value for index registers, and the one for base regs.  */

#define INDEX_REG_CLASS GENERAL_REGS

#define BASE_REG_CLASS GENERAL_REGS

#define FP_REG_CLASS_P(CLASS) \

  ((CLASS) == FP_REGS || (CLASS) == FPUPPER_REGS)

/* True if register is floating-point.  */

#define FP_REGNO_P(N) ((N) >= FP_REG_FIRST && (N) <= FP_REG_LAST)

/* Given an rtx X being reloaded into a reg required to be

   in class CLASS, return the class of reg to actually use.

   In general this is just CLASS; but on some machines

   in some cases it is preferable to use a more restrictive class.  */

#define PREFERRED_RELOAD_CLASS(X,CLASS) (CLASS)

#define MAYBE_FP_REG_CLASS_P(CLASS) \

  reg_classes_intersect_p ((CLASS), FP_REGS)

/* On the PA it is not possible to directly move data between

   GENERAL_REGS and FP_REGS.  On the 32-bit port, we use the

   location at SP-16.  We don't expose this location in the RTL to

   avoid scheduling related problems.  For example, the store and

   load could be separated by a call to a pure or const function

   which has no frame and uses SP-16.  */

#define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE)                   \

  (TARGET_64BIT                                                         \

   && (MAYBE_FP_REG_CLASS_P (CLASS1) != FP_REG_CLASS_P (CLASS2)         \

       || MAYBE_FP_REG_CLASS_P (CLASS2) != FP_REG_CLASS_P (CLASS1)))

/* Stack layout; function entry, exit and calling.  */

/* Define this if pushing a word on the stack

   makes the stack pointer a smaller address.  */

/* #define STACK_GROWS_DOWNWARD */

/* Believe it or not.  */

#define ARGS_GROW_DOWNWARD

/* Define this to nonzero if the nominal address of the stack frame

   is at the high-address end of the local variables;

   that is, each additional local variable allocated

   goes at a more negative offset in the frame.  */

#define FRAME_GROWS_DOWNWARD 0

/* Offset within stack frame to start allocating local variables at.

   If FRAME_GROWS_DOWNWARD, this is the offset to the END of the

   first local allocated.  Otherwise, it is the offset to the BEGINNING

   of the first local allocated.

   On the 32-bit ports, we reserve one slot for the previous frame

   pointer and one fill slot.  The fill slot is for compatibility

   with HP compiled programs.  On the 64-bit ports, we reserve one

   slot for the previous frame pointer.  */

#define STARTING_FRAME_OFFSET 8

/* Define STACK_ALIGNMENT_NEEDED to zero to disable final alignment

   of the stack.  The default is to align it to STACK_BOUNDARY.  */

#define STACK_ALIGNMENT_NEEDED 0

/* If we generate an insn to push BYTES bytes,

   this says how many the stack pointer really advances by.

   On the HP-PA, don't define this because there are no push insns.  */

/*  #define PUSH_ROUNDING(BYTES) */

/* Offset of first parameter from the argument pointer register value.

   This value will be negated because the arguments grow down.

   Also note that on STACK_GROWS_UPWARD machines (such as this one)

   this is the distance from the frame pointer to the end of the first

   argument, not it's beginning.  To get the real offset of the first

   argument, the size of the argument must be added.  */

#define FIRST_PARM_OFFSET(FNDECL) (TARGET_64BIT ? -64 : -32)

/* When a parameter is passed in a register, stack space is still

   allocated for it.  */

#define REG_PARM_STACK_SPACE(DECL) (TARGET_64BIT ? 64 : 16)

/* Define this if the above stack space is to be considered part of the

   space allocated by the caller.  */

#define OUTGOING_REG_PARM_STACK_SPACE

/* Keep the stack pointer constant throughout the function.

   This is both an optimization and a necessity: longjmp

   doesn't behave itself when the stack pointer moves within

   the function!  */

#define ACCUMULATE_OUTGOING_ARGS 1

/* The weird HPPA calling conventions require a minimum of 48 bytes on

   the stack: 16 bytes for register saves, and 32 bytes for magic.

   This is the difference between the logical top of stack and the

   actual sp.

   On the 64-bit port, the HP C compiler allocates a 48-byte frame

   marker, although the runtime documentation only describes a 16

   byte marker.  For compatibility, we allocate 48 bytes.  */

#define STACK_POINTER_OFFSET \

  (TARGET_64BIT ? -(current_function_outgoing_args_size + 48): -32)

#define STACK_DYNAMIC_OFFSET(FNDECL)    \

  (TARGET_64BIT                         \

   ? (STACK_POINTER_OFFSET)             \

   : ((STACK_POINTER_OFFSET) - current_function_outgoing_args_size))

/* Value is 1 if returning from a function call automatically

   pops the arguments described by the number-of-args field in the call.

   FUNDECL is the declaration node of the function (as a tree),

   FUNTYPE is the data type of the function (as a tree),

   or for a library call it is an identifier node for the subroutine name.  */

#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0

/* Define how to find the value returned by a function.

   VALTYPE is the data type of the value (as a tree).

   If the precise function being called is known, FUNC is its FUNCTION_DECL;

   otherwise, FUNC is 0.  */

#define FUNCTION_VALUE(VALTYPE, FUNC) function_value (VALTYPE, FUNC)

/* Define how to find the value returned by a library function

   assuming the value has mode MODE.  */

#define LIBCALL_VALUE(MODE)     \

  gen_rtx_REG (MODE,                                                    \

               (! TARGET_SOFT_FLOAT                                     \

                && ((MODE) == SFmode || (MODE) == DFmode) ? 32 : 28))

/* 1 if N is a possible register number for a function value

   as seen by the caller.  */

#define FUNCTION_VALUE_REGNO_P(N) \

  ((N) == 28 || (! TARGET_SOFT_FLOAT && (N) == 32))

/* Define a data type for recording info about an argument list

   during the scan of that argument list.  This data type should

   hold all necessary information about the function itself

   and about the args processed so far, enough to enable macros

   such as FUNCTION_ARG to determine where the next arg should go.

   On the HP-PA, the WORDS field holds the number of words

   of arguments scanned so far (including the invisible argument,

   if any, which holds the structure-value-address).  Thus, 4 or

   more means all following args should go on the stack.

   The INCOMING field tracks whether this is an "incoming" or

   "outgoing" argument.

   The INDIRECT field indicates whether this is is an indirect

   call or not.

   The NARGS_PROTOTYPE field indicates that an argument does not

   have a prototype when it less than or equal to 0.  */

struct hppa_args {int words, nargs_prototype, incoming, indirect; };

#define CUMULATIVE_ARGS struct hppa_args

/* Initialize a variable CUM of type CUMULATIVE_ARGS

   for a call to a function whose data type is FNTYPE.

   For a library call, FNTYPE is 0.  */

#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \

  (CUM).words = 0,                                                       \

  (CUM).incoming = 0,                                                    \

  (CUM).indirect = (FNTYPE) && !(FNDECL),                               \

  (CUM).nargs_prototype = (FNTYPE && TYPE_ARG_TYPES (FNTYPE)            \

                           ? (list_length (TYPE_ARG_TYPES (FNTYPE)) - 1 \

                              + (TYPE_MODE (TREE_TYPE (FNTYPE)) == BLKmode \

                                 || pa_return_in_memory (TREE_TYPE (FNTYPE), 0))) \

                           : 0)

/* Similar, but when scanning the definition of a procedure.  We always

   set NARGS_PROTOTYPE large so we never return a PARALLEL.  */

#define INIT_CUMULATIVE_INCOMING_ARGS(CUM,FNTYPE,IGNORE) \

  (CUM).words = 0,                               \

  (CUM).incoming = 1,                           \

  (CUM).indirect = 0,                            \

  (CUM).nargs_prototype = 1000

/* Figure out the size in words of the function argument.  The size

   returned by this macro should always be greater than zero because

   we pass variable and zero sized objects by reference.  */

#define FUNCTION_ARG_SIZE(MODE, TYPE)   \

  ((((MODE) != BLKmode \

     ? (HOST_WIDE_INT) GET_MODE_SIZE (MODE) \

     : int_size_in_bytes (TYPE)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)

/* Update the data in CUM to advance over an argument

   of mode MODE and data type TYPE.

   (TYPE is null for libcalls where that information may not be available.)  */

#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \

{ (CUM).nargs_prototype--;                                              \

  (CUM).words += FUNCTION_ARG_SIZE(MODE, TYPE)                          \

    + (((CUM).words & 01) && (TYPE) != 0                         \

        && FUNCTION_ARG_SIZE(MODE, TYPE) > 1);                          \

}

/* Determine where to put an argument to a function.

   Value is zero to push the argument on the stack,

   or a hard register in which to store the argument.

   MODE is the argument's machine mode.

   TYPE is the data type of the argument (as a tree).

    This is null for libcalls where that information may

    not be available.

   CUM is a variable of type CUMULATIVE_ARGS which gives info about

    the preceding args and about the function being called.

   NAMED is nonzero if this argument is a named parameter

    (otherwise it is an extra parameter matching an ellipsis).

   On the HP-PA the first four words of args are normally in registers

   and the rest are pushed.  But any arg that won't entirely fit in regs

   is pushed.

   Arguments passed in registers are either 1 or 2 words long.

   The caller must make a distinction between calls to explicitly named

   functions and calls through pointers to functions -- the conventions

   are different!  Calls through pointers to functions only use general

   registers for the first four argument words.

   Of course all this is different for the portable runtime model

   HP wants everyone to use for ELF.  Ugh.  Here's a quick description

   of how it's supposed to work.

   1) callee side remains unchanged.  It expects integer args to be

   in the integer registers, float args in the float registers and

   unnamed args in integer registers.

   2) caller side now depends on if the function being called has

   a prototype in scope (rather than if it's being called indirectly).

      2a) If there is a prototype in scope, then arguments are passed

      according to their type (ints in integer registers, floats in float

      registers, unnamed args in integer registers.

      2b) If there is no prototype in scope, then floating point arguments

      are passed in both integer and float registers.  egad.

  FYI: The portable parameter passing conventions are almost exactly like

  the standard parameter passing conventions on the RS6000.  That's why

  you'll see lots of similar code in rs6000.h.  */

/* If defined, a C expression which determines whether, and in which

   direction, to pad out an argument with extra space.  */

#define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding ((MODE), (TYPE))

/* Specify padding for the last element of a block move between registers

   and memory.

   The 64-bit runtime specifies that objects need to be left justified

   (i.e., the normal justification for a big endian target).  The 32-bit

   runtime specifies right justification for objects smaller than 64 bits.

   We use a DImode register in the parallel for 5 to 7 byte structures

   so that there is only one element.  This allows the object to be

   correctly padded.  */

#define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \

  function_arg_padding ((MODE), (TYPE))

/* Do not expect to understand this without reading it several times.  I'm

   tempted to try and simply it, but I worry about breaking something.  */

#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \

  function_arg (&CUM, MODE, TYPE, NAMED)