dpx2.h

gcc编译工具没有什么特别

	{							      \
	  fprintf (FILE, "\tadd.w #%d,sp\n", - (fsize + 4));	      \
	}							      \
      else							      \
	{							      \
	  fprintf (FILE, "\tadd.l #%d,sp\n", - (fsize + 4));          \
	}							      \
    }								      \
  for (regno = 23; regno >= 16; regno--)                              \
    if (regs_ever_live[regno] && ! call_used_regs[regno])             \
      if (first) {						      \
        fprintf (FILE, "\tfmovem.x %s", reg_names[regno]);            \
	first = 0;						      \
       }							      \
      else fprintf (FILE, "/%s", reg_names[regno]);            	      \
  if (!first) fprintf (FILE, ",-(sp)\n");			      \
								      \
  mask = 0;							      \
  for (regno = 0; regno < 16; regno++)				      \
    if (regs_ever_live[regno] && ! call_used_regs[regno])	      \
      {								      \
        mask |= 1 << (15 - regno);				      \
        num_saved_regs++;                   			      \
      }                                                               \
  if (frame_pointer_needed)                                           \
    {                                                                 \
      mask &= ~ (1 << (15 - FRAME_POINTER_REGNUM));                   \
      num_saved_regs--;                                               \
    }                                                                 \
                                                                      \
                                                                      \
  if (num_saved_regs <= 2)                                            \
    {                                                                 \
      /* Store each separately in the same order moveml uses.         \
         Using two movel instructions instead of a single moveml      \
         is about 15% faster for the 68020 and 68030 at no expense    \
         in code size */                                              \
                                                                      \
      int i;                                                          \
                                                                      \
      /* Undo the work from above. */                                 \
      for (i = 0; i< 16; i++)                                         \
        if (mask & (1 << i))                                          \
          fprintf (FILE, "\tmove.l %s,-(sp)\n", reg_names[15 - i]);   \
    }                                                                 \
  else if (mask)                                                      \
    {                                                                 \
      first = 1;                                                      \
      for (regno = 0; regno < 16; regno++)                            \
        if (mask & (1 << regno))                                      \
          if (first) {                                                \
            fprintf (FILE, "\tmovem.l %s", reg_names[15 - regno]);    \
            first = 0;                                                \
           }                                                          \
          else fprintf (FILE, "/%s", reg_names[15 - regno]);	      \
      fprintf (FILE, ",-(sp)\n");	           		      \
    }                                                                 \
  if (flag_pic && current_function_uses_pic_offset_table)             \
    {                                                                 \
      fprintf (FILE, "\tmove.l #__GLOBAL_OFFSET_TABLE_, %s\n",        \
		   reg_names[PIC_OFFSET_TABLE_REGNUM]);               \
      fprintf (FILE, "\tlea.l (pc,%s.l),%s\n",                        \
		   reg_names[PIC_OFFSET_TABLE_REGNUM],                \
		   reg_names[PIC_OFFSET_TABLE_REGNUM]);               \
    }                                                                 \
}


