except in the FP regs, where a single reg is always enough.  */#define CLASS_MAX_NREGS(CLASS, MODE)	\ ((CLASS) == FLOAT_REGS ? 1 :			\   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))/* 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/* Define this 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/* 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.  */#define STARTING_FRAME_OFFSET 0/* If we generate an insn to push BYTES bytes,   this says how many the stack pointer really advances by.   On 386 pushw decrements by exactly 2 no matter what the position was.   On the 386 there is no pushb; we use pushw instead, and this   has the effect of rounding up to 2.  */#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & (-2))/* Offset of first parameter from the argument pointer register value.  */#define FIRST_PARM_OFFSET(FNDECL) 8/* Value is 1 if returning from a function call automatically   pops the arguments described by the number-of-args field in the call.   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.   On the 80386, the RTD insn may be used to pop them if the number     of args is fixed, but if the number is variable then the caller     must pop them all.  RTD can't be used for library calls now     because the library is compiled with the Unix compiler.   Use of RTD is a selectable option, since it is incompatible with   standard Unix calling sequences.  If the option is not selected,   the caller must always pop the args.  */#define RETURN_POPS_ARGS(FUNTYPE)   \  (TARGET_RTD && TREE_CODE (FUNTYPE) != IDENTIFIER_NODE		\   && (TYPE_ARG_TYPES (FUNTYPE) == 0				\       || TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE))) == void_type_node))#define FUNCTION_VALUE(VALTYPE, FUNC)  \   gen_rtx (REG, TYPE_MODE (VALTYPE), \	    VALUE_REGNO(TYPE_MODE(VALTYPE)))/* 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, VALUE_REGNO(MODE))/* 1 if N is a possible register number for function argument passing.   On the 80386, no registers are used in this way.      *NOTE* -mregparm does not work.   It exists only to test register calling conventions.  */#define FUNCTION_ARG_REGNO_P(N) 0/* 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 80386, this is a single integer, which is a number of bytes   of arguments scanned so far.  */#define CUMULATIVE_ARGS int/* 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.   On the 80386, the offset starts at 0.  */#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE)	\ ((CUM) = 0)/* 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) += ((MODE) != BLKmode			\	    ? (GET_MODE_SIZE (MODE) + 3) & ~3	\	    : (int_size_in_bytes (TYPE) + 3) & ~3))/* Define where to put the arguments 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 80386 all args are pushed, except if -mregparm is specified   then the first two words of arguments are passed in EAX, EDX.   *NOTE* -mregparm does not work.   It exists only to test register calling conventions.  */#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \((TARGET_REGPARM && (CUM) < 8) ? gen_rtx (REG, (MODE), (CUM) / 4) : 0)/* For an arg passed partly in registers and partly in memory,   this is the number of registers used.   For args passed entirely in registers or entirely in memory, zero.  */#define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) \((TARGET_REGPARM && (CUM) < 8					\  && 8 < ((CUM) + ((MODE) == BLKmode				\		      ? int_size_in_bytes (TYPE)		\		      : GET_MODE_SIZE (MODE))))  		\ ? 2 - (CUM) / 4 : 0)/* This macro generates the assembly code for function entry.   FILE is a stdio stream to output the code to.   SIZE is an int: how many units of temporary storage to allocate.   Refer to the array `regs_ever_live' to determine which registers   to save; `regs_ever_live[I]' is nonzero if register number I   is ever used in the function.  This macro is responsible for   knowing which registers should not be saved even if used.  */#define FUNCTION_PROLOGUE(FILE, SIZE)     \  function_prologue (FILE, SIZE)/* Output assembler code to FILE to increment profiler label # LABELNO   for profiling a function entry.  */#define FUNCTION_PROFILER(FILE, LABELNO)  \   fprintf (FILE, "\tmovl $%sP%d,%%edx\n\tcall _mcount\n", LPREFIX, (LABELNO));/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,   the stack pointer does not matter.  The value is tested only in   functions that have frame pointers.   No definition is equivalent to always zero.  *//* Note on the 386 it might be more efficient not to define this since    we have to restore it ourselves from the frame pointer, in order to   use pop */#define EXIT_IGNORE_STACK 1/* This macro generates the assembly code for function exit,   on machines that need it.  If FUNCTION_EPILOGUE is not defined   then individual return instructions are generated for each   return statement.  Args are same as for FUNCTION_PROLOGUE.   The function epilogue should not depend on the current stack pointer!   It should use the frame pointer only.  This is mandatory because   of alloca; we also take advantage of it to omit stack adjustments   before returning.  */#define FUNCTION_EPILOGUE(FILE, SIZE) \  function_epilogue (FILE, SIZE)/* If the memory address ADDR is relative to the frame pointer,   correct it to be relative to the stack pointer instead.   This is for when we don't use a frame pointer.   ADDR should be a variable name.  */#define FIX_FRAME_POINTER_ADDRESS(ADDR,DEPTH)  \{ int offset = -1;							\  rtx regs = stack_pointer_rtx;						\  if (ADDR == frame_pointer_rtx)					\    offset = 0;								\  else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 0) == frame_pointer_rtx \	   && GET_CODE (XEXP (ADDR, 1)) == CONST_INT)			\    offset = INTVAL (XEXP (ADDR, 1));					\  else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 0) == frame_pointer_rtx) \    { rtx other_reg = XEXP (ADDR, 1);					\      offset = 0;							\      regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); }	\  else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 1) == frame_pointer_rtx) \    { rtx other_reg = XEXP (ADDR, 0);					\      offset = 0;							\      regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); }	\  else if (GET_CODE (ADDR) == PLUS					\	   && GET_CODE (XEXP (ADDR, 0)) == PLUS				\	   && XEXP (XEXP (ADDR, 0), 0) == frame_pointer_rtx		\	   && GET_CODE (XEXP (ADDR, 1)) == CONST_INT)			\    { rtx other_reg = XEXP (XEXP (ADDR, 0), 1);				\      offset = INTVAL (XEXP (ADDR, 1));					\      regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); }	\  else if (GET_CODE (ADDR) == PLUS					\	   && GET_CODE (XEXP (ADDR, 0)) == PLUS				\	   && XEXP (XEXP (ADDR, 0), 1) == frame_pointer_rtx		\	   && GET_CODE (XEXP (ADDR, 1)) == CONST_INT)			\    { rtx other_reg = XEXP (XEXP (ADDR, 0), 0);				\      offset = INTVAL (XEXP (ADDR, 1));					\      regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); }	\  if (offset >= 0)							\    { int regno;							\      extern char call_used_regs[];					\      for (regno = FIRST_FLOAT_REG; regno < FIRST_PSEUDO_REGISTER; regno++)\	if (regs_ever_live[regno] && ! call_used_regs[regno])		\	  offset += 8;							\      for (regno=0 ; regno <FIRST_FLOAT_REG ; regno++)   		\	if (regs_ever_live[regno] && ! call_used_regs[regno])		\	  offset += 4;							\      offset -= 4;							\      ADDR = plus_constant (regs, offset + (DEPTH)); } }/* Addressing modes, and classification of registers for them.  *//* #define HAVE_POST_INCREMENT *//* #define HAVE_POST_DECREMENT *//* #define HAVE_PRE_DECREMENT *//* #define HAVE_PRE_INCREMENT *//* Macros to check register numbers against specific register classes.  *//* These assume that REGNO is a hard or pseudo reg number.   They give nonzero only if REGNO is a hard reg of the suitable class   or a pseudo reg currently allocated to a suitable hard reg.   Since they use reg_renumber, they are safe only once reg_renumber   has been allocated, which happens in local-alloc.c.  */#define REGNO_OK_FOR_INDEX_P(REGNO) \  ((REGNO) < STACK_POINTER_REGNUM || (unsigned) reg_renumber[REGNO] < STACK_POINTER_REGNUM)#define REGNO_OK_FOR_BASE_P(REGNO) \  ((REGNO) <= STACK_POINTER_REGNUM || (unsigned) reg_renumber[REGNO] <= STACK_POINTER_REGNUM)#define REGNO_OK_FOR_SIREG_P(REGNO) ((REGNO) == 4 || reg_renumber[REGNO] == 4)#define REGNO_OK_FOR_DIREG_P(REGNO) ((REGNO) == 5 || reg_renumber[REGNO] == 5)/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx   and check its validity for a certain class.   We have two alternate definitions for each of them.   The usual definition accepts all pseudo regs; the other rejects   them unless they have been allocated suitable hard regs.   The symbol REG_OK_STRICT causes the latter definition to be used.   Most source files want to accept pseudo regs in the hope that   they will get allocated to the class that the insn wants them to be in.   Source files for reload pass need to be strict.   After reload, it makes no difference, since pseudo regs have   been eliminated by then.  */#ifndef REG_OK_STRICT/* Nonzero if X is a hard reg that can be used as an index or if   it is a pseudo reg.  */#define REG_OK_FOR_INDEX_P(X) (REGNO (X) < STACK_POINTER_REGNUM || REGNO (X) >= FIRST_PSEUDO_REGISTER)/* Nonzero if X is a hard reg that can be used as a base reg   of if it is a pseudo reg.  */  /* ?wfs */#define REG_OK_FOR_BASE_P(X) (REGNO (X) <= STACK_POINTER_REGNUM || REGNO(X) >= FIRST_PSEUDO_REGISTER)#define REG_OK_FOR_STRREG_P(X) \  (REGNO (X) == 4 || REGNO (X) == 5 || REGNO (X) >= FIRST_PSEUDO_REGISTER)#else/* Nonzero if X is a hard reg that can be used as an index.  */#define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))/* Nonzero if X is a hard reg that can be used as a base reg.  */#define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))#define REG_OK_FOR_STRREG_P(X) \  (REGNO_OK_FOR_DIREG_P (REGNO (X)) || REGNO_OK_FOR_SIREG_P (REGNO (X)))#endif/* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression   that is a valid memory address for an instruction.   The MODE argument is the machine mode for the MEM expression   that wants to use this address.   The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,   except for CONSTANT_ADDRESS_P which is usually machine-independent.  */#define MAX_REGS_PER_ADDRESS 2#define CONSTANT_ADDRESS_P(X)   CONSTANT_P (X)/* Nonzero if the constant value X is a legitimate general operand.   It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */#define LEGITIMATE_CONSTANT_P(X) 1#define GO_IF_INDEXABLE_BASE(X, ADDR)	\ if (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) goto ADDR#define LEGITIMATE_INDEX_REG_P(X)   \  (GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X))/* Return 1 if X is an index or an index times a scale.  */#define LEGITIMATE_INDEX_P(X)   \   (LEGITIMATE_INDEX_REG_P (X)				\    || (GET_CODE (X) == MULT				\	&& LEGITIMATE_INDEX_REG_P (XEXP (X, 0))		\	&& GET_CODE (XEXP (X, 1)) == CONST_INT		\	&& (INTVAL (XEXP (X, 1)) == 2			\	    || INTVAL (XEXP (X, 1)) == 4		\	    || INTVAL (XEXP (X, 1)) == 8)))/* Go to ADDR if X is an index term, a base reg, or a sum of those.  */#define GO_IF_INDEXING(X, ADDR)	\{ if (LEGITIMATE_INDEX_P (X)) goto ADDR;				\  GO_IF_INDEXABLE_BASE (X, ADDR);					\  if (GET_CODE (X) == PLUS && LEGITIMATE_INDEX_P (XEXP (X, 0)))		\    { GO_IF_INDEXABLE_BASE (XEXP (X, 1), ADDR); }			\  if (GET_CODE (X) == PLUS && LEGITIMATE_INDEX_P (XEXP (X, 1)))		\    { GO_IF_INDEXABLE_BASE (XEXP (X, 0), ADDR); } }/* We used to allow this, but it isn't ever used.   || ((GET_CODE (X) == POST_DEC || GET_CODE (X) == POST_INC)		\       && REG_P (XEXP (X, 0))						\       && REG_OK_FOR_STRREG_P (XEXP (X, 0)))				\*/#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \{ if (CONSTANT_ADDRESS_P (X)) goto ADDR;				\  GO_IF_INDEXING (X, ADDR);						\  if (GET_CODE (X) == PLUS)						\    { if (CONSTANT_ADDRESS_P (XEXP (X, 1)))				\	GO_IF_INDEXING (XEXP (X, 0), ADDR);				\      if (CONSTANT_ADDRESS_P (XEXP (X, 0)))				\	GO_IF_INDEXING (XEXP (X, 1), ADDR); } }/* Try machine-dependent ways of modifying an illegitimate address   to be legitimate.  If we find one, return the new, valid address.   This macro is used in only one place: `memory_address' in explow.c.   OLDX is the address as it was before break_out_memory_refs was called.   In some cases it is useful to look at this to decide what needs to be done.   MODE and WIN are passed so that this macro can use   GO_IF_LEGITIMATE_ADDRESS.   It is always safe for this macro to do nothing.  It exists to recognize   opportunities to optimize the output.   For the 80386, we handle X+REG by loading X into a register R and   using R+REG.  R will go in a general reg and indexing will be used.   However, if REG is a broken-out memory address or multiplication,   nothing needs to be done because REG can certainly go in a general reg.  */#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)   \{ register int ch = (X) != (OLDX);					\  if (GET_CODE (X) == PLUS)						\    { if (GET_CODE (XEXP (X, 0)) == MULT)				\	ch = 1, XEXP (X, 0) = force_operand (XEXP (X, 0), 0);		\      if (GET_CODE (XEXP (X, 1)) == MULT)				\	ch = 1, XEXP (X, 1) = force_operand (XEXP (X, 1), 0);		\