home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / out-a29k.c < prev    next >
C/C++ Source or Header  |  1991-06-04  |  33KB  |  1,248 lines
  1. /* Subroutines used for code generation on AMD Am29000.
  2.    Copyright (C) 1987, 1988, 1990, 1991 Free Software Foundation, Inc.
  3.    Contributed by Richard Kenner (kenner@nyu.edu)
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include <stdio.h>
  22. #include "config.h"
  23. #include "rtl.h"
  24. #include "regs.h"
  25. #include "hard-reg-set.h"
  26. #include "real.h"
  27. #include "insn-config.h"
  28. #include "conditions.h"
  29. #include "insn-flags.h"
  30. #include "output.h"
  31. #include "insn-attr.h"
  32. #include "flags.h"
  33. #include "recog.h"
  34. #include "expr.h"
  35. #include "obstack.h"
  36. #include "tree.h"
  37.  
  38. #define min(A,B)    ((A) < (B) ? (A) : (B))
  39.  
  40. /* This gives the size in words of the register stack for the current
  41.    procedure.  */
  42.  
  43. static int a29k_regstack_size;
  44.  
  45. /* This points to the last insn of the insn prologue.  It is set when
  46.    an insn without a filled delay slot is found near the start of the
  47.    function.  */
  48.  
  49. static char *a29k_last_prologue_insn;
  50.  
  51. /* This points to the first insn that will be in the epilogue.  It is null if
  52.    no epilogue is required.  */
  53.  
  54. static char *a29k_first_epilogue_insn;
  55.  
  56. /* This is nonzero if a a29k_first_epilogue_insn was put in a delay slot.  It
  57.    indicates that an intermediate label needs to be written.  */
  58.  
  59. static int a29k_first_epilogue_insn_used;
  60.  
  61. /* Location to hold the name of the current function.  We need this prolog to
  62.    contain the tag words prior to the declaration.  So the name must be stored
  63.    away.  */
  64.  
  65. char *a29k_function_name;
  66.  
  67. /* Save information from a "cmpxx" operation until the branch or scc is
  68.    emitted.  */
  69.  
  70. rtx a29k_compare_op0, a29k_compare_op1;
  71. int a29k_compare_fp_p;
  72.  
  73. /* Gives names for registers.  */
  74. extern char *reg_names[];
  75.  
  76. /* Returns 1 if OP is a 8-bit constant. */
  77.  
  78. int
  79. cint_8_operand (op, mode)
  80.      register rtx op;
  81.      enum machine_mode mode;
  82. {
  83.   return GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffffff00) == 0;
  84. }
  85.  
  86. /* Returns 1 if OP is a 16-bit constant.  */
  87.  
  88. int
  89. cint_16_operand (op, mode)
  90.      rtx op;
  91.      enum machine_mode mode;
  92. {
  93.   return GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffff0000) == 0;
  94. }
  95.  
  96. /* Returns 1 if OP cannot be moved in a single insn.  */
  97.  
  98. int
  99. long_const_operand (op, mode)
  100.      register rtx op;
  101.      enum machine_mode mode;
  102. {
  103.   if (! CONSTANT_P (op))
  104.     return 0;
  105.  
  106.   if (TARGET_29050 && GET_CODE (op) == CONST_INT
  107.       && (INTVAL (op) & 0xffff) == 0)
  108.     return 0;
  109.  
  110.   return (GET_CODE (op) != CONST_INT
  111.       || ((INTVAL (op) & 0xffff0000) != 0
  112.           && (INTVAL (op) & 0xffff0000) != 0xffff0000
  113.           && INTVAL (op) != 0x80000000));
  114. }
  115.  
  116. /* The following four functions detect constants of 0, 8, 16, and 24 used as
  117.    a position in ZERO_EXTRACT operations.  They can either be the appropriate
  118.    constant integer or a shift (which will be produced by combine).  */
  119.  
  120. static int
  121. shift_constant_operand (op, mode, val)
  122.      rtx op;
  123.      enum machine_mode mode;
  124.      int val;
  125. {
  126.   return ((GET_CODE (op) == CONST_INT && INTVAL (op) == val)
  127.       || (GET_CODE (op) == ASHIFT
  128.           && GET_CODE (XEXP (op, 0)) == CONST_INT
  129.           && INTVAL (XEXP (op, 0)) == val / 8
  130.           && GET_CODE (XEXP (op, 1)) == CONST_INT
  131.           && INTVAL (XEXP (op, 1)) == 3));
  132. }
  133.  
  134. int
  135. const_0_operand (op, mode)
  136.      rtx op;
  137.      enum machine_mode mode;
  138. {
  139.   return shift_constant_operand (op, mode, 0);
  140. }
  141.  
  142. int
  143. const_8_operand (op, mode)
  144.      rtx op;
  145.      enum machine_mode mode;
  146. {
  147.   return shift_constant_operand (op, mode, 8);
  148. }
  149.  
  150. int
  151. const_16_operand (op, mode)
  152.      rtx op;
  153.      enum machine_mode;
  154. {
  155.   return shift_constant_operand (op, mode, 16);
  156. }
  157.  
  158. int
  159. const_24_operand (op, mode)
  160.      rtx op;
  161.      enum machine_mode;
  162. {
  163.   return shift_constant_operand (op, mode, 24);
  164. }
  165.  
  166. /* Returns 1 if OP is a floating-point constant of the proper mode.  */
  167.  
  168. int
  169. float_const_operand (op, mode)
  170.      rtx op;
  171.      enum machine_mode mode;
  172. {
  173.   return GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == mode;
  174. }
  175.  
  176. /* Returns 1 if OP is a floating-point constant of the proper mode or a
  177.    general-purpose register.  */
  178.  
  179. int
  180. gen_reg_or_float_constant_operand (op, mode)
  181.      rtx op;
  182.      enum machine_mode mode;
  183. {
  184.   return float_const_operand (op, mode) || gen_reg_operand (op, mode);
  185. }
  186.      
  187. /* Returns 1 if OP is a special machine register.  */
  188.  
  189. int
  190. spec_reg_operand (op, mode)
  191.      rtx op;
  192.      enum machine_mode mode;
  193. {
  194.   return GET_MODE (op) == SImode && GET_CODE (op) == REG
  195.      && REGNO (op) >= R_BP && REGNO (op) <= R_EXO;
  196. }
  197.  
  198. /* Returns 1 if OP is an accumulator register.  */
  199.  
  200. int
  201. accum_reg_operand (op, mode)
  202.      rtx op;
  203.      enum machine_mode mode;
  204. {
  205.   return (GET_CODE (op) == REG
  206.       && REGNO (op) >= R_ACC (0) && REGNO (op) <= R_ACC (3));
  207. }
  208.  
  209. /* Returns 1 if OP is a normal data register.  */
  210.  
  211. int
  212. gen_reg_operand (op, mode)
  213.      rtx op;
  214.      enum machine_mode mode;
  215. {
  216.   int regno;
  217.  
  218.   if (GET_MODE (op) != mode && mode != VOIDmode)
  219.     return 0;
  220.  
  221.   if (GET_CODE (op) == REG)
  222.     regno = REGNO (op);
  223.   else if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
  224.     {
  225.       regno = REGNO (SUBREG_REG (op));
  226.       if (regno < FIRST_PSEUDO_REGISTER)
  227.     regno += SUBREG_WORD (op);
  228.     }
  229.   else
  230.     return 0;
  231.  
  232.   return regno >= FIRST_PSEUDO_REGISTER || regno < R_BP;
  233. }
  234.  
  235. /* Returns 1 if OP is either an 8-bit constant integer or a general register.
  236.    If a register, it must be in the proper mode unless MODE is VOIDmode.  */
  237.  
  238. int
  239. srcb_operand (op, mode)
  240.       register rtx op;
  241.       enum machine_mode mode;
  242. {
  243.   if (GET_CODE (op) == CONST_INT
  244.       && (mode == QImode
  245.       || (INTVAL (op) & 0xffffff00) == 0))
  246.     return 1;
  247.  
  248.   if (GET_MODE (op) != mode && mode != VOIDmode)
  249.     return 0;
  250.  
  251.   return gen_reg_operand (op, mode);
  252. }
  253.  
  254. /* Return 1 if OP is either an immediate or a general register.  This is used
  255.    for the input operand of mtsr/mtrsim.  */
  256.  
  257. int
  258. gen_reg_or_immediate_operand (op, mode)
  259.      rtx op;
  260.      enum machine_mode;
  261. {
  262.   return gen_reg_operand (op, mode) || immediate_operand (op, mode);
  263. }
  264.  
  265. /* Return 1 if OP can be used as the second operand of and AND insn.  This
  266.    includes srcb_operand and a constant whose complement fits in 8 bits.  */
  267.  
  268. int
  269. and_operand (op, mode)
  270.      rtx op;
  271.      enum machine_mode;
  272. {
  273.   return (srcb_operand (op, mode)
  274.       || (GET_CODE (op) == CONST_INT
  275.           && ((unsigned) ((~ INTVAL (op)) & GET_MODE_MASK (mode)) < 256)));
  276. }
  277.  
  278. /* Return 1 if OP can be used as the second operand of an ADD insn.
  279.    This is the same as above, except we use negative, rather than
  280.    complement.   */
  281.  
  282. int
  283. add_operand (op, mode)
  284.      rtx op;
  285.      enum machine_mode;
  286. {
  287.   return (srcb_operand (op, mode)
  288.       || (GET_CODE (op) == CONST_INT
  289.           && ((unsigned) ((- INTVAL (op)) & GET_MODE_MASK (mode)) < 256)));
  290. }
  291.  
  292. /* Return 1 if OP can be used as the input operand for a move insn.  */
  293.  
  294. int
  295. in_operand (op, mode)
  296.      rtx op;
  297.      enum machine_mode mode;
  298. {
  299.   rtx orig_op = op;
  300.  
  301.   if (! general_operand (op, mode))
  302.     return 0;
  303.  
  304.   while (GET_CODE (op) == SUBREG)
  305.     op = SUBREG_REG (op);
  306.  
  307.   switch (GET_CODE (op))
  308.     {
  309.     case REG:
  310.       return 1;
  311.  
  312.     case MEM:
  313.       return (GET_MODE_SIZE (mode) >= UNITS_PER_WORD || TARGET_DW_ENABLE);
  314.  
  315.     case CONST_INT:
  316.       if (GET_MODE_CLASS (mode) != MODE_INT)
  317.     return 0;
  318.  
  319.       return 1;
  320.  
  321.     case CONST:
  322.     case SYMBOL_REF:
  323.     case LABEL_REF:
  324.       return (GET_MODE (op) == mode
  325.           || mode == SImode || mode == HImode || mode == QImode);
  326.  
  327.     case CONST_DOUBLE:
  328.       return ((GET_MODE_CLASS (mode) == MODE_FLOAT
  329.            && mode == GET_MODE (op))
  330.           || (GET_MODE (op) == VOIDmode
  331.           && GET_MODE_CLASS (mode) == MODE_INT));
  332.  
  333.     default:
  334.       return 0;
  335.     }
  336. }
  337.  
  338. /* Return 1 if OP can be used as the output operand for a move insn.  */
  339.  
  340. int
  341. out_operand (op, mode)
  342.      rtx op;
  343.      enum machine_mode mode;
  344. {
  345.   rtx orig_op = op;
  346.  
  347.   if (! general_operand (op, mode))
  348.     return 0;
  349.  
  350.   while (GET_CODE (op) == SUBREG)
  351.     op = SUBREG_REG (op);
  352.  
  353.   if (GET_CODE (op) == REG)
  354.     return (mode == SImode || gen_reg_operand (orig_op, mode)
  355.         || (GET_MODE_CLASS (mode) == MODE_FLOAT
  356.         && accum_reg_operand (orig_op, mode)));
  357.  
  358.   else if (GET_CODE (op) == MEM)
  359.     return mode == SImode || mode == SFmode || TARGET_DW_ENABLE;
  360.  
  361.   else
  362.     return 0;
  363. }
  364.  
  365. /* Return 1 if OP is some extension operator.  */
  366.  
  367. int
  368. extend_operator (op, mode)
  369.      rtx op;
  370.      enum machine_mode mode;
  371. {
  372.   return ((mode == VOIDmode || GET_MODE (op) == mode)
  373.       && (GET_CODE (op) == ZERO_EXTEND || GET_CODE (op) == SIGN_EXTEND));
  374. }
  375.  
  376. /* Return 1 if OP is a comparison operator that we have in floating-point.  */
  377.  
  378. int
  379. fp_comparison_operator (op, mode)
  380.      rtx op;
  381.      enum machine_mode mode;
  382. {
  383.   return ((mode == VOIDmode || mode == GET_MODE (op))
  384.       && (GET_CODE (op) == EQ || GET_CODE (op) == GT ||
  385.           GET_CODE (op) == GE));
  386. }
  387.  
  388. /* Return 1 if OP is a valid branch comparison.  */
  389.  
  390. int
  391. branch_operator (op, mode)
  392.      rtx op;
  393.      enum machine_mode mode;
  394. {
  395.   return ((mode == VOIDmode || mode == GET_MODE (op))
  396.       && (GET_CODE (op) == GE || GET_CODE (op) == LT));
  397. }
  398.  
  399. /* Return 1 if OP is a load multiple operation.  It is known to be a
  400.    PARALLEL and the first three sections will be tested.  */
  401.  
  402. int
  403. load_multiple_operation (op, mode)
  404.      rtx op;
  405.      enum machine_mode mode;
  406. {
  407.   int count = XVECLEN (op, 0) - 2;
  408.   int dest_regno;
  409.   rtx src_addr;
  410.   int i;
  411.  
  412.   /* Perform a quick check so we don't blow up below.  */
  413.   if (count <= 1
  414.       || GET_CODE (XVECEXP (op, 0, 0)) != SET
  415.       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != REG
  416.       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != MEM)
  417.     return 0;
  418.  
  419.   dest_regno = REGNO (SET_DEST (XVECEXP (op, 0, 0)));
  420.   src_addr = XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0);
  421.  
  422.   for (i = 1; i < count; i++)
  423.     {
  424.       rtx elt = XVECEXP (op, 0, i + 2);
  425.  
  426.       if (GET_CODE (elt) != SET
  427.       || GET_CODE (SET_DEST (elt)) != REG
  428.       || GET_MODE (SET_DEST (elt)) != SImode
  429.       || REGNO (SET_DEST (elt)) != dest_regno + i
  430.       || GET_CODE (SET_SRC (elt)) != MEM
  431.       || GET_MODE (SET_SRC (elt)) != SImode
  432.       || GET_CODE (XEXP (SET_SRC (elt), 0)) != PLUS
  433.       || ! rtx_equal_p (XEXP (XEXP (SET_SRC (elt), 0), 0), src_addr)
  434.       || GET_CODE (XEXP (XEXP (SET_SRC (elt), 0), 1)) != CONST_INT
  435.       || INTVAL (XEXP (XEXP (SET_SRC (elt), 0), 1)) != i * 4)
  436.     return 0;
  437.     }
  438.  
  439.   return 1;
  440. }
  441.  
  442. /* Similar, but tests for store multiple.  */
  443.  
  444. int
  445. store_multiple_operation (op, mode)
  446.      rtx op;
  447.      enum machine_mode mode;
  448. {
  449.   int num_special = TARGET_NO_STOREM_BUG ? 2 : 1;
  450.   int count = XVECLEN (op, 0) - num_special;
  451.   int src_regno;
  452.   rtx dest_addr;
  453.   int i;
  454.  
  455.   /* Perform a quick check so we don't blow up below.  */
  456.   if (count <= 1
  457.       || GET_CODE (XVECEXP (op, 0, 0)) != SET
  458.       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != MEM
  459.       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != REG)
  460.     return 0;
  461.  
  462.   src_regno = REGNO (SET_SRC (XVECEXP (op, 0, 0)));
  463.   dest_addr = XEXP (SET_DEST (XVECEXP (op, 0, 0)), 0);
  464.  
  465.   for (i = 1; i < count; i++)
  466.     {
  467.       rtx elt = XVECEXP (op, 0, i + num_special);
  468.  
  469.       if (GET_CODE (elt) != SET
  470.       || GET_CODE (SET_SRC (elt)) != REG
  471.       || GET_MODE (SET_SRC (elt)) != SImode
  472.       || REGNO (SET_SRC (elt)) != src_regno + i
  473.       || GET_CODE (SET_DEST (elt)) != MEM
  474.       || GET_MODE (SET_DEST (elt)) != SImode
  475.       || GET_CODE (XEXP (SET_DEST (elt), 0)) != PLUS
  476.       || ! rtx_equal_p (XEXP (XEXP (SET_DEST (elt), 0), 0), dest_addr)
  477.       || GET_CODE (XEXP (XEXP (SET_DEST (elt), 0), 1)) != CONST_INT
  478.       || INTVAL (XEXP (XEXP (SET_DEST (elt), 0), 1)) != i * 4)
  479.     return 0;
  480.     }
  481.  
  482.   return 1;
  483. }
  484.  
  485. /* Given a special register REG and MASK, a value being masked against a
  486.    quantity to which the special register is set, return 1 if the masking
  487.    operation is built-in to the setting of that special register.  */
  488.  
  489. int
  490. masks_bits_for_special (reg, mask)
  491.      rtx reg;
  492.      rtx mask;
  493. {
  494.    int needed_mask_value;
  495.  
  496.   if (GET_CODE (reg) != REG || GET_CODE (mask) != CONST_INT)
  497.     abort ();
  498.  
  499.   switch (REGNO (reg))
  500.     {
  501.     case R_BP:
  502.     case R_INT:
  503.       needed_mask_value = 3;
  504.       break;
  505.  
  506.     case R_FC:
  507.       needed_mask_value = 31;
  508.       break;
  509.  
  510.     case R_CR:
  511.     case R_LRU:
  512.       needed_mask_value = 255;
  513.       break;
  514.  
  515.     case R_FPE:
  516.       needed_mask_value = 511;
  517.       break;
  518.  
  519.     case R_MMU:
  520.       needed_mask_value = 0x3ff;
  521.       break;
  522.  
  523.     case R_OPS:
  524.     case R_CPS:
  525.     case R_RBP:
  526.     case R_FPS:
  527.       needed_mask_value = 0xffff;
  528.       break;
  529.  
  530.     case R_VAB:
  531.       needed_mask_value = 0xffff0000;
  532.       break;
  533.  
  534.     case R_Q:
  535.     case R_CFG:
  536.     case R_CHA:
  537.     case R_CHD:
  538.     case R_CHC:
  539.     case R_TMC:
  540.     case R_TMR:
  541.     case R_PC0:
  542.     case R_PC1:
  543.     case R_PC2:
  544.       return 0;
  545.  
  546.     default:
  547.       abort ();
  548.     }
  549.  
  550.    return (INTVAL (mask) & ~ needed_mask_value) == 0;
  551. }
  552.  
  553. /* Return nonzero if this label is that of the return point, but there is
  554.    a non-null epilogue.  */
  555.  
  556. int
  557. epilogue_operand (op, mode)
  558.      rtx op;
  559.      enum machine_mode mode;
  560. {
  561.   return next_active_insn (op) == 0 && a29k_first_epilogue_insn != 0;
  562. }
  563.  
  564. /* Return the register class of a scratch register needed to copy IN into
  565.    or out of a register in CLASS in MODE.  If it can be done directly,
  566.    NO_REGS is returned.  */
  567.  
  568. enum reg_class
  569. secondary_reload_class (class, mode, in)
  570.      enum reg_class class;
  571.      enum machine_mode mode;
  572.      rtx in;
  573. {
  574.   int regno = -1;
  575.  
  576.   if (GET_CODE (in) == REG || GET_CODE (in) == SUBREG)
  577.     regno = true_regnum (in);
  578.  
  579.   /* We can place anything into GENERAL_REGS and can put GENERAL_REGS
  580.      into anything.  */
  581.   if (class == GENERAL_REGS || regno < R_BP)
  582.     return NO_REGS;
  583.  
  584.   /* We can place 16-bit constants into a special register.  */
  585.   if (GET_CODE (in) == CONST_INT
  586.       && (GET_MODE_BITSIZE (mode) <= 16
  587.       || (unsigned) INTVAL (in) <= 65535)
  588.       && (class == BP_REGS || class == Q_REGS || class == SPECIAL_REGS))
  589.     return NO_REGS;
  590.  
  591.   /* Otherwise, we need GENERAL_REGS.  */
  592.   return GENERAL_REGS;
  593. }
  594.  
  595. /* START is the zero-based incoming argument register index used (0 is 160,
  596.    i.e., the first incoming argument register) and COUNT is the number used.
  597.  
  598.    Mark the corresponding incoming registers as neither fixed nor call used.
  599.    For each register used for incoming arguments, we have one less local
  600.    register that can be used.  So also mark some high-numbered registers as
  601.    fixed.
  602.  
  603.    Return the first register number to use for the argument.  */
  604.  
  605. int
  606. incoming_reg (start, count)
  607.      int start;
  608.      int count;
  609. {
  610.   int i;
  611.  
  612.   if (! TARGET_NO_REUSE_ARGS)
  613.     /* Mark all the used registers as not fixed and saved over calls.  */
  614.     for (i = R_AR (start); i < R_AR (16) && i < R_AR (start + count); i++)
  615.       {
  616.     fixed_regs[i] = call_used_regs[i] = call_fixed_regs[i] = 0;
  617.     CLEAR_HARD_REG_BIT (fixed_reg_set, i);
  618.     CLEAR_HARD_REG_BIT (call_used_reg_set, i);
  619.     CLEAR_HARD_REG_BIT (call_fixed_reg_set, i);
  620.       }
  621.  
  622.   /* Shorten the maximum size of the frame.  */
  623.   for (i = R_AR (0) - start - count; i < R_AR (0) - start; i++)
  624.     {
  625.       fixed_regs[i] = call_used_regs[i] = call_fixed_regs[i] = 1;
  626.       SET_HARD_REG_BIT (fixed_reg_set, i);
  627.       SET_HARD_REG_BIT (call_used_reg_set, i);
  628.       SET_HARD_REG_BIT (call_fixed_reg_set, i);
  629.     }
  630.  
  631.   return R_AR (start);
  632. }
  633.  
  634. /* These routines are used in finding insns to fill delay slots in the
  635.    epilogue.  */
  636.  
  637. /* Return 1 if the current function will adjust the register stack.  */
  638.  
  639. int
  640. needs_regstack_p ()
  641. {
  642.   int i;
  643.   rtx insn;
  644.  
  645.   if (frame_pointer_needed)
  646.     return 1;
  647.  
  648.   /* If any local register is used, we need to adjust the regstack.  */
  649.   for (i = R_LR (127); i >= R_LR (0); i --)
  650.     if (regs_ever_live[i])
  651.       return 1;
  652.  
  653.   /* We need a register stack if we make any calls.  */
  654.   for (insn = get_insns (); insn; insn = next_insn (insn))
  655.     if (GET_CODE (insn) == CALL_INSN
  656.     || (GET_CODE (insn) == INSN
  657.         && GET_CODE (PATTERN (insn)) == SEQUENCE
  658.         && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
  659.       return 1;
  660.  
  661.   /* Otherwise, we don't.  */
  662.   return 0;
  663. }
  664.  
  665. /* Return 1 if X uses a local register.  */
  666.  
  667. int
  668. uses_local_reg_p (x)
  669.      rtx x;
  670. {
  671.   char *fmt;
  672.   int i, j;
  673.  
  674.   switch (GET_CODE (x))
  675.     {
  676.     case REG:
  677.       return REGNO (x) >= R_LR (0) && REGNO (x) <= R_FP;
  678.  
  679.     case CONST_INT:
  680.     case CONST:
  681.     case PC:
  682.     case CC0:
  683.     case LABEL_REF:
  684.     case SYMBOL_REF:
  685.       return 0;
  686.     }
  687.  
  688.   fmt = GET_RTX_FORMAT (GET_CODE (x));
  689.   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
  690.     {
  691.       if (fmt[i] == 'e')
  692.     {
  693.       if (uses_local_reg_p (XEXP (x, i)))
  694.         return 1;
  695.     }
  696.       else if (fmt[i] == 'E')
  697.     {
  698.       for (j = XVECLEN (x, i) - 1; j >= 0; j--)
  699.         if (uses_local_reg_p (XVECEXP (x, i, j)))
  700.           return 1;
  701.     }
  702.     }
  703.  
  704.   return 0;
  705. }
  706.  
  707. /* Returns 1 if this function is known to have a null epilogue.  */
  708.  
  709. int
  710. null_epilogue ()
  711. {
  712.   return (reload_completed && ! needs_regstack_p ()
  713.       && get_frame_size () == 0
  714.       && current_function_pretend_args_size == 0);
  715. }
  716.  
  717. /* Write out the assembler form of an operand.  Recognize the following
  718.    special options:
  719.  
  720.     %N means write the low-order 8 bits of the negative of the constant
  721.     %Q means write a QImode operand (truncate constants to 8 bits)
  722.     %M means write the low-order 16 bits of the constant
  723.     %C means write the low-order 8 bits of the complement of the constant
  724.     %X means write the cntl values for LOAD with operand an extension op
  725.     %b means write `f' is this is a reversed condition, `t' otherwise
  726.     %B means write `t' is this is a reversed condition, `f' otherwise
  727.     %J means write the 29k opcode part for a comparison operation
  728.     %e means write the label with an extra `X' is this is the epilogue
  729.                    otherwise the normal label name
  730.     %E means write nothing if this insn has a delay slot,
  731.                a nop unless this is the epilogue label, in which case
  732.                write the first epilogue insn
  733.     %F means write just the normal operand if the insn has a delay slot;
  734.                otherwise, this is a recursive call so output the
  735.                symbol + 4 and write the first prologue insn in the
  736.                delay slot.
  737.     %L means write the register number plus one ("low order" register)
  738.                or the low-order part of a multi-word constant
  739.     %O means write the register number plus two
  740.     %P means write the register number plus three ("low order" of TImode)
  741.     %S means write the number of words in the mode of the operand,
  742.                minus one (for CR)
  743.         %V means write the number of elements in a PARALLEL minus 1
  744.     %# means write nothing if we have a delay slot, "\n\tnop" otherwise
  745.     %* means write the register name for TPC.  */
  746.  
  747. void
  748. print_operand (file, x, code)
  749.      FILE *file;
  750.      rtx x;
  751.      char code;
  752. {
  753.   char buf[100];
  754.  
  755.   /* These macros test for integers and extract the low-order bits.  */
  756. #define INT_P(X)  \
  757. ((GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE)    \
  758.  && GET_MODE (X) == VOIDmode)
  759.  
  760. #define INT_LOWPART(X) \
  761.   (GET_CODE (X) == CONST_INT ? INTVAL (X) : CONST_DOUBLE_LOW (X))
  762.  
  763.   switch (code)
  764.     {
  765.     case 'Q':
  766.       if (GET_CODE (x) == REG)
  767.     break;
  768.       else if (! INT_P (x))
  769.     output_operand_lossage ("invalid %%Q value");
  770.       fprintf (file, "%d", INT_LOWPART (x) & 0xff);
  771.       return;
  772.  
  773.     case 'C':
  774.       if (! INT_P (x))
  775.     output_operand_lossage ("invalid %%C value");
  776.       fprintf (file, "%d", (~ INT_LOWPART (x)) & 0xff);
  777.       return;
  778.  
  779.     case 'N':
  780.       if (! INT_P (x))
  781.     output_operand_lossage ("invalid %%N value");
  782.       fprintf (file, "%d", (- INT_LOWPART (x)) & 0xff);
  783.       return;
  784.  
  785.     case 'M':
  786.       if (! INT_P (x))
  787.     output_operand_lossage ("invalid %%M value");
  788.       fprintf (file, "%d", INT_LOWPART (x) & 0xffff);
  789.       return;
  790.  
  791.     case 'X':
  792.       fprintf (file, "%d", ((GET_MODE (XEXP (x, 0)) == QImode ? 1 : 2)
  793.                 + (GET_CODE (x) == SIGN_EXTEND ? 16 : 0)));
  794.       return;
  795.   
  796.     case 'b':
  797.       if (GET_CODE (x) == GE)
  798.     fprintf (file, "f");
  799.       else
  800.     fprintf (file, "t");
  801.       return;
  802.  
  803.     case 'B':
  804.       if (GET_CODE (x) == GE)
  805.     fprintf (file, "t");
  806.       else
  807.     fprintf (file, "f");
  808.       return;
  809.  
  810.     case 'J':
  811.       /* It so happens that the RTX names for the conditions are the same as
  812.      the 29k's insns except for "ne", which requires "neq".  */
  813.       fprintf (file, GET_RTX_NAME (GET_CODE (x)));
  814.       if (GET_CODE (x) == NE)
  815.     fprintf (file, "q");
  816.       return;
  817.  
  818.     case 'e':
  819.       if (optimize && flag_delayed_branch
  820.       && a29k_last_prologue_insn == 0 && epilogue_operand (x, VOIDmode)
  821.       && dbr_sequence_length () == 0)
  822.     {
  823.       ASM_GENERATE_INTERNAL_LABEL (buf, "LX", CODE_LABEL_NUMBER (x));
  824.       assemble_name (file, buf);
  825.     }
  826.       else
  827.     output_asm_label (x);
  828.       return;
  829.  
  830.     case 'E':
  831.       if (dbr_sequence_length ())
  832.     ;
  833.       else if (a29k_last_prologue_insn)
  834.     {
  835.       fprintf (file, "\n\t%s", a29k_last_prologue_insn);
  836.       a29k_last_prologue_insn = 0;
  837.     }
  838.       else if (optimize && flag_delayed_branch
  839.            && epilogue_operand (x, VOIDmode))
  840.     {
  841.       fprintf (file, "\n\t%s", a29k_first_epilogue_insn);
  842.       a29k_first_epilogue_insn_used = 1;
  843.     }
  844.       else
  845.     fprintf (file, "\n\tnop");
  846.       return;
  847.       
  848.     case 'F':
  849.       output_addr_const (file, x);
  850.       if (! strcmp (XSTR (x, 0), current_function_name)
  851.       && dbr_sequence_length () == 0)
  852.     fprintf (file, "+4\n\t%s,%d",
  853.          a29k_regstack_size >= 64 ? "const gr121" : "sub gr1,gr1",
  854.          a29k_regstack_size * 4);
  855.       return;
  856.  
  857.     case 'L':
  858.       if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) == DFmode)
  859.     {
  860.       union real_extract u;
  861.  
  862.       bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
  863.       fprintf (file, "$double1(%.20e)", u.d);
  864.     }
  865.       else if (GET_CODE (x) == REG)
  866.     fprintf (file, "%s", reg_names[REGNO (x) + 1]);
  867.       else
  868.     output_operand_lossage ("invalid %%L value");
  869.       return;
  870.  
  871.     case 'O':
  872.       if (GET_CODE (x) != REG)
  873.     output_operand_lossage ("invalid %%O value");
  874.       fprintf (file, "%s", reg_names[REGNO (x) + 2]);
  875.       return;
  876.  
  877.     case 'P':
  878.       if (GET_CODE (x) != REG)
  879.     output_operand_lossage ("invalid %%P value");
  880.       fprintf (file, "%s", reg_names[REGNO (x) + 3]);
  881.       return;
  882.  
  883.     case 'S':
  884.       fprintf (file, "%d", (GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD)-1);
  885.       return;
  886.  
  887.     case 'V':
  888.       if (GET_CODE (x) != PARALLEL)
  889.     output_operand_lossage ("invalid %%V value");
  890.       fprintf (file, "%d", XVECLEN (x, 0) - 2);
  891.       return;
  892.  
  893.     case '#':
  894.       if (dbr_sequence_length () == 0)
  895.     {
  896.       if (a29k_last_prologue_insn)
  897.         {
  898.           fprintf (file, "\n\t%s", a29k_last_prologue_insn);
  899.           a29k_last_prologue_insn = 0;
  900.         }
  901.       else
  902.         fprintf (file, "\n\tnop");
  903.     }
  904.       return;
  905.  
  906.     case '*':
  907.       fprintf (file, "%s", reg_names [R_TPC]);
  908.       return;
  909.     }
  910.  
  911.   if (GET_CODE (x) == REG)
  912.     fprintf (file, "%s", reg_names [REGNO (x)]);
  913.  
  914.   else if (GET_CODE (x) == MEM)
  915.     output_address (XEXP (x, 0));
  916.  
  917.   else if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == SUBREG
  918.        && GET_CODE (SUBREG_REG (XEXP (x, 0))) == CONST_DOUBLE)
  919.     {
  920.       union real_extract u;
  921.  
  922.       if (GET_MODE (SUBREG_REG (XEXP (x, 0))) == SFmode)
  923.     fprintf (file, "$float");
  924.       else
  925.     fprintf (file, "$double%d", SUBREG_WORD (XEXP (x, 0)));
  926.       bcopy (&CONST_DOUBLE_LOW (SUBREG_REG (XEXP (x, 0))), &u, sizeof u);
  927.       fprintf (file, "(%.20e)", u.d);
  928.     }
  929.  
  930.   else if (GET_CODE (x) == CONST_DOUBLE
  931.        && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
  932.     {
  933.       union real_extract u;
  934.  
  935.       bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
  936.       fprintf (file, "$%s(%.20e)",
  937.            GET_MODE (x) == SFmode ? "float" : "double0", u.d);
  938.     }
  939.  
  940.   else
  941.     output_addr_const (file, x);
  942. }
  943.  
  944. /* This page contains routines to output function prolog and epilog code. */
  945.  
  946. /* Output function prolog code to file FILE.  Memory stack size is SIZE.
  947.  
  948.    Also sets register names for incoming arguments and frame pointer.  */
  949.  
  950. void
  951. output_prolog (file, size)
  952.      FILE *file;
  953.      int size;
  954. {
  955.   int makes_calls = 0;
  956.   int arg_count = 0;
  957.   rtx insn;
  958.   int i;
  959.   unsigned int tag_word;
  960.  
  961.   /* See if we make any calls.  We need to set lr1 if so.  */
  962.   for (insn = get_insns (); insn; insn = next_insn (insn))
  963.     if (GET_CODE (insn) == CALL_INSN
  964.     || (GET_CODE (insn) == INSN
  965.         && GET_CODE (PATTERN (insn)) == SEQUENCE
  966.         && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
  967.       {
  968.     makes_calls = 1;
  969.     break;
  970.       }
  971.  
  972.   /* Find the highest local register used.  */
  973.   for (i = R_LR (127); i >= R_LR (0); i--)
  974.     if (regs_ever_live[i])
  975.       break;
  976.  
  977.   a29k_regstack_size = i - (R_LR (0) - 1);
  978.  
  979.   /* If calling routines, ensure we count lr0 & lr1.  */
  980.   if (makes_calls && a29k_regstack_size < 2)
  981.     a29k_regstack_size = 2;
  982.  
  983.   /* Count frame pointer and align to 8 byte boundary (even number of
  984.      registers).  */
  985.   a29k_regstack_size += frame_pointer_needed;
  986.   if (a29k_regstack_size & 1) a29k_regstack_size++;
  987.  
  988.   /* See how many incoming arguments we have in registers.  */
  989.   for (i = R_AR (0); i < R_AR (16); i++)
  990.     if (! fixed_regs[i])
  991.       arg_count++;
  992.  
  993.   /* The argument count includes the caller's lr0 and lr1.  */
  994.   arg_count += 2;
  995.  
  996.   /* Set the names of the frame pointer and incoming argument registers.  */
  997.   reg_names[FRAME_POINTER_REGNUM] = reg_names[R_LR (a29k_regstack_size - 1)];
  998.   for (i = 0; i < 16; i++)
  999.     reg_names[R_AR (i)] = reg_names[R_LR (a29k_regstack_size + i + 2)];
  1000.  
  1001.   /* Compute memory stack size.  Add in number of bytes that the we should
  1002.      push and pretend the caller did and the size of outgoing arguments.
  1003.      Then round to a doubleword boundary.  */
  1004.   size += (current_function_pretend_args_size
  1005.        + current_function_outgoing_args_size);
  1006.   size = (size + 7) & ~7;
  1007.  
  1008.   /* Write header words.  See if one or two word form.  */
  1009.   tag_word = (frame_pointer_needed ? 0x400000 : 0) + (arg_count << 16);
  1010.  
  1011.   if (size / 8 > 0xff)
  1012.     fprintf (file, "\t.word %d, 0x%0x\n", (size / 8) << 2,
  1013.          0x800000 + tag_word);
  1014.   else
  1015.     fprintf (file, "\t.word 0x%0x\n", tag_word + ((size / 8) << 3));
  1016.  
  1017.   /* Define the function name.  */
  1018.   assemble_name (file, a29k_function_name);
  1019.   fprintf (file, ":\n");
  1020.  
  1021.   /* Push the register stack by the proper amount.  There are two possible
  1022.      ways to do this.  */
  1023.   if (a29k_regstack_size >= 256/4)
  1024.     fprintf (file, "\tconst %s,%d\n\tsub gr1,gr1,%s\n",
  1025.          reg_names[R_TAV], a29k_regstack_size * 4, reg_names[R_TAV]);
  1026.   else if (a29k_regstack_size)
  1027.     fprintf (file, "\tsub gr1,gr1,%d\n", a29k_regstack_size * 4);
  1028.  
  1029.   /* Test that the registers are available.  */
  1030.   if (a29k_regstack_size)
  1031.     fprintf (file, "\tasgeu V_%sSPILL,gr1,%s\n",
  1032.          TARGET_KERNEL_REGISTERS ? "K" : "", reg_names[R_RAB]);
  1033.  
  1034.   /* Set up frame pointer, if one is needed.  */
  1035.   if (frame_pointer_needed)
  1036.     fprintf (file, "\tsll %s,%s,0\n", reg_names[FRAME_POINTER_REGNUM],
  1037.          reg_names[R_MSP]);
  1038.  
  1039.   /* Make room for any frame space.  There are three ways to do this.  */
  1040.   if (size >= 256)
  1041.     {
  1042.       fprintf (file, "\tconst %s,%d\n", reg_names[R_TAV], size);
  1043.       if (size >= 65536)
  1044.     fprintf (file, "\tconsth %s,%d\n", reg_names[R_TAV], size);
  1045.       if (TARGET_STACK_CHECK)
  1046.     fprintf (file, "\tcall %s,__msp_check\n", reg_names[R_TPC]);
  1047.       fprintf (file, "\tsub %s,%s,%s\n",
  1048.            reg_names[R_MSP], reg_names[R_MSP], reg_names[R_TAV]);
  1049.     }
  1050.   else if (size)
  1051.     {
  1052.       if (TARGET_STACK_CHECK)
  1053.     fprintf (file, "\tcall %s,__msp_check\n", reg_names[R_TPC]);
  1054.       fprintf (file, "\tsub %s,%s,%d\n",
  1055.            reg_names[R_MSP], reg_names[R_MSP], size);
  1056.     }
  1057.  
  1058.   /* If this routine will make calls, set lr1.  If we see an insn that
  1059.      can use a delay slot before a call or jump, save this insn for that
  1060.      slot (this condition is equivalent to seeing if we have an insn that
  1061.      needs delay slots before an insn that has a filled delay slot).  */
  1062.   a29k_last_prologue_insn = 0;
  1063.   if (makes_calls)
  1064.     {
  1065.       i = (a29k_regstack_size + arg_count) * 4;
  1066.       if (i >= 256)
  1067.     fprintf (file, "\tconst %s,%d\n\tsub lr1,gr1,%s\n",
  1068.          reg_names[R_TAV], i, reg_names[R_TAV]);
  1069.       else
  1070.     {
  1071.       if (optimize && flag_delayed_branch)
  1072.         for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
  1073.           {
  1074.         if (GET_CODE (insn) == CODE_LABEL
  1075.             || (GET_CODE (insn) == INSN
  1076.             && GET_CODE (PATTERN (insn)) == SEQUENCE))
  1077.           break;
  1078.  
  1079.         if (GET_CODE (insn) == NOTE
  1080.             || (GET_CODE (insn) == INSN
  1081.             && (GET_CODE (PATTERN (insn)) == USE
  1082.                 || GET_CODE (PATTERN (insn)) == CLOBBER)))
  1083.           continue;
  1084.  
  1085.         if (num_delay_slots (insn) > 0)
  1086.           {
  1087.             a29k_last_prologue_insn = (char *) oballoc (100);
  1088.             sprintf (a29k_last_prologue_insn, "add lr1,gr1,%d", i);
  1089.             break;
  1090.           }
  1091.           }
  1092.  
  1093.       if (a29k_last_prologue_insn == 0)
  1094.         fprintf (file, "\tadd lr1,gr1,%d\n", i);
  1095.     }
  1096.     }
  1097.  
  1098.   /* Compute the first insn of the epilogue.  */
  1099.   a29k_first_epilogue_insn_used = 0;
  1100.  
  1101.   if (size == 0 && a29k_regstack_size == 0 && ! frame_pointer_needed)
  1102.     a29k_first_epilogue_insn = 0;
  1103.   else
  1104.     a29k_first_epilogue_insn = (char *) oballoc (100);
  1105.  
  1106.   if (frame_pointer_needed)
  1107.     sprintf (a29k_first_epilogue_insn, "sll %s,%s,0",
  1108.          reg_names[R_MSP], reg_names[FRAME_POINTER_REGNUM]);
  1109.   else if (a29k_regstack_size)
  1110.     {
  1111.       if (a29k_regstack_size >= 256 / 4)
  1112.     sprintf (a29k_first_epilogue_insn, "const %s,%d",
  1113.          reg_names[R_TAV], a29k_regstack_size * 4);
  1114.       else
  1115.     sprintf (a29k_first_epilogue_insn, "add gr1,gr1,%d",
  1116.          a29k_regstack_size * 4);
  1117.     }
  1118.   else if (size)
  1119.     {
  1120.       if (size >= 256)
  1121.     sprintf (a29k_first_epilogue_insn, "const %s,%d",
  1122.          reg_names[R_TAV], size);
  1123.       else
  1124.     sprintf (a29k_first_epilogue_insn, "add %s,%s",
  1125.          reg_names[R_MSP], reg_names[R_MSP], size);
  1126.     }
  1127. }
  1128.  
  1129. /* Call this after writing what might be the first instruction of the
  1130.    epilogue.  If that first insn was used in a delay slot, an intermediate
  1131.    label is written.  */
  1132.  
  1133. static void
  1134. check_epilogue_internal_label (file)
  1135.      FILE *file;
  1136. {
  1137.   rtx insn;
  1138.  
  1139.   if (! a29k_first_epilogue_insn_used)
  1140.     return;
  1141.  
  1142.   for (insn = get_last_insn ();
  1143.        GET_CODE (insn) != CODE_LABEL;
  1144.        insn = PREV_INSN (insn))
  1145.     ;
  1146.  
  1147.   ASM_OUTPUT_INTERNAL_LABEL (file, "LX", CODE_LABEL_NUMBER (insn));
  1148.   a29k_first_epilogue_insn_used = 0;
  1149. }
  1150.  
  1151. /* Output the epilog of the last procedure to file FILE.  SIZE is the memory
  1152.    stack size.  The register stack size is in the variable
  1153.    A29K_REGSTACK_SIZE.  */
  1154.  
  1155. void
  1156. output_epilog (file, size)
  1157.      FILE *file;
  1158.      int size;
  1159. {
  1160.   rtx insn;
  1161.   int locals_unavailable = 0;    /* True until after first insn
  1162.                    after gr1 update. */
  1163.  
  1164.   /* If we hit a BARRIER before a real insn or CODE_LABEL, we don't
  1165.      need to do anything because we are never jumped to.  */
  1166.   insn = get_last_insn ();
  1167.   if (GET_CODE (insn) == NOTE)
  1168.     insn = prev_nonnote_insn (insn);
  1169.  
  1170.   if (insn && GET_CODE (insn) == BARRIER)
  1171.     return;
  1172.  
  1173.   /* If a frame pointer was needed we must restore the memory stack pointer
  1174.      before adjusting the register stack.  */
  1175.   if (frame_pointer_needed)
  1176.     {
  1177.       fprintf (file, "\tsll %s,%s,0\n",
  1178.            reg_names[R_MSP], reg_names[FRAME_POINTER_REGNUM]);
  1179.       check_epilogue_internal_label (file);
  1180.     }
  1181.  
  1182.   /* Restore the register stack.  There are two ways to do this.  */
  1183.   if (a29k_regstack_size)
  1184.     {
  1185.       if (a29k_regstack_size >= 256/4)
  1186.     {
  1187.       fprintf (file, "\tconst %s,%d\n",
  1188.            reg_names[R_TAV], a29k_regstack_size * 4);
  1189.       check_epilogue_internal_label (file);
  1190.       fprintf (file, "\tadd gr1,gr1,%s\n", reg_names[R_TAV]);
  1191.     }
  1192.       else
  1193.     {
  1194.       fprintf (file, "\tadd gr1,gr1,%d\n", a29k_regstack_size * 4);
  1195.       check_epilogue_internal_label (file);
  1196.     }
  1197.       locals_unavailable = 1;
  1198.     }
  1199.  
  1200.   /* Restore the memory stack pointer if there is no frame pointer.
  1201.      Adjust the size to include any pretend arguments and pushed
  1202.      arguments and round to doubleword boundary.  */
  1203.   size += (current_function_pretend_args_size
  1204.        + current_function_outgoing_args_size);
  1205.   size = (size + 7) & ~7;
  1206.  
  1207.   if (size && ! frame_pointer_needed)
  1208.     {
  1209.       if (size >= 256)
  1210.     {
  1211.       fprintf (file, "\tconst %s,%d\n", reg_names[R_TAV], size);
  1212.       check_epilogue_internal_label (file);
  1213.       locals_unavailable = 0;
  1214.       if (size >= 65536)
  1215.         fprintf (file, "\tconsth %s,%d\n", reg_names[R_TAV], size);
  1216.       fprintf (file, "\tadd %s,%s,%s\n",
  1217.            reg_names[R_MSP], reg_names[R_MSP], reg_names[R_TAV]);
  1218.     }
  1219.       else
  1220.     {
  1221.       fprintf (file, "\tadd %s,%s,%d\n",
  1222.            reg_names[R_MSP], reg_names[R_MSP], size);
  1223.       check_epilogue_internal_label (file);
  1224.       locals_unavailable = 0;
  1225.     }
  1226.     }
  1227.  
  1228.   if (locals_unavailable)
  1229.     {
  1230.       /* If we have an insn for this delay slot, write it.  */
  1231.       if (current_function_epilogue_delay_list)
  1232.     final_scan_insn (XEXP (current_function_epilogue_delay_list, 0),
  1233.              file, write_symbols, 1, -2, 1);
  1234.       else
  1235.     fprintf (file, "\tnop\n");
  1236.     }
  1237.  
  1238.   fprintf (file, "\tjmpi lr0\n");
  1239.   if (a29k_regstack_size)
  1240.     fprintf (file, "\tasleu V_%sFILL,lr1,%s\n",
  1241.          TARGET_KERNEL_REGISTERS ? "K" : "", reg_names[R_RFB]);
  1242.   else if (current_function_epilogue_delay_list)
  1243.     final_scan_insn (XEXP (current_function_epilogue_delay_list, 0),
  1244.              file, write_symbols, 1, -2, 1);
  1245.   else
  1246.     fprintf (file, "\tnop\n");
  1247. }
  1248.