{ register int regno;						\  register int mask, fmask;					\  register int nregs;						\  int offset, foffset, fpoffset;				\  extern char call_used_regs[];					\  extern int current_function_pops_args;			\  extern int current_function_args_size;			\  int fsize = ((SIZE) + 3) & -4;				\  int big = 0;							\  FUNCTION_EXTRA_EPILOGUE (FILE, SIZE);				\  nregs = 0;  fmask = 0; fpoffset = 0;				\  for (regno = 24 ; regno < 56 ; regno++)			\    if (regs_ever_live[regno] && ! call_used_regs[regno])	\      nregs++;							\  fpoffset = nregs*8;						\  nregs = 0;							\  for (regno = 16; regno < 24; regno++)				\    if (regs_ever_live[regno] && ! call_used_regs[regno])	\      { nregs++; fmask |= 1 << (23 - regno); }			\  foffset = fpoffset + nregs * 12;				\  nregs = 0;  mask = 0;						\  if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \  for (regno = 0; regno < 16; regno++)				\    if (regs_ever_live[regno] && ! call_used_regs[regno])	\      { nregs++; mask |= 1 << regno; }				\  offset = foffset + nregs * 4;					\  if (offset + fsize >= 0x8000 					\      && frame_pointer_needed 					\      && (mask || fmask || fpoffset)) 				\    { fprintf (FILE, "\tmovel #%d,a0\n", -fsize);		\      fsize = 0, big = 1; }					\  if (exact_log2 (mask) >= 0) {					\    if (big)							\      fprintf (FILE, "\tmovel a6@(-%d,a0:l),%s\n",		\	       offset + fsize, reg_names[exact_log2 (mask)]);	\    else if (! frame_pointer_needed)				\      fprintf (FILE, "\tmovel sp@+,%s\n",			\	       reg_names[exact_log2 (mask)]);			\    else							\      fprintf (FILE, "\tmovel a6@(-%d),%s\n",			\	       offset + fsize, reg_names[exact_log2 (mask)]); }	\  else if (mask) {						\    if (big)							\      fprintf (FILE, "\tmoveml a6@(-%d,a0:l),#0x%x\n",		\	       offset + fsize, mask);				\    else if (! frame_pointer_needed)				\      fprintf (FILE, "\tmoveml sp@+,#0x%x\n", mask);		\    else							\      fprintf (FILE, "\tmoveml a6@(-%d),#0x%x\n",		\	       offset + fsize, mask); }				\  if (fmask) {							\    if (big)							\      fprintf (FILE, "\tfmovem a6@(-%d,a0:l),#0x%x\n",		\	       foffset + fsize, fmask);				\    else if (! frame_pointer_needed)				\      fprintf (FILE, "\tfmovem sp@+,#0x%x\n", fmask);		\    else							\      fprintf (FILE, "\tfmovem a6@(-%d),#0x%x\n",		\	       foffset + fsize, fmask); }			\  if (fpoffset != 0)						\    for (regno = 55; regno >= 24; regno--)			\      if (regs_ever_live[regno] && ! call_used_regs[regno]) {	\	if (big)						\	  fprintf(FILE, "\tfpmoved a6@(-%d,a0:l), %s\n",	\		  fpoffset + fsize, reg_names[regno]);		\	else if (! frame_pointer_needed)			\	  fprintf(FILE, "\tfpmoved sp@+, %s\n",			\		  reg_names[regno]);				\	else							\	  fprintf(FILE, "\tfpmoved a6@(-%d), %s\n",		\		  fpoffset + fsize, reg_names[regno]);		\	fpoffset -= 8;						\      }								\  if (frame_pointer_needed)					\    fprintf (FILE, "\tunlk a6\n");				\  if (current_function_pops_args && current_function_args_size)	\    fprintf (FILE, "\trtd #%d\n", current_function_args_size);	\  else fprintf (FILE, "\trts\n"); }/* This is a hook for other tm files to change.  */#define FUNCTION_EXTRA_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 = 16; regno < FIRST_PSEUDO_REGISTER; regno++)		\        if (regs_ever_live[regno] && ! call_used_regs[regno])		\          offset += 12;							\      for (regno = 0; regno < 16; 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) < 16 || (unsigned) reg_renumber[REGNO] < 16)#define REGNO_OK_FOR_BASE_P(REGNO) \(((REGNO) ^ 010) < 8 || (unsigned) (reg_renumber[REGNO] ^ 010) < 8)#define REGNO_OK_FOR_DATA_P(REGNO) \((REGNO) < 8 || (unsigned) reg_renumber[REGNO] < 8)#define REGNO_OK_FOR_FP_P(REGNO) \(((REGNO) ^ 020) < 8 || (unsigned) (reg_renumber[REGNO] ^ 020) < 8)#define REGNO_OK_FOR_FPA_P(REGNO) \(((REGNO) >= 24 && (REGNO) < 56) || (reg_renumber[REGNO] >= 24 && reg_renumber[REGNO] < 56))/* Now macros that check whether X is a register and also,   strictly, whether it is in a specified class.   These macros are specific to the 68000, and may be used only   in code for printing assembler insns and in conditions for   define_optimization.  *//* 1 if X is a data register.  */#define DATA_REG_P(X) (REG_P (X) && REGNO_OK_FOR_DATA_P (REGNO (X)))/* 1 if X is an fp register.  */#define FP_REG_P(X) (REG_P (X) && REGNO_OK_FOR_FP_P (REGNO (X)))/* 1 if X is an address register  */#define ADDRESS_REG_P(X) (REG_P (X) && REGNO_OK_FOR_BASE_P (REGNO (X)))/* 1 if X is a register in the Sun FPA.  */#define FPA_REG_P(X) (REG_P (X) && REGNO_OK_FOR_FPA_P (REGNO (X)))/* Maximum number of registers that can appear in a valid memory address.  */#define MAX_REGS_PER_ADDRESS 2/* Recognize any constant value that is a valid address.  */#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/* 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) ^ 020) >= 8)/* Nonzero if X is a hard reg that can be used as a base reg   or if it is a pseudo reg.  */#define REG_OK_FOR_BASE_P(X) ((REGNO (X) & ~027) != 0)#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))#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.  */#define INDIRECTABLE_1_ADDRESS_P(X)  \  (CONSTANT_ADDRESS_P (X)						\   || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X))			\   || ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC)		\       && REG_P (XEXP (X, 0))						\       && REG_OK_FOR_BASE_P (XEXP (X, 0)))				\   || (GET_CODE (X) == PLUS						\       && REG_P (XEXP (X, 0)) && REG_OK_FOR_BASE_P (XEXP (X, 0))	\       && GET_CODE (XEXP (X, 1)) == CONST_INT				\       && ((unsigned) INTVAL (XEXP (X, 1)) + 0x8000) < 0x10000))#if 0/* This should replace the last two lines   except that Sun's assembler does not seem to handle such operands.  */       && (TARGET_68020 ? CONSTANT_ADDRESS_P (XEXP (X, 1))		\	   : (GET_CODE (XEXP (X, 1)) == CONST_INT			\	      && ((unsigned) INTVAL (XEXP (X, 1)) + 0x8000) < 0x10000))))#endif#define GO_IF_NONINDEXED_ADDRESS(X, ADDR)  \{ if (INDIRECTABLE_1_ADDRESS_P (X)) goto ADDR; }#define GO_IF_INDEXABLE_BASE(X, ADDR)	\{ if (GET_CODE (X) == LABEL_REF) goto ADDR;				\  if (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) goto ADDR; }#define GO_IF_INDEXING(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); } }#define GO_IF_INDEXED_ADDRESS(X, ADDR)	 \{ GO_IF_INDEXING (X, ADDR);						\  if (GET_CODE (X) == PLUS)						\    { if (GET_CODE (XEXP (X, 1)) == CONST_INT				\	  && (unsigned) INTVAL (XEXP (X, 1)) + 0x80 < 0x100)		\	{ rtx go_temp = XEXP (X, 0); GO_IF_INDEXING (go_temp, ADDR); }	\      if (GET_CODE (XEXP (X, 0)) == CONST_INT				\	  && (unsigned) INTVAL (XEXP (X, 0)) + 0x80 < 0x100)		\	{ rtx go_temp = XEXP (X, 1); GO_IF_INDEXING (go_temp, ADDR); } } }#define LEGITIMATE_INDEX_REG_P(X)   \  ((GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X))	\   || (GET_CODE (X) == SIGN_EXTEND			\       && GET_CODE (XEXP (X, 0)) == REG			\       && GET_MODE (XEXP (X, 0)) == HImode		\       && REG_OK_FOR_INDEX_P (XEXP (X, 0))))#define LEGITIMATE_INDEX_P(X)   \   (LEGITIMATE_INDEX_REG_P (X)				\    || (TARGET_68020 && 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)))#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)  \{ GO_IF_NONINDEXED_ADDRESS (X, ADDR);			\  GO_IF_INDEXED_ADDRESS (X, 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 68000, we handle X+REG by loading X into a register R and   using R+REG.  R will go in an address 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 an address reg.  */#define COPY_ONCE(Y) if (!copied) { Y = copy_rtx (Y); copied = ch = 1; }#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)   \{ register int ch = (X) != (OLDX);					\  if (GET_CODE (X) == PLUS)						\    { int copied = 0;							\      if (GET_CODE (XEXP (X, 0)) == MULT)				\	{ COPY_ONCE (X); XEXP (X, 0) = force_operand (XEXP (X, 0), 0);}	\      if (GET_CODE (XEXP (X, 1)) == MULT)				\	{ COPY_ONCE (X); XEXP (X, 1) = force_operand (XEXP (X, 1), 0);}	\      if (ch && GET_CODE (XEXP (X, 1)) == REG				\	  && GET_CODE (XEXP (X, 0)) == REG)				\	return X;							\      if (ch) { GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); }		\      if (GET_CODE (XEXP (X, 0)) == REG					\	       || (GET_CODE (XEXP (X, 0)) == SIGN_EXTEND		\		   && GET_CODE (XEXP (XEXP (X, 0), 0)) == REG		\		   && GET_MODE (XEXP (XEXP (X, 0), 0)) == HImode))	\	{ register rtx temp = gen_reg_rtx (Pmode);			\	  register rtx val = force_operand (XEXP (X, 1), 0);		\	  emit_move_insn (temp, val);					\