home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / tm-crds.h < prev    next >
C/C++ Source or Header  |  1991-06-03  |  22KB  |  595 lines
  1. /* Definitions of target machine for GNU compiler.
  2.    Charles River Data Systems UNiverse/32
  3.  
  4.    Written by Gary E. Miller
  5.    bug reports to Gary_Edmunds_Miller@cup.portal.com
  6.  
  7.    Copyright (C) 1987 Free Software Foundation, Inc.
  8.  
  9. This file is part of GNU CC.
  10.  
  11. GNU CC is free software; you can redistribute it and/or modify
  12. it under the terms of the GNU General Public License as published by
  13. the Free Software Foundation; either version 2, or (at your option)
  14. any later version.
  15.  
  16. GNU CC is distributed in the hope that it will be useful,
  17. but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. GNU General Public License for more details.
  20.  
  21. You should have received a copy of the GNU General Public License
  22. along with GNU CC; see the file COPYING.  If not, write to
  23. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24.  
  25. #define MOTOROLA
  26. #define SGS
  27. #define CRDS    /* Charles River Data Systems assembler syntax. */
  28.  
  29. #include "tm-m68k.h"
  30.  
  31. /* See tm-m68k.h.  0 means 680[01]0 with no 68881.  */
  32.  
  33. #undef TARGET_DEFAULT
  34. #define    TARGET_DEFAULT 0
  35.  
  36. /* special flags to the unos assembler.  */
  37.  
  38. #undef ASM_SPEC
  39. #define ASM_SPEC "-g"
  40.  
  41. #undef LIB_SPEC
  42. #define LIB_SPEC "%{!p:%{!pg:-lunos}}%{p:-lc_p}%{pg:-lc_p}"
  43.  
  44. #undef STARTFILE_SPEC
  45. #define STARTFILE_SPEC  \
  46.   "%{pg:gcrt0.o%s}%{!pg:%{p:mc68rt0.o%s}%{!p:c68rt0.o%s}}"
  47.  
  48. /* CC1 spec */
  49. #if 0
  50. /* c.sac only used in _s_call_r() in libunos.a and malloc() in libmalloc.a */
  51. /* so we do not need to bother ! */
  52. #define CC1_SPEC "-fpcc-struct-return"
  53. #endif
  54.  
  55. /* -O2 for MAX optimization */
  56. #undef CC1_SPEC
  57. #define CC1_SPEC "%{O2:-fstrength-reduce}"
  58.  
  59. /* cpp has to support a #sccs directive for the /usr/include files */
  60.  
  61. #define SCCS_DIRECTIVE
  62.  
  63. /* Make output for SDB.  */
  64.  
  65. /* #define SDB_DEBUGGING_INFO UNOS casm has no debugging :-( */
  66.  
  67. /* UNOS has vprintf() */ 
  68.  
  69. #define HAVE_VPRINTF
  70.  
  71. /* UNOS need stack probe :-( */
  72.  
  73. #define HAVE_probe 1
  74. #define gen_probe()  gen_rtx(ASM_INPUT, VOIDmode, "tstb -2048(sp)\t;probe\n")
  75.  
  76. /* use memcpy, memset instead of bcopy, etc. */
  77.  
  78. #define TARGET_MEM_FUNCTIONS
  79.  
  80. /* Don't try to define `gcc_compiled.' since the assembler might not
  81.    accept symbols with periods and GDB doesn't run on this machine anyway.  */
  82. #define ASM_IDENTIFY_GCC(FILE)
  83.  
  84. /* Define __HAVE_68881__ in preprocessor if -m68881 is specified.
  85.    This will control the use of inline 68881 insns in certain macros.  */
  86.  
  87. #undef CPP_SPEC
  88. #define CPP_SPEC "%{m68881:-D__HAVE_68881__}"
  89.  
  90. /* Names to predefine in the preprocessor for this target machine.  */
  91.  
  92. #undef CPP_PREDEFINES
  93. #define CPP_PREDEFINES "-Dmc68k -DM68000 -Dmc68000 -Dunos -Dunix"
  94.  
  95. /* Register in which address to store a structure value
  96.    is passed to a function.  */
  97. /* unos uses ".comm c.sac" returns &c.sac in d0 */
  98. /* make pointer to c.sac ?
  99. #undef STRUCT_VALUE_REGNUM
  100. #define STRUCT_VALUE gen_rtx(MEM, Pmode, gen_rtx( , , ) )
  101. */
  102.  
  103. #define EXTRA_SECTIONS in_bss
  104.  
  105. #define EXTRA_SECTION_FUNCTIONS                        \
  106. void                                    \
  107. bss_section ()                                \
  108. {                                    \
  109.   if (in_section != in_bss)                        \
  110.     {                                    \
  111.       fprintf (asm_out_file, ".bss\n");                    \
  112.       in_section = in_bss;                        \
  113.     }                                    \
  114. }
  115.  
  116. /* Specify how to pad function arguments.
  117.    Value should be `upward', `downward' or `none'.
  118.    Same as the default, except no padding for large or variable-size args.  */
  119.  
  120. #define FUNCTION_ARG_PADDING(MODE, TYPE)                \
  121.   (((MODE) == BLKmode                            \
  122.     ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE))    == INTEGER_CST        \
  123.        && int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT)    \
  124.     : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY)                \
  125.    ? downward : none)
  126.  
  127. /* Override part of the obstack macros.  */
  128.  
  129. #define __PTR_TO_INT(P) ((int)(P))
  130. #define __INT_TO_PTR(P) ((char *)(P))
  131.  
  132. /* Override parts of tm-m68k.h to fit the CRuDS assembler.  */
  133.  
  134. #undef TARGET_VERSION 
  135. #define TARGET_VERSION fprintf (stderr, " (68k, CRDS/UNOS)");
  136.  
  137. /* Control the assembler format that we output.  */
  138.  
  139. /* Output at beginning of assembler file.  */
  140.  
  141. #undef ASM_FILE_START
  142. #define ASM_FILE_START(FILE)    \
  143.   fprintf (FILE, ";#NO_APP\n");
  144.  
  145. /* Output to assembler file text saying following lines
  146.    may contain character constants, extra white space, comments, etc.  */
  147.  
  148. #undef ASM_APP_ON
  149. #define ASM_APP_ON ";#APP\n"
  150.  
  151. /* Output to assembler file text saying following lines
  152.    no longer contain unusual constructs.  */
  153.  
  154. #undef ASM_APP_OFF 
  155. #define ASM_APP_OFF ";#NO_APP\n"
  156.  
  157. /* This is how to output an assembler line defining a `double' constant.  */
  158.  
  159. #undef ASM_OUTPUT_DOUBLE
  160. #define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \
  161. do { union { double f; long l[2];} tem;            \
  162.      tem.f = (VALUE);                    \
  163.      fprintf (FILE, "\t.long 0x%x, 0x%x\n", tem.l[0], tem.l[1]);    \
  164.    } while (0)
  165.  
  166. /*unos has no .skip :-( */
  167. #undef ASM_OUTPUT_SKIP
  168. #define ASM_OUTPUT_SKIP(FILE,SIZE)         \
  169.     fprintf (FILE, "\t. = . + %u\n", (SIZE));    
  170.  
  171. /* This says how to output an assembler line
  172.    to define a local common symbol.  */
  173. /* should use bss_section instead of data_section but this makes casm die ? */
  174.  
  175. #undef ASM_OUTPUT_LOCAL
  176. #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
  177. { data_section ();                \
  178.   if ((SIZE) > 1) fprintf (FILE, "\t.even\n");    \
  179.   assemble_name ((FILE), (NAME));        \
  180.   fprintf ((FILE), ":\t. = . + %u\n", (ROUNDED));}
  181.  
  182. /* This is how to output an insn to push a register on the stack.
  183.    It need not be very fast code.  */
  184.  
  185. #undef ASM_OUTPUT_REG_PUSH
  186. #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
  187.   fprintf (FILE, "\tmovel %s,-(sp)\n", reg_names[REGNO])
  188.  
  189. /* This is how to output an insn to pop a register from the stack.
  190.    It need not be very fast code.  */
  191.  
  192. #undef ASM_OUTPUT_REG_POP
  193. #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
  194.   fprintf (FILE, "\tmovel (sp)+,%s\n", reg_names[REGNO])
  195.  
  196. #undef  ASM_OUTPUT_ASCII
  197. #define  ASM_OUTPUT_ASCII(FILE, P , SIZE)                \
  198. {  int i;                                \
  199.       fprintf ((FILE), "\t.ascii \"");                \
  200.       for (i = 0; i < (SIZE); i++)                    \
  201.         {                                \
  202.           register int c = (P)[i];                    \
  203.           if (i != 0 && (i / 200) * 200 == i)            \
  204.         fprintf ((FILE), "\"\n\t.ascii \"");            \
  205.           if (c >= ' ' && c < 0177) {                \
  206.             if (c != '\"' && c != '\\') {                \
  207.           putc (c, (FILE));                    \
  208.           continue;                        \
  209.             }                            \
  210.            }                            \
  211.            /* brain dead asm doesn't understand char escapes */  \
  212.            fprintf ((FILE), "\"\n\t.byte\t%d\n\t.ascii \"", c);    \
  213.         }                                \
  214.       fprintf ((FILE), "\"\n");                    \
  215.  }
  216.  
  217.  
  218. /* Change all JBxx to Bxx.  Also change all DBRA to DBF.
  219.    Also change divs.l, etc., to divs, etc.  But don't change divsl.l.  */
  220.  
  221. #define ASM_OUTPUT_OPCODE(FILE, PTR)            \
  222. { if ((PTR)[0] == 'j' && (PTR)[1] == 'b')        \
  223.     { ++(PTR); }                    \
  224.   else if ((PTR)[0] == 'd')                \
  225.     {                            \
  226.       if (!strncmp ((PTR), "dbra", 4))            \
  227.     { fprintf ((FILE), "dbf"); (PTR) += 4; }    \
  228.       else if (!strncmp ((PTR), "div", 3) && (PTR)[5] == ' ')  \
  229.     { fprintf ((FILE), "div%c", (PTR)[3]); (PTR) += 6; }   \
  230.     }                            \
  231. }
  232.  
  233.  
  234. /* Print operand X (an rtx) in assembler syntax to file FILE.
  235.    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
  236.    For `%' followed by punctuation, CODE is the punctuation and X is null.
  237.  
  238.    On the 68000, we use several CODE characters:
  239.    '.' for dot needed in Motorola-style opcode names.
  240.    '-' for an operand pushing on the stack:
  241.        sp@-, -(sp) or -(%sp) depending on the style of syntax.
  242.    '+' for an operand pushing on the stack:
  243.        sp@+, (sp)+ or (%sp)+ depending on the style of syntax.
  244.    '@' for a reference to the top word on the stack:
  245.        sp@, (sp) or (%sp) depending on the style of syntax.
  246.    '#' for an immediate operand prefix (# in MIT and Motorola syntax
  247.        but & in SGS syntax, $ in unos syntax).
  248.    '!' for the cc register (used in an `and to cc' insn).
  249.  
  250.    'b' for byte insn (no effect, on the Sun; this is for the ISI).
  251.    'd' to force memory addressing to be absolute, not relative.
  252.    'f' for float insn (print a CONST_DOUBLE as a float rather than in hex)
  253.    'w' for FPA insn (print a CONST_DOUBLE as a SunFPA constant rather
  254.        than directly).  Second part of 'y' below.
  255.    'x' for float insn (print a CONST_DOUBLE as a float rather than in hex),
  256.        or print pair of registers as rx:ry.
  257.    'y' for a FPA insn (print pair of registers as rx:ry).  This also outputs
  258.        CONST_DOUBLE's as SunFPA constant RAM registers if
  259.        possible, so it should not be used except for the SunFPA. */
  260.  
  261. #undef PRINT_OPERAND_PUNCT_VALID_P
  262. #define PRINT_OPERAND_PUNCT_VALID_P(CODE)                \
  263.   ((CODE) == '.' || (CODE) == '#' || (CODE) == '-'            \
  264.    || (CODE) == '+' || (CODE) == '@' || (CODE) == '!')
  265.  
  266. #undef PRINT_OPERAND
  267. #define PRINT_OPERAND(FILE, X, CODE)  \
  268. { int i;                                \
  269.   if (CODE == '.') ;                            \
  270.   else if (CODE == '#') fprintf (FILE, "$");                \
  271.   else if (CODE == '-') fprintf (FILE, "-(sp)");            \
  272.   else if (CODE == '+') fprintf (FILE, "(sp)+");            \
  273.   else if (CODE == '@') fprintf (FILE, "(sp)");                \
  274.   else if (CODE == '!') fprintf (FILE, "cc");                \
  275.   else if (GET_CODE (X) == REG)                        \
  276.     { if (REGNO (X) < 16 && (CODE == 'y' || CODE == 'x') && GET_MODE (X) == DFmode)    \
  277.         fprintf (FILE, "%s:%s", reg_names[REGNO (X)], reg_names[REGNO (X)+1]); \
  278.       else                                \
  279.         fprintf (FILE, "%s", reg_names[REGNO (X)]);            \
  280.     }                                    \
  281.   else if (GET_CODE (X) == MEM)                        \
  282.     {                                    \
  283.       output_address (XEXP (X, 0));                    \
  284.       if (CODE == 'd' && ! TARGET_68020                    \
  285.       && CONSTANT_ADDRESS_P (XEXP (X, 0)))                \
  286.     /* fprintf (FILE, ".l") */;                    \
  287.     }                                    \
  288.   else if ((CODE == 'y' || CODE == 'w')                    \
  289.        && GET_CODE(X) == CONST_DOUBLE                \
  290.        && (i = standard_sun_fpa_constant_p (X)))            \
  291.     fprintf (FILE, "%%%d", i & 0x1ff);                    \
  292.   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)    \
  293.     { union { double d; int i[2]; } u;                    \
  294.       union { float f; int i; } u1;                    \
  295.       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
  296.       u1.f = u.d;                            \
  297.       if (CODE == 'f')                            \
  298.     ASM_OUTPUT_FLOAT_OPERAND (FILE, u1.f);                \
  299.       else                                \
  300.         fprintf (FILE, "$0x%x", u1.i); }                \
  301.   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode)    \
  302.     { union { double d; int i[2]; } u;                    \
  303.       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
  304.       ASM_OUTPUT_DOUBLE_OPERAND (FILE, u.d); }                \
  305.   else { putc ('$', FILE); output_addr_const (FILE, X); }}
  306.  
  307. /* Note that this contains a kludge that knows that the only reason
  308.    we have an address (plus (label_ref...) (reg...))
  309.    is in the insn before a tablejump, and we know that m68k.md
  310.    generates a label LInnn: on such an insn.  */
  311. #undef PRINT_OPERAND_ADDRESS
  312. #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
  313. { register rtx reg1, reg2, breg, ireg;                    \
  314.   register rtx addr = ADDR;                        \
  315.   rtx offset;                                \
  316.   switch (GET_CODE (addr))                        \
  317.     {                                    \
  318.     case REG:                                \
  319.       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);            \
  320.       break;                                \
  321.     case PRE_DEC:                            \
  322.       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);    \
  323.       break;                                \
  324.     case POST_INC:                            \
  325.       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);    \
  326.       break;                                \
  327.     case PLUS:                                \
  328.       reg1 = 0;    reg2 = 0;                        \
  329.       ireg = 0;    breg = 0;                        \
  330.       offset = 0;                            \
  331.       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                \
  332.     {                                \
  333.       offset = XEXP (addr, 0);                    \
  334.       addr = XEXP (addr, 1);                    \
  335.     }                                \
  336.       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))            \
  337.     {                                \
  338.       offset = XEXP (addr, 1);                    \
  339.       addr = XEXP (addr, 0);                    \
  340.     }                                \
  341.       if (GET_CODE (addr) != PLUS) ;                    \
  342.       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)        \
  343.     {                                \
  344.       reg1 = XEXP (addr, 0);                    \
  345.       addr = XEXP (addr, 1);                    \
  346.     }                                \
  347.       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)        \
  348.     {                                \
  349.       reg1 = XEXP (addr, 1);                    \
  350.       addr = XEXP (addr, 0);                    \
  351.     }                                \
  352.       else if (GET_CODE (XEXP (addr, 0)) == MULT)            \
  353.     {                                \
  354.       reg1 = XEXP (addr, 0);                    \
  355.       addr = XEXP (addr, 1);                    \
  356.     }                                \
  357.       else if (GET_CODE (XEXP (addr, 1)) == MULT)            \
  358.     {                                \
  359.       reg1 = XEXP (addr, 1);                    \
  360.       addr = XEXP (addr, 0);                    \
  361.     }                                \
  362.       else if (GET_CODE (XEXP (addr, 0)) == REG)            \
  363.     {                                \
  364.       reg1 = XEXP (addr, 0);                    \
  365.       addr = XEXP (addr, 1);                    \
  366.     }                                \
  367.       else if (GET_CODE (XEXP (addr, 1)) == REG)            \
  368.     {                                \
  369.       reg1 = XEXP (addr, 1);                    \
  370.       addr = XEXP (addr, 0);                    \
  371.     }                                \
  372.       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT        \
  373.       || GET_CODE (addr) == SIGN_EXTEND)                \
  374.     { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }    \
  375.       if (offset != 0) { if (addr != 0) abort (); addr = offset; }    \
  376.       if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND            \
  377.             || GET_CODE (reg1) == MULT))            \
  378.       || (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2))))        \
  379.     { breg = reg2; ireg = reg1; }                    \
  380.       else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1)))        \
  381.     { breg = reg1; ireg = reg2; }                    \
  382.       if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF)    \
  383.         { int scale = 1;                        \
  384.       if (GET_CODE (ireg) == MULT)                    \
  385.         { scale = INTVAL (XEXP (ireg, 1));                \
  386.           ireg = XEXP (ireg, 0); }                    \
  387.       if (GET_CODE (ireg) == SIGN_EXTEND)                \
  388.         fprintf (FILE, "L%d-LI%d-2(pc,%s.w",            \
  389.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  390.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  391.              reg_names[REGNO (XEXP (ireg, 0))]);         \
  392.       else                                \
  393.         fprintf (FILE, "L%d-LI%d-2(pc,%s.l",            \
  394.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  395.              CODE_LABEL_NUMBER (XEXP (addr, 0)),        \
  396.              reg_names[REGNO (ireg)]);                \
  397.       if (scale != 1) fprintf (FILE, ":%d", scale);            \
  398.       putc (')', FILE);                        \
  399.       break; }                            \
  400.       if (breg != 0 && ireg == 0 && GET_CODE (addr) == LABEL_REF)    \
  401.         { fprintf (FILE, "L%d-LI%d-2(pc,%s.l",                \
  402.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  403.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  404.            reg_names[REGNO (breg)]);                \
  405.       putc (')', FILE);                        \
  406.       break; }                            \
  407.       if (ireg != 0 || breg != 0)                    \
  408.     { int scale = 1;                        \
  409.       if (breg == 0)                        \
  410.         abort ();                            \
  411.       if (addr && GET_CODE (addr) == LABEL_REF) abort ();        \
  412.       if (addr != 0)                        \
  413.         output_addr_const (FILE, addr);                \
  414.       fprintf (FILE, "(%s", reg_names[REGNO (breg)]);        \
  415.       if (breg != 0 && ireg != 0)                    \
  416.         putc (',', FILE);                        \
  417.       if (ireg != 0 && GET_CODE (ireg) == MULT)            \
  418.         { scale = INTVAL (XEXP (ireg, 1));                \
  419.           ireg = XEXP (ireg, 0); }                    \
  420.       if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)        \
  421.         fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);    \
  422.       else if (ireg != 0)                        \
  423.         fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);        \
  424.       if (scale != 1) fprintf (FILE, ":%d", scale);            \
  425.       putc (')', FILE);                        \
  426.       break;                            \
  427.     }                                \
  428.       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)        \
  429.     { fprintf (FILE, "L%d-LI%d-2(pc,%s.l)",                \
  430.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  431.            CODE_LABEL_NUMBER (XEXP (addr, 0)),            \
  432.            reg_names[REGNO (reg1)]);                \
  433.       break; }                            \
  434.     default:                                \
  435.       if (GET_CODE (addr) == CONST_INT                    \
  436.       && INTVAL (addr) < 0x8000                    \
  437.       && INTVAL (addr) >= -0x8000)                    \
  438.     fprintf (FILE, "%d", INTVAL (addr));                \
  439.       else                                \
  440.         output_addr_const (FILE, addr);                    \
  441.     }}
  442.  
  443. #define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME) \
  444.   fprintf (FILE, "\t; file\t\"%s\"\n", FILENAME)
  445.  
  446. #define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO)    \
  447.   fprintf (FILE, "\t; ln\t%d\n",            \
  448.        (sdb_begin_function_line        \
  449.         ? last_linenum - sdb_begin_function_line : 1))
  450.  
  451. /* This macro generates the assembly code for function entry.
  452.    FILE is a stdio stream to output the code to.
  453.    SIZE is an int: how many units of temporary storage to allocate.
  454.    Refer to the array `regs_ever_live' to determine which registers
  455.    to save; `regs_ever_live[I]' is nonzero if register number I
  456.    is ever used in the function.  This macro is responsible for
  457.    knowing which registers should not be saved even if used.  */
  458.  
  459. /* Note that the order of the bit mask for fmovem is the opposite
  460.    of the order for movem!  */
  461.  
  462. #undef FUNCTION_PROLOGUE
  463. #define FUNCTION_PROLOGUE(FILE, SIZE)     \
  464. { register int regno;                        \
  465.   register int mask = 0;                    \
  466.   extern char call_used_regs[];                    \
  467.   int fsize = ((SIZE) + 3) & -4;                \
  468.   /* unos stack probe */                    \
  469.   if ( fsize > 30000 ) {                    \
  470.     fprintf (FILE, "\tmovel sp,a0\n");                \
  471.     fprintf (FILE, "\taddl $-%d,a0\n", 2048 + fsize);        \
  472.     fprintf (FILE, "\ttstb (a0)\n");                \
  473.   } else {                            \
  474.     fprintf (FILE, "\ttstb -%d(sp)\n", 2048 + fsize);        \
  475.   }                                \
  476.   if (frame_pointer_needed)                    \
  477.     { if (TARGET_68020 || fsize < 0x8000)            \
  478.         fprintf (FILE, "\tlink a6,$%d\n", -fsize);        \
  479.       else                            \
  480.     fprintf (FILE, "\tlink a6,$0\n\tsubl $%d,sp\n", fsize); }  \
  481.   for (regno = 24; regno < 56; regno++)                \
  482.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  483.       fprintf(FILE, "\tfpmoved %s, sp@-\n",            \
  484.           reg_names[regno]);                \
  485.   for (regno = 16; regno < 24; regno++)                \
  486.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  487.        mask |= 1 << (regno - 16);                \
  488.   if ((mask & 0xff) != 0)                    \
  489.     fprintf (FILE, "\tfmovem $0x%x,-(sp)\n", mask & 0xff);       \
  490.   mask = 0;                            \
  491.   for (regno = 0; regno < 16; regno++)                \
  492.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  493.        mask |= 1 << (15 - regno);                \
  494.   if (frame_pointer_needed)                    \
  495.     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));            \
  496.   if (exact_log2 (mask) >= 0)                    \
  497.     fprintf (FILE, "\tmovel %s,-(sp)\n", reg_names[15 - exact_log2 (mask)]);  \
  498.   else if (mask) fprintf (FILE, "\tmovem $0x%x,-(sp)\n", mask); }
  499.  
  500. /* Must put address in  %a0 , not  %d0 . -- LGM, 7/15/88 */
  501. /* UNOS ?? */
  502. #undef FUNCTION_PROFILER
  503. #define FUNCTION_PROFILER(FILE, LABEL_NO)    \
  504.     fprintf (FILE, "\tmovl &LP%%%d,%%a0\n\tjsr mcount\n", (LABEL_NO))
  505.  
  506. /* This macro generates the assembly code for function exit,
  507.    on machines that need it.  If FUNCTION_EPILOGUE is not defined
  508.    then individual return instructions are generated for each
  509.    return statement.  Args are same as for FUNCTION_PROLOGUE.
  510.  
  511.    The function epilogue should not depend on the current stack pointer!
  512.    It should use the frame pointer only.  This is mandatory because
  513.    of alloca; we also take advantage of it to omit stack adjustments
  514.    before returning.  */
  515.  
  516. #undef FUNCTION_EPILOGUE
  517. #define FUNCTION_EPILOGUE(FILE, SIZE) \
  518. { register int regno;                        \
  519.   register int mask, fmask;                    \
  520.   register int nregs;                        \
  521.   int offset, foffset, fpoffset;                \
  522.   extern char call_used_regs[];                    \
  523.   int fsize = ((SIZE) + 3) & -4;                \
  524.   int big = 0;                            \
  525.   FUNCTION_EXTRA_EPILOGUE (FILE, SIZE);                \
  526.   nregs = 0;  fmask = 0; fpoffset = 0;                \
  527.   for (regno = 24 ; regno < 56 ; regno++)            \
  528.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  529.       nregs++;                            \
  530.   fpoffset = nregs*8;                        \
  531.   nregs = 0;                            \
  532.   for (regno = 16; regno < 24; regno++)                \
  533.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  534.       { nregs++; fmask |= 1 << (23 - regno); }            \
  535.   foffset = fpoffset + nregs * 12;                \
  536.   nregs = 0;  mask = 0;                        \
  537.   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
  538.   for (regno = 0; regno < 16; regno++)                \
  539.     if (regs_ever_live[regno] && ! call_used_regs[regno])    \
  540.       { nregs++; mask |= 1 << regno; }                \
  541.   offset = foffset + nregs * 4;                    \
  542.   if (offset + fsize >= 0x8000                     \
  543.       && frame_pointer_needed                     \
  544.       && (mask || fmask || fpoffset))                 \
  545.     { fprintf (FILE, "\tmovel $%d,a0\n", -fsize);        \
  546.       fsize = 0, big = 1; }                    \
  547.   if (exact_log2 (mask) >= 0) {                    \
  548.     if (big)                            \
  549.       fprintf (FILE, "\tmovel -%d(a6,a0.l),%s\n",        \
  550.            offset + fsize, reg_names[exact_log2 (mask)]);    \
  551.     else if (! frame_pointer_needed)                \
  552.       fprintf (FILE, "\tmovel (sp)+,%s\n",            \
  553.            reg_names[exact_log2 (mask)]);            \
  554.     else                            \
  555.       fprintf (FILE, "\tmovel -%d(a6),%s\n",            \
  556.            offset + fsize, reg_names[exact_log2 (mask)]); }    \
  557.   else if (mask) {                        \
  558.     if (big)                            \
  559.       fprintf (FILE, "\tmovem -%d(a6,a0.l),$0x%x\n",        \
  560.            offset + fsize, mask);                \
  561.     else if (! frame_pointer_needed)                \
  562.       fprintf (FILE, "\tmovem (sp)+,$0x%x\n", mask);        \
  563.     else                            \
  564.       fprintf (FILE, "\tmovem -%d(a6),$0x%x\n",        \
  565.            offset + fsize, mask); }                \
  566.   if (fmask) {                            \
  567.     if (big)                            \
  568.       fprintf (FILE, "\tfmovem -%d(a6,a0.l),$0x%x\n",        \
  569.            foffset + fsize, fmask);                \
  570.     else if (! frame_pointer_needed)                \
  571.       fprintf (FILE, "\tfmovem (sp)+,$0x%x\n", fmask);        \
  572.     else                            \
  573.       fprintf (FILE, "\tfmovem -%d(a6),$0x%x\n",        \
  574.            foffset + fsize, fmask); }            \
  575.   if (fpoffset != 0)                        \
  576.     for (regno = 55; regno >= 24; regno--)            \
  577.       if (regs_ever_live[regno] && ! call_used_regs[regno]) {    \
  578.     if (big)                        \
  579.       fprintf(FILE, "\tfpmoved -%d(a6,a0.l), %s\n",    \
  580.           fpoffset + fsize, reg_names[regno]);        \
  581.     else if (! frame_pointer_needed)            \
  582.       fprintf(FILE, "\tfpmoved (sp)+, %s\n",            \
  583.           reg_names[regno]);                \
  584.     else                            \
  585.       fprintf(FILE, "\tfpmoved -%d(a6), %s\n",        \
  586.           fpoffset + fsize, reg_names[regno]);        \
  587.     fpoffset -= 8;                        \
  588.       }                                \
  589.   if (frame_pointer_needed)                    \
  590.     fprintf (FILE, "\tunlk a6\n");                \
  591.   if (current_function_pops_args)                \
  592.     fprintf (FILE, "\trtd $%d\n", current_function_pops_args);    \
  593.   else fprintf (FILE, "\trts\n"); }
  594.  
  595.