i370.h

linux下的gcc编译器

#ifdef TARGET_ELF_ABI 

/* How to refer to registers in assembler output.  This sequence is
   indexed by compiler's hard-register-number (see above).  */

#define REGISTER_NAMES							\
{ "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",		\
  "r8",  "r9", "r10", "r11", "r12", "r13", "r14", "r15",		\
  "f0",  "f2",  "f4",  "f6"						\
}

/* Print operand XV (an rtx) in assembler syntax to file FILE.
   CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
   For `%' followed by punctuation, CODE is the punctuation and XV is null.  */

#define PRINT_OPERAND(FILE, XV, CODE)					\
{									\
  switch (GET_CODE (XV))						\
    {									\
      static char curreg[4];						\
      case REG:								\
	if (CODE == 'N')						\
	    strcpy (curreg, reg_names[REGNO (XV) + 1]);			\
	else								\
	    strcpy (curreg, reg_names[REGNO (XV)]);			\
	fprintf (FILE, "%s", curreg);					\
	break;								\
      case MEM:								\
	{								\
	  rtx addr = XEXP (XV, 0);					\
	  if (CODE == 'O')						\
	    {								\
	      if (GET_CODE (addr) == PLUS)				\
		fprintf (FILE, "%d", INTVAL (XEXP (addr, 1)));		\
	      else							\
		fprintf (FILE, "0");					\
	    }								\
	  else if (CODE == 'R')						\
	    {								\
	      if (GET_CODE (addr) == PLUS)				\
		fprintf (FILE, "%s", reg_names[REGNO (XEXP (addr, 0))]);\
	      else							\
		fprintf (FILE, "%s", reg_names[REGNO (addr)]);		\
	    }								\
	  else								\
	    output_address (XEXP (XV, 0));				\
	}								\
	break;								\
      case SYMBOL_REF:							\
      case LABEL_REF:							\
	mvs_page_lit += 4;						\
        if (SYMBOL_REF_FLAG (XV)) fprintf (FILE, "=V(");                \
        else                      fprintf (FILE, "=A(");                \
        output_addr_const (FILE, XV);                                   \
        fprintf (FILE, ")");                                            \
	break;								\
      case CONST_INT:					        	\
	if (CODE == 'B')						\
	  fprintf (FILE, "%d", INTVAL (XV) & 0xff);			\
	else if (CODE == 'X')						\
	  fprintf (FILE, "%02X", INTVAL (XV) & 0xff);			\
	else if (CODE == 'h')						\
	  fprintf (FILE, "%d", (INTVAL (XV) << 16) >> 16);		\
	else if (CODE == 'H')						\
	  {								\
	    mvs_page_lit += 2;						\
	    fprintf (FILE, "=H'%d'", (INTVAL (XV) << 16) >> 16);	\
	  }								\
	else if (CODE == 'K')						\
	  {								\
            /* auto sign-extension of signed 16-bit to signed 32-bit */	\
	    mvs_page_lit += 4;						\
	    fprintf (FILE, "=F'%d'", (INTVAL (XV) << 16) >> 16);	\
	  }								\
	else if (CODE == 'W')						\
	  {								\
            /* hand-built sign-extension of signed 32-bit to 64-bit */	\
	    mvs_page_lit += 8;						\
	    if (0 <=  INTVAL (XV)) {					\
	       fprintf (FILE, "=XL8'00000000");				\
            } else {							\
	       fprintf (FILE, "=XL8'FFFFFFFF");				\
            }								\
	    fprintf (FILE, "%08X'", INTVAL (XV));			\
	  }								\
	else								\
	  {								\
	    mvs_page_lit += 4;						\
	    fprintf (FILE, "=F'%d'", INTVAL (XV));			\
	  }								\
	break;								\
      case CONST_DOUBLE:						\
	if (GET_MODE (XV) == DImode)					\
	  {								\
	    if (CODE == 'M')						\
	      {								\
		mvs_page_lit += 4;					\
		fprintf (FILE, "=XL4'%08X'", CONST_DOUBLE_LOW (XV));	\
	      }								\
	    else if (CODE == 'L')					\
	      {								\
		mvs_page_lit += 4;					\
		fprintf (FILE, "=XL4'%08X'", CONST_DOUBLE_HIGH (XV));	\
	      }								\
	    else							\
	      {								\
		mvs_page_lit += 8;					\
		fprintf (FILE, "=yyyyXL8'%08X%08X'", 			\
			CONST_DOUBLE_HIGH (XV), CONST_DOUBLE_LOW (XV));	\
	      }								\
	  }								\
	else								\
	  { 								\
            char buf[50];						\
	    if (GET_MODE (XV) == SFmode)				\
	      {								\
		mvs_page_lit += 4;					\
		real_to_decimal (buf, CONST_DOUBLE_REAL_VALUE (XV),	\
				 sizeof (buf), 0, 1);			\
		fprintf (FILE, "=E'%s'", buf);				\
	      }								\
	    else if (GET_MODE (XV) == DFmode)				\
	      {								\
		mvs_page_lit += 8;					\
		real_to_decimal (buf, CONST_DOUBLE_REAL_VALUE (XV),	\
				 sizeof (buf), 0, 1);			\
		fprintf (FILE, "=D'%s'", buf);				\
	      }								\
	    else /* VOIDmode */						\
	      {								\
		mvs_page_lit += 8;					\
		fprintf (FILE, "=XL8'%08X%08X'", 			\
			CONST_DOUBLE_HIGH (XV), CONST_DOUBLE_LOW (XV));	\
	      }								\
	  }								\
	break;								\
      case CONST:							\
	if (GET_CODE (XEXP (XV, 0)) == PLUS				\
	   && GET_CODE (XEXP (XEXP (XV, 0), 0)) == SYMBOL_REF)		\
	  {								\
	    mvs_page_lit += 4;						\
	    if (SYMBOL_REF_FLAG (XEXP (XEXP (XV, 0), 0)))		\
	      {								\
		fprintf (FILE, "=V(");					\
		ASM_OUTPUT_LABELREF (FILE,				\
				  XSTR (XEXP (XEXP (XV, 0), 0), 0));	\
		fprintf (FILE, ")\n\tA\t%s,=F'%d'", curreg,		\
				  INTVAL (XEXP (XEXP (XV, 0), 1)));	\
	      }								\
	    else							\
	      {								\
		fprintf (FILE, "=A(");					\
		output_addr_const (FILE, XV);				\
		fprintf (FILE, ")");					\
	      }								\
	  }								\
	else								\
	  {								\
	    mvs_page_lit += 4;						\
	    fprintf (FILE, "=bogus_bad_F'");				\
	    output_addr_const (FILE, XV);				\
	    fprintf (FILE, "'");					\
/* XXX hack alert this gets gen'd in -fPIC code in relation to a tablejump */  \
/* but its somehow fundamentally broken, I can't make any sense out of it */  \
debug_rtx (XV); \
abort(); \
	  }								\
	break;								\
      default:								\
	abort();							\
    }									\
}