#undef FUNCTION_EPILOGUE
#define FUNCTION_EPILOGUE(FILE, SIZE)                                 \
{                                                                     \
  register int regno;                                                 \
  register int mask, fmask;                                           \
  register int nregs;                                                 \
  int offset, foffset, fpoffset, first = 1;		              \
  extern char call_used_regs[];                                       \
  int fsize = ((SIZE) + 3) & -4;                                      \
  int big = 0;                                                        \
  rtx insn = get_last_insn ();                                        \
                                                                      \
  /* If the last insn was a BARRIER, we don't have to write any code.  */ \
  if (GET_CODE (insn) == NOTE)                                        \
    insn = prev_nonnote_insn (insn);                                  \
  if (insn && GET_CODE (insn) == BARRIER)                             \
    {                                                                 \
      /* Output just a no-op so that debuggers don't get confused     \
	 about which function the pc is in at this address.  */       \
      fprintf (FILE, "\tnop\n");                                      \
      return;                                                         \
    }                                                                 \
                                                                      \
  nregs = 0;  fmask = 0; fpoffset = 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, "\tmove.l #%d,a0\n", -fsize);                    \
      fsize = 0, big = 1;                                             \
    }                                                                 \
  if (nregs <= 2)                                                     \
    {                                                                 \
      /* Restore each separately in the same order moveml does.       \
         Using two movel instructions instead of a single moveml      \
         is about 15% faster for the 68020 and 68030 at no expense    \
         in code size. */                                             \
                                                                      \
      int i;                                                          \
                                                                      \
      /* Undo the work from above. */                                 \
      for (i = 0; i< 16; i++)                                         \
        if (mask & (1 << i))                                          \
          {                                                           \
            if (big)                                                  \
	      {                                                       \
		fprintf (FILE, "\tmove.l -%d(%s,a0.l),%s\n",          \
			     offset + fsize,                          \
			     reg_names[FRAME_POINTER_REGNUM],         \
			     reg_names[i]);                           \
	      }                                                       \
            else if (! frame_pointer_needed)                          \
	      {                                                       \
		fprintf (FILE, "\tmove.l (sp)+,%s\n",                 \
			     reg_names[i]);                           \
	      }                                                       \
            else                                                      \
	      {                                                       \
		fprintf (FILE, "\tmove.l -%d(%s),%s\n",               \
			     offset + fsize,                          \
			     reg_names[FRAME_POINTER_REGNUM],         \
			     reg_names[i]);                           \
	      }                                                       \
            offset = offset - 4;                                      \
          }                                                           \
    }                                                                 \
  else if (mask)                                                      \
    {                                                                 \
      first = 1;						      \
      for (regno = 0; regno < 16; regno++)                            \
        if (mask & (1 << regno))                                      \
          if (first && big) {                                         \
            fprintf (FILE, "\tmovem.l -%d(%s,a0.l),%s",               \
		     offset + fsize,                                  \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
            first = 0;                                                \
           }                                                          \
          else if (first && ! frame_pointer_needed) {                 \
            fprintf (FILE, "\tmovem.l (sp)+,%s",                      \
		     offset + fsize,                                  \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
            first = 0;                                                \
           }                                                          \
          else if (first) {   				              \
            fprintf (FILE, "\tmovem.l -%d(%s),%s",                    \
		     offset + fsize,                                  \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
            first = 0;                                                \
           }                                                          \
          else  						      \
	    fprintf (FILE, "/%s", reg_names[regno]);	              \
      fprintf (FILE, "\n");	                 		      \
    }                                                                 \
  if (fmask)                                                          \
    {                                                                 \
      first = 1;						      \
      for (regno = 16; regno < 24; regno++)                           \
        if (fmask & (1 << (23 - regno)))                               \
          if (first && big) {	                                      \
            fprintf (FILE, "\tfmovem.x -%d(%s,a0.l),%s",              \
		     foffset + fsize,                                 \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
	    first = 0;						      \
           }                                                          \
          else if (first && ! frame_pointer_needed) {                 \
            fprintf (FILE, "\tfmovem.x (sp)+,%s",                     \
		     foffset + fsize,                                 \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
	    first = 0;						      \
           }                                                          \
          else if (first) {    				              \
            fprintf (FILE, "\tfmovem.x -%d(%s),%s",                   \
		     foffset + fsize,                                 \
		     reg_names[FRAME_POINTER_REGNUM],                 \
		     reg_names[regno]);                               \
	    first = 0;						      \
           }                                                          \
	  else fprintf (FILE, "/%s", reg_names[regno]); 	      \
      fprintf (FILE, "\n");					      \
    }                                                                 \
  if (frame_pointer_needed)                                           \
    fprintf (FILE, "\tunlk %s\n",                                     \
	     reg_names[FRAME_POINTER_REGNUM]);                        \
  else if (fsize)                                                     \
    {                                                                 \
      if (fsize + 4 < 0x8000)                                         \
	{                                                             \
	  fprintf (FILE, "\tadd.w #%d,sp\n", fsize + 4);              \
	}                                                             \
      else                                                            \
	{                                                             \
	  fprintf (FILE, "\tadd.l #%d,sp\n", fsize + 4);              \
	}                                                             \
    }                                                                 \
  if (current_function_pops_args)                                     \
    fprintf (FILE, "\trtd #%d\n", current_function_pops_args);        \
  else                                                                \
    fprintf (FILE, "\trts\n");                                        \
}

/* Translate Motorola opcodes such as `jbeq'
   into VERSAdos opcodes such as `beq'.
   Change `fbeq' to `fbseq', `fbne' to `fbsneq'.
*/

#undef ASM_OUTPUT_OPCODE
#define ASM_OUTPUT_OPCODE(FILE, PTR)			\
{ if ((PTR)[0] == 'j' && (PTR)[1] == 'b')		\
    { ++(PTR);						\
      while (*(PTR) != ' ')				\
	{ putc (*(PTR), (FILE)); ++(PTR); }		\
    }			                          	\
  else if ((PTR)[0] == 'f')                             \
    {                                                   \
      if (!strncmp ((PTR), "fbeq", 4))                  \
        { fprintf ((FILE), "fbseq"); (PTR) += 4; }      \
      else if (!strncmp ((PTR), "fbne", 4))             \
        { fprintf ((FILE), "fbsneq"); (PTR) += 4; }     \
    }                                                   \
  else if ((PTR)[0] == 'b' && (PTR)[1] == 'f')          \
    {                                                   \
      char *s;                                          \
      if ((s = (char*)strchr ((PTR), '{')))             \
	while (*s != '}') {                             \
	  if (*s == 'b')                                \
	    /* hack, I replace it with R ie nothing */  \
	    *s = '0';                                   \
	  s++; }					\
    }                                                   \
}

/* This is how to output a `long double' extended real constant. */
#undef ASM_OUTPUT_LONG_DOUBLE 
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)  				\
do { long l[3];								\
     REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l);			\
     if (sizeof (int) == sizeof (long))					\
       fprintf (FILE, "\tdc.l $%x,$%x,$%x\n", l[0], l[1], l[2]);	\
     else								\
       fprintf (FILE, "\tdc.l $%lx,$%lx,$%lx\n", l[0], l[1], l[2]);	\
   } while (0)

#undef ASM_OUTPUT_DOUBLE
#if 0
#define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \