tm-ns32k.h

这是完整的gcc源代码

/* Likewise for `char' and `short' constants.  */

#define ASM_OUTPUT_SHORT(FILE,VALUE)  \
( fprintf (FILE, "\t.word "),			\
  output_addr_const (FILE, (VALUE)),		\
  fprintf (FILE, "\n"))

#define ASM_OUTPUT_CHAR(FILE,VALUE)  \
( fprintf (FILE, "\t.byte "),			\
  output_addr_const (FILE, (VALUE)),		\
  fprintf (FILE, "\n"))

/* This is how to output an assembler line for a numeric constant byte.  */

#define ASM_OUTPUT_BYTE(FILE,VALUE)  \
  fprintf (FILE, "\t.byte 0x%x\n", (VALUE))

/* This is how to output an insn to push a register on the stack.
   It need not be very fast code.  */

#define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
  fprintf (FILE, "\tmovd %s,tos\n", reg_names[REGNO])

/* This is how to output an insn to pop a register from the stack.
   It need not be very fast code.  */

#define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
  fprintf (FILE, "\tmovd tos,%s\n", reg_names[REGNO])

/* This is how to output an element of a case-vector that is absolute.
   (The 68000 does not use such vectors,
   but we must define this macro anyway.)  */

#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
  fprintf (FILE, "\t.long L%d\n", VALUE)

/* This is how to output an element of a case-vector that is relative.  */
/* ** Notice that the second element is LI format! */
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  \
  fprintf (FILE, "\t.word L%d-LI%d\n", VALUE, REL)

/* This is how to output an assembler line
   that says to advance the location counter
   to a multiple of 2**LOG bytes.  */

#define ASM_OUTPUT_ALIGN(FILE,LOG)  \
  fprintf (FILE, "\t.align %d\n", (LOG))

#define ASM_OUTPUT_SKIP(FILE,SIZE)  \
  fprintf (FILE, "\t.space %u\n", (SIZE))

/* This says how to output an assembler line
   to define a global common symbol.  */

#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
( fputs (".comm ", (FILE)),			\
  assemble_name ((FILE), (NAME)),		\
  fprintf ((FILE), ",%u\n", (ROUNDED)))

/* This says how to output an assembler line
   to define a local common symbol.  */

#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
( fputs (".lcomm ", (FILE)),			\
  assemble_name ((FILE), (NAME)),		\
  fprintf ((FILE), ",%u\n", (ROUNDED)))

/* Store in OUTPUT a string (made with alloca) containing
   an assembler-name for a local static variable named NAME.
   LABELNO is an integer which is different for each call.  */

#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)	\
( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),	\
  sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))

/* Define the parentheses used to group arithmetic operations
   in assembler code.  */

#define ASM_OPEN_PAREN "("
#define ASM_CLOSE_PAREN ")"

/* Define results of standard character escape sequences.  */
#define TARGET_BELL 007
#define TARGET_BS 010
#define TARGET_TAB 011
#define TARGET_NEWLINE 012
#define TARGET_VT 013
#define TARGET_FF 014
#define TARGET_CR 015

/* Print an instruction operand X on file FILE.
   CODE is the code from the %-spec that requested printing this operand;
   if `%z3' was used to print operand 3, then CODE is 'z'. */

/* %$ means print the prefix for an immediate operand.  */

#define PRINT_OPERAND_PUNCT_VALID_P(CODE)				\
  ((CODE) == '$' || (CODE) == '?')

#define PRINT_OPERAND(FILE, X, CODE)  \
{ if (CODE == '$') fprintf (FILE, "$");					\
  else if (CODE == '?');						\
  else if (GET_CODE (X) == REG)						\
    fprintf (FILE, "%s", reg_names[REGNO (X)]);				\
  else if (GET_CODE (X) == MEM)						\
    output_address (XEXP (X, 0));					\
  else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode)	\
    if (GET_MODE (X) == DFmode)						\
      { union { double d; int i[2]; } u;				\
	u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);	\
	fprintf (FILE, "$0d%.20e", u.d); }				\
    else								\
      { union { double d; int i[2]; } u;				\
	u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);	\
	fprintf (FILE, "$0f%.20e", u.d); }				\
  else { putc ('$', FILE); output_addr_const (FILE, X); }}

/* Print a memory operand whose address is X, on file FILE.  */