#define PRINT_OPERAND_ADDRESS(FILE, ADDR)				\
{									\
  rtx breg, xreg, offset, plus;						\
  									\
  switch (GET_CODE (ADDR))						\
    {									\
      case REG:								\
	fprintf (FILE, "0(%s)", reg_names[REGNO (ADDR)]);		\
	break;								\
      case PLUS:							\
	breg = 0;							\
	xreg = 0;							\
	offset = 0;							\
	if (GET_CODE (XEXP (ADDR, 0)) == PLUS)				\
	  {								\
	    if (GET_CODE (XEXP (ADDR, 1)) == REG)			\
	      breg = XEXP (ADDR, 1);					\
	    else							\
	      offset = XEXP (ADDR, 1);					\
	    plus = XEXP (ADDR, 0);					\
	  }								\
	else								\
	  {								\
	    if (GET_CODE (XEXP (ADDR, 0)) == REG)			\
	      breg = XEXP (ADDR, 0);					\
	    else							\
	      offset = XEXP (ADDR, 0);					\
	    plus = XEXP (ADDR, 1);					\
	  }								\
	if (GET_CODE (plus) == PLUS)					\
	  {								\
	    if (GET_CODE (XEXP (plus, 0)) == REG)			\
	      {								\
		if (breg)						\
		  xreg = XEXP (plus, 0);				\
		else							\
		  breg = XEXP (plus, 0);				\
	      }								\
	    else							\
	      {								\
		offset = XEXP (plus, 0);				\
	      }								\
	    if (GET_CODE (XEXP (plus, 1)) == REG)			\
	      {								\
		if (breg)						\
		  xreg = XEXP (plus, 1);				\
		else							\
		  breg = XEXP (plus, 1);				\
	      }								\
	    else							\
	      {								\
		offset = XEXP (plus, 1);				\
	      }								\
	  }								\
	else if (GET_CODE (plus) == REG)				\
	  {								\
	    if (breg)							\
	      xreg = plus;						\
	    else							\
	      breg = plus;						\
	  }								\
	else								\
	  {								\
	    offset = plus;						\
	  }								\
	if (offset)							\
	  {								\
	    if (GET_CODE (offset) == LABEL_REF)				\
	      fprintf (FILE, "L%d",					\
			CODE_LABEL_NUMBER (XEXP (offset, 0)));		\
	    else							\
	      output_addr_const (FILE, offset);				\
	  }								\
	else								\
	  fprintf (FILE, "0");						\
	if (xreg)							\
	    fprintf (FILE, "(%s,%s)",					\
		    reg_names[REGNO (xreg)], reg_names[REGNO (breg)]); 	\
	else								\
	  fprintf (FILE, "(%s)", reg_names[REGNO (breg)]);		\
	break;								\
      default:								\
	mvs_page_lit += 4;						\
	if (SYMBOL_REF_FLAG (ADDR)) fprintf (FILE, "=V(");		\
	else                        fprintf (FILE, "=A(");		\
	output_addr_const (FILE, ADDR);					\
	fprintf (FILE, ")");						\
	break;								\
    }									\
}

/* Output assembler code to FILE to increment profiler label # LABELNO
   for profiling a function entry.  */
/* Make it a no-op for now, so we can at least compile glibc */
#define FUNCTION_PROFILER(FILE, LABELNO)  {				\
  mvs_check_page (FILE, 24, 4);						\
     fprintf (FILE, "\tSTM\tr1,r2,%d(sp)\n", STACK_POINTER_OFFSET-8);	\
     fprintf (FILE, "\tLA\tr1,1(0,0)\n"); 				\
     fprintf (FILE, "\tL\tr2,=A(.LP%d)\n", LABELNO);			\
     fprintf (FILE, "\tA\tr1,0(r2)\n");			 		\
     fprintf (FILE, "\tST\tr1,0(r2)\n");		 		\
     fprintf (FILE, "\tLM\tr1,r2,%d(sp)\n", STACK_POINTER_OFFSET-8);	\
}

/* Don't bother to output .extern pseudo-ops.  They are not needed by
   ELF assemblers.  */

#undef ASM_OUTPUT_EXTERNAL

#define ASM_DOUBLE "\t.double"     

/* #define ASM_OUTPUT_LABELREF(FILE, NAME) */	/* use gas -- defaults.h */

/* Generate internal label.  Since we can branch here from off page, we
   must reload the base register.  Note that internal labels are generated
   for loops, goto's and case labels.  */
#undef ASM_OUTPUT_INTERNAL_LABEL
#define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM) 			\
{									\
  if (!strcmp (PREFIX,"L"))						\
    {									\
      mvs_add_label(NUM);						\
    }									\
  fprintf (FILE, ".%s%d:\n", PREFIX, NUM); 				\
}

/* let config/svr4.h define this ...
 *  #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, TABLE)
 *    fprintf (FILE, "%s%d:\n", PREFIX, NUM)
 */

/* This is how to output an element of a case-vector that is absolute.  */
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  				\
  mvs_check_page (FILE, 4, 0);						\
  fprintf (FILE, "\t.long\t.L%d\n", VALUE)

/* This is how to output an element of a case-vector that is relative.  */
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) 		\
  mvs_check_page (FILE, 4, 0);						\
  fprintf (FILE, "\t.long\t.L%d-.L%d\n", VALUE, REL)

/* Right now, PUSH & POP are used only when profiling is enabled, 
   and then, only to push the static chain reg and the function struct 
   value reg, and only if those are used by the function being profiled.
   We don't need this for profiling, so punt.  */
#define ASM_OUTPUT_REG_PUSH(FILE, REGNO) 
#define ASM_OUTPUT_REG_POP(FILE, REGNO)	


/* Indicate that jump tables go in the text section.  This is
   necessary when compiling PIC code.  */
#define JUMP_TABLES_IN_TEXT_SECTION 1

/* Define macro used to output shift-double opcodes when the shift
   count is in %cl.  Some assemblers require %cl as an argument;
   some don't.

   GAS requires the %cl argument, so override i386/unix.h.  */

#undef SHIFT_DOUBLE_OMITS_COUNT
#define SHIFT_DOUBLE_OMITS_COUNT 0

#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
  sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
 
 /* Implicit library calls should use memcpy, not bcopy, etc.  */
#define TARGET_MEM_FUNCTIONS
 
/* Output before read-only data.  */
#define TEXT_SECTION_ASM_OP "\t.text"

/* Output before writable (initialized) data.  */
#define DATA_SECTION_ASM_OP "\t.data"

/* Output before writable (uninitialized) data.  */
#define BSS_SECTION_ASM_OP "\t.bss"

/* In the past there was confusion as to what the argument to .align was
   in GAS.  For the last several years the rule has been this: for a.out
   file formats that argument is LOG, and for all other file formats the
   argument is 1<<LOG.

   However, GAS now has .p2align and .balign pseudo-ops so to remove any
   doubt or guess work, and since this file is used for both a.out and other
   file formats, we use one of them.  */

#define ASM_OUTPUT_ALIGN(FILE,LOG) \
  if ((LOG)!=0) fprintf ((FILE), "\t.balign %d\n", 1<<(LOG))
 
/* Globalizing directive for a label.  */
#define GLOBAL_ASM_OP ".globl "

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

#endif /* TARGET_ELF_ABI */
#endif /* ! GCC_I370_H */