#define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
{ register rtx reg1, reg2, breg, ireg;					\
  register rtx addr = ADDR;						\
  rtx offset;								\
  int mem=0, multval, offset_printed;					\
  char reg1_str[256], reg2_str[256];					\
 retry:									\
  switch (GET_CODE (addr))						\
    {									\
    case MEM:								\
      fprintf (FILE, "0(");						\
      addr = XEXP (addr, 0);						\
      mem =1;								\
      goto retry;		 					\
    case REG:								\
      fprintf (FILE, "0(%s)", reg_names[REGNO (addr)]);			\
      break;								\
    case PRE_DEC:							\
      if (REGNO(XEXP(addr, 0)) != STACK_POINTER_REGNUM)			\
         fprintf(FILE, ")1:%d", REGNO(XEXP(addr,0)));			\
      else fprintf (FILE, "tos", reg_names[REGNO (XEXP (addr, 0))]);	\
      break;								\
    case POST_INC:							\
      if (REGNO(XEXP(addr, 0)) != STACK_POINTER_REGNUM)			\
         fprintf(FILE, ")2:%d", REGNO(XEXP(addr,0)));			\
      else fprintf (FILE, "tos", reg_names[REGNO (XEXP (addr, 0))]);	\
      break;								\
    case MULT:								\
      reg1 = XEXP (addr, 0); /* [rX:Y] */				\
      reg2 = XEXP (addr, 1); /* CONST/REG */				\
      if (GET_CODE (reg1) == CONST_INT && GET_CODE(reg2) == REG) {	\
	reg1 = reg2;							\
        reg2 = XEXP (addr, 0); /* [rX:Y] */				\
      }	else								\
      if (GET_CODE (reg2) != CONST_INT ||				\
	    GET_CODE (reg1) != REG) {					\
	  abort();							\
      }									\
      fprintf (FILE, "0[%s:%c]", 					\
	reg_names[ REGNO(reg1) ],					\
	"XbwXdXXXq"[INTVAL (reg2)]);			        	\
      break;								\
    case PLUS:								\
      reg1 = 0;	reg2 = 0;						\
      ireg = 0;	breg = 0;						\
      offset = 0;							\
      multval = 0;							\
      reg1_str[0] = 0; reg2_str[0] = 0;					\
      offset_printed = 0;						\
      if (CONSTANT_ADDRESS_P (XEXP (addr, 0))				\
	  || GET_CODE (XEXP (addr, 0)) == MEM)				\
	{								\
	  /* CONST / MEM(PLUS((REG)(CONST))) */				\
	  offset = XEXP (addr, 0);					\
	  /* (REG) / PLUS((REG)(CONST)) / MULT((REG)(CONST)) */		\
	  addr = XEXP (addr, 1);					\
	}								\
      else if (CONSTANT_ADDRESS_P (XEXP (addr, 1))			\
	       || GET_CODE (XEXP (addr, 1)) == MEM)			\
	{								\
	  /* CONST / MEM(PLUS((REG)(CONST))) */				\
	  offset = XEXP (addr, 1);					\
	  /* (REG) / PLUS((REG)(CONST)) / MULT((REG)(CONST)) */		\
	  addr = XEXP (addr, 0);					\
	}								\
      if (offset != 0) {						\
	if (GET_CODE (offset) == MEM) {					\
	    offset = XEXP (offset, 0);	/* skip MEM */			\
	    switch (GET_CODE (offset)) {				\
		case REG:						\
		    sprintf (reg1_str, "(%s)",				\
			reg_names[REGNO (offset)]);			\
		    offset = 0;						\
		    break;						\
		case PLUS:						\
		    if (!CONSTANT_ADDRESS_P (XEXP (offset, 1))) {	\
			fprintf (FILE,					\
		    "PROGRAM in disorder PRINT_ADDR, PLUS, PLUS\n");	\
			print_rtl(FILE, offset);			\
			exit (1);					\
		    }							\
		    if (GET_CODE (XEXP(offset,0)) != REG) {		\
			fprintf (FILE,					\
		    "PROGRAM in disorder PRINT_ADDR, PLUS, REG\n");	\
			print_rtl(FILE, offset);			\
			exit (1);					\
		    }							\
		    sprintf (reg1_str, "(%s))",				\
			reg_names[REGNO (XEXP(offset,0))]);		\
		    offset = XEXP (offset, 1);				\
		    break;						\
		default:						\
		    abort();						\
	    }								\
	} else { /* !MEM */						\
	    if (!CONSTANT_ADDRESS_P (offset)) {				\
		abort();						\
	    }								\
	    output_addr_const (FILE, offset);				\
	    offset_printed = 1;						\
	    offset = 0;							\
	}								\
      }									\
		    							\
      if (GET_CODE (addr) == PLUS) {					\
	  if (GET_CODE (XEXP (addr, 0)) == MULT)			\
	    {								\
	      reg1 = XEXP (addr, 0); /* [rX:Y] */			\
	      addr = XEXP (addr, 1); /* CONST/REG */			\
	      if (GET_CODE (XEXP (reg1, 1)) != CONST_INT ||		\
		    GET_CODE (XEXP (reg1, 0)) != REG) {			\
		  abort();						\
	      }								\
	      sprintf (reg2_str, "[%s:%c]", 				\
		reg_names[ REGNO(XEXP (reg1, 0)) ],			\
		"XbwXdXXXq"[INTVAL (XEXP (reg1, 1))]);		        \
	      reg1 = 0;							\
	    }								\
	  else if (GET_CODE (XEXP (addr, 1)) == MULT)			\
	    {								\
	      reg1 = XEXP (addr, 1); /* [rX:Y] */			\
	      addr = XEXP (addr, 0); /* CONST */			\
	      if (GET_CODE (XEXP (reg1, 1)) != CONST_INT ||		\
		    GET_CODE (XEXP (reg1, 0)) != REG) {			\
		  abort();						\
	      }								\
	      sprintf (reg2_str, "[%s:%c]", 				\
		reg_names[ REGNO(XEXP (reg1, 0)) ],			\
		"XbwXdXXXq"[INTVAL (XEXP (reg1, 1))]);		        \
	      reg1 = 0;							\
	    }								\
	  else if (GET_CODE (XEXP (addr, 0)) == REG			\
		   && REGNO (XEXP (addr, 0)) < 8)			\
	    {								\
	      sprintf (reg2_str, "[%s:b]",				\
		reg_names[ REGNO(XEXP (addr, 0)) ]);			\
	      addr = XEXP (addr, 1); /* CONST / REG */			\
	    }								\
	  else if (GET_CODE (XEXP (addr, 1)) == REG			\
		   && REGNO (XEXP (addr, 1)) < 8)			\
	    {								\
	      sprintf (reg2_str, "[%s:b]",				\
		reg_names[ REGNO(XEXP (addr, 1)) ]);			\
	      addr = XEXP (addr, 0); /* CONST / REG */			\
	    }								\
	  else abort ();						\
      }									\
      if (addr)								\
	switch (GET_CODE (addr)) {					\
	    case MULT:							\
		if(*reg2_str) {						\
		    fprintf (FILE,					\
	        "PROGRAM in disorder PRINT_ADDR, INDEX, two mults\n");	\
		print_rtl(FILE, addr);					\
		    exit (1);						\
	        }							\
	        reg1 = XEXP (addr, 0); /* [rX:Y] */			\
	        addr = XEXP (addr, 1); /* CONST */			\
	        if (GET_CODE (addr) != CONST_INT) {			\
		    fprintf (FILE,					\
	        "PROGRAM in disorder PRINT_ADDR, INDEX, !CONS3 (%d)\n",	\
		        GET_CODE (addr));				\
		print_rtl(FILE, addr);					\
		    exit (1);						\
	        }							\
		sprintf (reg2_str, "[%s:%c]", reg_names[ REGNO(reg1) ],	\
		    "XbwXdXXXq"[INTVAL (addr)]);			\
	        break;							\
	    case REG:							\
		if (!*reg1_str)	{					\
                    if (offset || offset_printed)			\
		        sprintf (reg1_str, "(%s)", reg_names[REGNO (addr)]); \
                    else						\
		        sprintf (reg1_str, "0(%s)", reg_names[REGNO (addr)]); \
		} else if (!*reg2_str)					\
		    sprintf (reg2_str, "[%s:b]",			\
			reg_names[REGNO (addr)]);			\
		else abort();						\
		break;							\
	    case MEM:							\
		addr = XEXP(addr,0);					\
		switch (GET_CODE(addr)) {				\
		case REG:						\
		  if (!*reg1_str) {					\
		    if (offset || offset_printed)			\
		      sprintf (reg1_str, "(0(%s))",			\
			       reg_names[REGNO (addr)]); 		\
		    else						\
		      sprintf (reg1_str, "0(0(%s))",			\
			       reg_names[REGNO (addr)]);		\
		  } else						\
		    abort();						\
		  break;						\
		case PLUS:						\
		  if (GET_CODE (XEXP (addr, 0)) == REG) {		\
		    if (!*reg1_str) {					\
		      sprintf (reg1_str, "(%s))",			\
			       reg_names[REGNO(XEXP(addr, 0))]);	\
		      offset = XEXP(addr, 1);				\
		    } else						\
		      abort();						\
		  } else {						\
		    if (!*reg1_str) {					\
		      sprintf (reg1_str, "(%s))",			\
			       reg_names[REGNO(XEXP(addr, 1))]);	\
		      offset = XEXP(addr, 0);				\
		    } else						\
		      abort();						\
		  }							\
		  break;						\
		default:						\
		  abort();						\
		}							\
		break;							\
	    default:							\
		if (offset_printed)					\
		    fprintf (FILE, "+");				\
		output_addr_const (FILE, addr);				\
		offset_printed ++;					\
	}								\
      if (offset) {							\
	    if(!offset_printed)						\
		fputc ('0', FILE);					\
	    fputc ('(', FILE);						\
	    output_addr_const (FILE, offset);				\
      }									\
      if (*reg1_str)							\
	    fprintf (FILE, "%s", reg1_str);				\
      if (*reg2_str)							\
	    fprintf (FILE, "%s", reg2_str);				\
      break;								\
    default:								\
      output_addr_const (FILE, addr);					\
    }									\
    if(mem)								\
	fprintf(FILE,")");}

/*
Local variables:
version-control: t
End:
*/