home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / optabs.c < prev    next >
C/C++ Source or Header  |  1992-04-29  |  100KB  |  3,394 lines
  1. /* Expand the basic unary and binary arithmetic operations, for GNU compiler.
  2.    Copyright (C) 1987-1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. #include "config.h"
  22. #include "rtl.h"
  23. #include "tree.h"
  24. #include "flags.h"
  25. #include "insn-flags.h"
  26. #include "insn-codes.h"
  27. #include "expr.h"
  28. #include "insn-config.h"
  29. #include "recog.h"
  30.  
  31. /* Each optab contains info on how this target machine
  32.    can perform a particular operation
  33.    for all sizes and kinds of operands.
  34.  
  35.    The operation to be performed is often specified
  36.    by passing one of these optabs as an argument.
  37.  
  38.    See expr.h for documentation of these optabs.  */
  39.  
  40. optab add_optab;
  41. optab sub_optab;
  42. optab smul_optab;
  43. optab smul_widen_optab;
  44. optab umul_widen_optab;
  45. optab sdiv_optab;
  46. optab sdivmod_optab;
  47. optab udiv_optab;
  48. optab udivmod_optab;
  49. optab smod_optab;
  50. optab umod_optab;
  51. optab flodiv_optab;
  52. optab ftrunc_optab;
  53. optab and_optab;
  54. optab ior_optab;
  55. optab xor_optab;
  56. optab ashl_optab;
  57. optab lshr_optab;
  58. optab lshl_optab;
  59. optab ashr_optab;
  60. optab rotl_optab;
  61. optab rotr_optab;
  62.  
  63. optab mov_optab;
  64. optab movstrict_optab;
  65.  
  66. optab neg_optab;
  67. optab abs_optab;
  68. optab one_cmpl_optab;
  69. optab ffs_optab;
  70.  
  71. optab cmp_optab;
  72. optab ucmp_optab;  /* Used only for libcalls for unsigned comparisons.  */
  73. optab tst_optab;
  74.  
  75. /* SYMBOL_REF rtx's for the library functions that are called
  76.    implicitly and not via optabs.  */
  77.  
  78. rtx extendsfdf2_libfunc;
  79. rtx truncdfsf2_libfunc;
  80. rtx memcpy_libfunc;
  81. rtx bcopy_libfunc;
  82. rtx memcmp_libfunc;
  83. rtx bcmp_libfunc;
  84. rtx memset_libfunc;
  85. rtx bzero_libfunc;
  86. rtx eqsf2_libfunc;
  87. rtx nesf2_libfunc;
  88. rtx gtsf2_libfunc;
  89. rtx gesf2_libfunc;
  90. rtx ltsf2_libfunc;
  91. rtx lesf2_libfunc;
  92. rtx eqdf2_libfunc;
  93. rtx nedf2_libfunc;
  94. rtx gtdf2_libfunc;
  95. rtx gedf2_libfunc;
  96. rtx ltdf2_libfunc;
  97. rtx ledf2_libfunc;
  98.  
  99. /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
  100.    gives the gen_function to make a branch to test that condition.  */
  101.  
  102. rtxfun bcc_gen_fctn[NUM_RTX_CODE];
  103.  
  104. /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
  105.    gives the insn code to make a store-condition insn
  106.    to test that condition.  */
  107.  
  108. enum insn_code setcc_gen_code[NUM_RTX_CODE];
  109.  
  110. static void emit_float_lib_cmp ();
  111.  
  112. #ifdef NeXT
  113. /* Add a REG_EQUAL note to the last insn in SEQ.  TARGET is being set to
  114.    the result of operation CODE applied to OP0 (and OP1 if it is a binary
  115.    operation).
  116.  
  117.    If the last insn does not set TARGET, don't do anything, but return 1.
  118.  
  119.    If a previous insn sets TARGET and TARGET is one of OP0 or OP1,
  120.    don't add the REG_EQUAL note but return 0.  Our caller can then try
  121.    again, ensuring that TARGET is not one of the operands.  */
  122.  
  123. static int
  124. add_equal_note (seq, target, code, op0, op1)
  125.      rtx seq;
  126.      rtx target;
  127.      enum rtx_code code;
  128.      rtx op0, op1;
  129. {
  130.   rtx set;
  131.   int i;
  132.   rtx note;
  133.  
  134.   if ((GET_RTX_CLASS (code) != '1' && GET_RTX_CLASS (code) != '2'
  135.        && GET_RTX_CLASS (code) != 'c' && GET_RTX_CLASS (code) != '<')
  136.       || GET_CODE (seq) != SEQUENCE
  137.       || (set = single_set (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1))) == 0
  138.       || GET_CODE (target) == ZERO_EXTRACT
  139.       || (! rtx_equal_p (SET_DEST (set), target)
  140.       /* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside the
  141.          SUBREG.  */
  142.       && (GET_CODE (SET_DEST (set)) != STRICT_LOW_PART
  143.           || ! rtx_equal_p (SUBREG_REG (XEXP (SET_DEST (set), 0)),
  144.                 target))))
  145.     return 1;
  146.  
  147.   /* If TARGET is in OP0 or OP1, check if anything in SEQ sets TARGET
  148.      besides the last insn.  */
  149.   if (reg_overlap_mentioned_p (target, op0)
  150.       || (op1 && reg_overlap_mentioned_p (target, op1)))
  151.     for (i = XVECLEN (seq, 0) - 2; i >= 0; i--)
  152.       if (reg_set_p (target, XVECEXP (seq, 0, i)))
  153.     return 0;
  154.  
  155.   if (GET_RTX_CLASS (code) == '1')
  156.     note = gen_rtx (code, GET_MODE (target), op0);
  157.   else
  158.     note = gen_rtx (code, GET_MODE (target), op0, op1);
  159.  
  160.   REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1))
  161.     = gen_rtx (EXPR_LIST, REG_EQUAL, note,
  162.            REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)));
  163.  
  164.   return 1;
  165. }
  166. #endif /* NeXT */
  167.  
  168. /* Generate code to perform an operation specified by BINOPTAB
  169.    on operands OP0 and OP1, with result having machine-mode MODE.
  170.  
  171.    UNSIGNEDP is for the case where we have to widen the operands
  172.    to perform the operation.  It says to use zero-extension.
  173.  
  174.    If TARGET is nonzero, the value
  175.    is generated there, if it is convenient to do so.
  176.    In all cases an rtx is returned for the locus of the value;
  177.    this may or may not be TARGET.  */
  178.  
  179. rtx
  180. expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
  181.      enum machine_mode mode;
  182.      optab binoptab;
  183.      rtx op0, op1;
  184.      rtx target;
  185.      int unsignedp;
  186.      enum optab_methods methods;
  187. {
  188.   enum mode_class class;
  189.   enum machine_mode wider_mode;
  190.   enum machine_mode submode = mode_for_size (BITS_PER_WORD, MODE_INT, 0);
  191.   register rtx temp;
  192.   int commutative_op = 0;
  193.   rtx last;
  194.  
  195.   class = GET_MODE_CLASS (mode);
  196.  
  197.   op0 = protect_from_queue (op0, 0);
  198.   op1 = protect_from_queue (op1, 0);
  199.   if (target)
  200.     target = protect_from_queue (target, 1);
  201.  
  202. #if 0
  203.   /* We may get better code by generating the result in a register
  204.      when the target is not one of the operands.  */
  205.   if (target && ! rtx_equal_p (target, op1) && ! rtx_equal_p (target, op0))
  206.     target_is_not_an_operand = 1;
  207. #endif
  208.  
  209.   if (flag_force_mem)
  210.     {
  211.       op0 = force_not_mem (op0);
  212.       op1 = force_not_mem (op1);
  213.     }
  214.  
  215.   /* If we are inside an appropriately-short loop and one operand is an
  216.      expensive constant, force it into a register.  */
  217.   if (CONSTANT_P (op0) && preserve_subexpressions_p () && rtx_cost (op0) > 2)
  218.     op0 = force_reg (mode, op0);
  219.  
  220.   if (CONSTANT_P (op1) && preserve_subexpressions_p () && rtx_cost (op1) > 2)
  221.     op1 = force_reg (mode, op1);
  222.  
  223. #if 0  /* Turned off because it seems to be a kludgy method.  */
  224.   /* If subtracting integer from pointer, and the pointer has a special mode,
  225.      then change it to an add.  We use the add insn of Pmode for combining
  226.      integers with pointers, and the sub insn to subtract two pointers.  */
  227.  
  228.   if (binoptab == sub_optab
  229.       && GET_MODE (op0) == Pmode && GET_MODE (op1) != Pmode)
  230.     {
  231.       op1 = negate_rtx (GET_MODE(op1), op1);
  232.       binoptab = add_optab;
  233.     }
  234. #endif /* 0 */
  235.  
  236.   /* Record where to delete back to if we backtrack.  */
  237.   last = get_last_insn ();
  238.  
  239.   /* If operation is commutative,
  240.      try to make the first operand a register.
  241.      Even better, try to make it the same as the target.
  242.      Also try to make the last operand a constant.  */
  243.   if (binoptab == add_optab
  244.       || binoptab == and_optab
  245.       || binoptab == ior_optab
  246.       || binoptab == xor_optab
  247.       || binoptab == smul_optab
  248.       || binoptab == smul_widen_optab
  249.       || binoptab == umul_widen_optab)
  250.     {
  251.       commutative_op = 1;
  252.  
  253.       if (((target == 0 || GET_CODE (target) == REG)
  254.        ? ((GET_CODE (op1) == REG
  255.            && GET_CODE (op0) != REG)
  256.           || target == op1)
  257.        : rtx_equal_p (op1, target))
  258.       ||
  259.       GET_CODE (op0) == CONST_INT)
  260.     {
  261.       temp = op1;
  262.       op1 = op0;
  263.       op0 = temp;
  264.     }
  265.     }
  266.  
  267.   /* If we can do it with a three-operand insn, do so.  */
  268.  
  269.   if (methods != OPTAB_MUST_WIDEN
  270.       && binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  271.     {
  272.       int icode = (int) binoptab->handlers[(int) mode].insn_code;
  273.       enum machine_mode mode0 = insn_operand_mode[icode][1];
  274.       enum machine_mode mode1 = insn_operand_mode[icode][2];
  275.       rtx pat;
  276.       rtx xop0 = op0, xop1 = op1;
  277.  
  278.       if (target)
  279.     temp = target;
  280.       else
  281.     temp = gen_reg_rtx (mode);
  282.  
  283.       /* If it is a commutative operator and the modes would match
  284.      if we would swap the operands, we can save the conversions. */
  285.       if (commutative_op)
  286.     {
  287.       if (GET_MODE (op0) != mode0 && GET_MODE (op1) != mode1
  288.           && GET_MODE (op0) == mode1 && GET_MODE (op1) == mode0)
  289.         {
  290.           register rtx tmp;
  291.  
  292.           tmp = op0; op0 = op1; op1 = tmp;
  293.           tmp = xop0; xop0 = xop1; xop1 = tmp;
  294.         }
  295.     }
  296.  
  297.       /* In case the insn wants input operands in modes different from
  298.      the result, convert the operands.  */
  299.  
  300.       if (GET_MODE (op0) != VOIDmode
  301.       && GET_MODE (op0) != mode0)
  302.     xop0 = convert_to_mode (mode0, xop0, unsignedp);
  303.  
  304.       if (GET_MODE (xop1) != VOIDmode
  305.       && GET_MODE (xop1) != mode1)
  306.     xop1 = convert_to_mode (mode1, xop1, unsignedp);
  307.  
  308.       /* Now, if insn's predicates don't allow our operands, put them into
  309.      pseudo regs.  */
  310.  
  311.       if (! (*insn_operand_predicate[icode][1]) (xop0, mode0))
  312.     xop0 = copy_to_mode_reg (mode0, xop0);
  313.  
  314.       if (! (*insn_operand_predicate[icode][2]) (xop1, mode1))
  315.     xop1 = copy_to_mode_reg (mode1, xop1);
  316.  
  317.       if (! (*insn_operand_predicate[icode][0]) (temp, mode))
  318.     temp = gen_reg_rtx (mode);
  319.  
  320.       pat = GEN_FCN (icode) (temp, xop0, xop1);
  321.       if (pat)
  322.     {
  323.       rtx insn;
  324.       rtx prev_insn = get_last_insn ();
  325.  
  326.       insn = emit_insn (pat);
  327.       /* If we just made a multi-insn sequence,
  328.          record in the last insn an equivalent expression for its value
  329.          and a pointer to the first insn.  This makes cse possible.  */
  330.       if (binoptab->code != UNKNOWN && PREV_INSN (insn) != prev_insn)
  331.         REG_NOTES (insn)
  332.           = gen_rtx (EXPR_LIST, REG_EQUAL,
  333.              gen_rtx (binoptab->code, GET_MODE (temp), op0, op1),
  334.              REG_NOTES (insn));
  335.   
  336.       return temp;
  337.     }
  338.       else
  339.     delete_insns_since (last);
  340.     }
  341.  
  342.   /* These can be done a word at a time.  */
  343.   if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
  344.       && class == MODE_INT
  345.       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
  346.       && binoptab->handlers[(int) submode].insn_code != CODE_FOR_nothing)
  347.     {
  348.       int i;
  349.       rtx seq;
  350.       rtx equiv_value;
  351.  
  352.       if (target == 0)
  353.     target = gen_reg_rtx (mode);
  354.  
  355.       start_sequence ();
  356.  
  357.       /* Do the actual arithmetic.  */
  358.       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
  359.     {
  360.       rtx target_piece = operand_subword (target, i, 1, mode);
  361.       rtx x = expand_binop (submode, binoptab,
  362.                 operand_subword_force (op0, i, mode),
  363.                 operand_subword_force (op1, i, mode),
  364.                 target_piece, unsignedp, methods);
  365.       if (target_piece != x)
  366.         emit_move_insn (target_piece, x);
  367.     }
  368.  
  369.       seq = gen_sequence ();
  370.       end_sequence ();
  371.  
  372.       if (binoptab->code != UNKNOWN)
  373.     equiv_value = gen_rtx (binoptab->code, mode, op0, op1);
  374.       else
  375.     equiv_value = 0;
  376.  
  377.       emit_no_conflict_block (seq, target, op0, op1, equiv_value);
  378.       return target;
  379.     }
  380.  
  381.   /* These can be done a word at a time by propagating carries.  */
  382.   if ((binoptab == add_optab || binoptab == sub_optab)
  383.       && class == MODE_INT
  384.       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
  385.       && binoptab->handlers[(int) submode].insn_code != CODE_FOR_nothing)
  386.     {
  387.       int i;
  388.       rtx carry_tmp = gen_reg_rtx (submode);
  389.       optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
  390.       int nwords = GET_MODE_BITSIZE (mode) / BITS_PER_WORD;
  391.       rtx carry_in, carry_out;
  392.  
  393.       /* We can handle either a 1 or -1 value for the carry.  If STORE_FLAG
  394.      value is one of those, use it.  Otherwise, use 1 since it is the
  395.      one easiest to get.  */
  396. #if STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1
  397.       int normalizep = STORE_FLAG_VALUE;
  398. #else
  399.       int normalizep = 1;
  400. #endif
  401.  
  402.       /* Prepare the operands.  */
  403.       op0 = force_reg (mode, op0);
  404.       op1 = force_reg (mode, op1);
  405.  
  406.       if (target == 0 || GET_CODE (target) != REG
  407.       || target == op0 || target == op1)
  408.     target = gen_reg_rtx (mode);
  409.  
  410.       /* Do the actual arithmetic.  */
  411.       for (i = 0; i < nwords; i++)
  412.     {
  413.       int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
  414.       rtx target_piece = operand_subword (target, index, 1, mode);
  415.       rtx op0_piece = operand_subword_force (op0, index, mode);
  416.       rtx op1_piece = operand_subword_force (op1, index, mode);
  417.       rtx x;
  418.  
  419.       /* Main add/subtract of the input operands.  */
  420.       x = expand_binop (submode, binoptab,
  421.                 op0_piece, op1_piece,
  422.                 target_piece, unsignedp, methods);
  423.       if (x == 0)
  424.         break;
  425.  
  426.       if (i + 1 < nwords)
  427.         {
  428.           /* Store carry from main add/subtract.  */
  429.           carry_out = gen_reg_rtx (submode);
  430.           carry_out = emit_store_flag (carry_out,
  431.                        binoptab == add_optab ? LTU : GTU,
  432.                        x, op0_piece,
  433.                        submode, 1, normalizep);
  434.           if (!carry_out)
  435.         break;
  436.         }
  437.  
  438.       if (i > 0)
  439.         {
  440.           /* Add/subtract previous carry to main result.  */
  441.           x = expand_binop (submode,
  442.                 normalizep == 1 ? binoptab : otheroptab,
  443.                 x, carry_in,
  444.                 target_piece, 1, methods);
  445.           if (target_piece != x)
  446.         emit_move_insn (target_piece, x);
  447.  
  448.           if (i + 1 < nwords)
  449.         {
  450.           /* THIS CODE HAS NOT BEEN TESTED.  */
  451.           /* Get out carry from adding/subtracting carry in.  */
  452.           carry_tmp = emit_store_flag (carry_tmp,
  453.                            binoptab == add_optab
  454.                              ? LTU : GTU,
  455.                            x, carry_in,
  456.                            submode, 1, normalizep);
  457.           /* Logical-ior the two poss. carry together.  */
  458.           carry_out = expand_binop (submode, ior_optab,
  459.                         carry_out, carry_tmp,
  460.                         carry_out, 0, methods);
  461.           if (!carry_out)
  462.             break;
  463.         }
  464.         }
  465.  
  466.       carry_in = carry_out;
  467.     }    
  468.  
  469.       if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
  470.     {
  471.       rtx temp;
  472.       
  473.       temp = emit_move_insn (target, target);
  474.       REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
  475.                       gen_rtx (binoptab->code, mode, op0, op1),
  476.                       REG_NOTES (temp));
  477.       return target;
  478.     }
  479.       else
  480.     delete_insns_since (last);
  481.     }
  482.  
  483.   /* If we want to multiply two two-word values and have normal and widening
  484.      multiplies of single-word values, we can do this with three smaller
  485.      multiplications.  Note that we do not make a REG_NO_CONFLICT block here
  486.      because we are not operating on one word at a time. 
  487.  
  488.      The multiplication proceeds as follows:
  489.                  _______________________
  490.                 [__op0_high_|__op0_low__]
  491.                  _______________________
  492.     *                [__op1_high_|__op1_low__]
  493.     _______________________________________________
  494.                  _______________________
  495. (1)                [__op0_low__*__op1_low__]
  496.          _______________________
  497. (2a)        [__op0_low__*__op1_high_]
  498.          _______________________
  499. (2b)        [__op0_high_*__op1_low__]
  500.      _______________________
  501. (3) [__op0_high_*__op1_high_]
  502.  
  503.  
  504.     This gives a 4-word result.  Since we are only interested in the
  505.     lower 2 words, partial result (3) and the upper words of (2a) and
  506.     (2b) don't need to be calculated.  Hence (2a) and (2b) can be
  507.     calculated using non-widening multiplication.
  508.  
  509.     (1), however, needs to be calculated with an unsigned widening
  510.     multiplication.  If this operation is not directly supported we
  511.     try using a signed widening multiplication and adjust the result.
  512.     This adjustment works as follows:
  513.  
  514.       If both operands are positive then no adjustment is needed.
  515.  
  516.       If the operands have different signs, for example op0_low < 0 and
  517.       op1_low >= 0, the instruction treats the most significant bit of
  518.       op0_low as a sign bit instead of a bit with significance
  519.       2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
  520.       with 2**BITS_PER_WORD - op0_low, and two's complements the
  521.       result.  Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
  522.       the result.
  523.  
  524.       Similarly, if both operands are negative, we need to add
  525.       (op0_low + op1_low) * 2**BITS_PER_WORD.
  526.  
  527.       We use a trick to adjust quickly.  We logically shift op0_low right
  528.       (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
  529.       op0_high (op1_high) before it is used to calculate 2b (2a).  If no
  530.       logical shift exists, we do an arithmetic right shift and subtract
  531.       the 0 or -1.  */
  532.  
  533.   if (binoptab == smul_optab
  534.       && class == MODE_INT
  535.       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
  536.       && smul_optab->handlers[(int) submode].insn_code != CODE_FOR_nothing
  537.       && add_optab->handlers[(int) submode].insn_code != CODE_FOR_nothing
  538.       && ((umul_widen_optab->handlers[(int) mode].insn_code
  539.        != CODE_FOR_nothing)
  540.       || (smul_widen_optab->handlers[(int) mode].insn_code
  541.           != CODE_FOR_nothing)))
  542.     {
  543.       int low = (WORDS_BIG_ENDIAN ? 1 : 0);
  544.       int high = (WORDS_BIG_ENDIAN ? 0 : 1);
  545.       rtx op0_high = operand_subword_force (op0, high, mode);
  546.       rtx op0_low = operand_subword_force (op0, low, mode);
  547.       rtx op1_high = operand_subword_force (op1, high, mode);
  548.       rtx op1_low = operand_subword_force (op1, low, mode);
  549.       rtx product = 0;
  550.       rtx op0_xhigh;
  551.       rtx op1_xhigh;
  552.  
  553.       /* If the target is the same as one of the inputs, don't use it.  This
  554.      prevents problems with the REG_EQUAL note.  */
  555.       if (target == op0 || target == op1)
  556.     target = 0;
  557.  
  558.       /* Multiply the two lower words to get a double-word product.
  559.      If unsigned widening multiplication is available, use that;
  560.      otherwise use the signed form and compensate.  */
  561.  
  562.       if (umul_widen_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  563.     {
  564.       product = expand_binop (mode, umul_widen_optab, op0_low, op1_low,
  565.                   target, 1, OPTAB_DIRECT);
  566.  
  567.       /* If we didn't succeed, delete everything we did so far.  */
  568.       if (product == 0)
  569.         delete_insns_since (last);
  570.       else
  571.         op0_xhigh = op0_high, op1_xhigh = op1_high;
  572.     }
  573.  
  574.       if (product == 0
  575.       && smul_widen_optab->handlers[(int) mode].insn_code
  576.            != CODE_FOR_nothing)
  577.     {
  578.       rtx wordm1 = gen_rtx (CONST_INT, VOIDmode, BITS_PER_WORD - 1);
  579.       product = expand_binop (mode, smul_widen_optab, op0_low, op1_low,
  580.                   target, 1, OPTAB_DIRECT);
  581.       op0_xhigh = expand_binop (submode, lshr_optab, op0_low, wordm1,
  582.                     0, 1, OPTAB_DIRECT);
  583.       if (op0_xhigh)
  584.         op0_xhigh = expand_binop (submode, add_optab, op0_high, op0_xhigh,
  585.                       op0_xhigh, 0, OPTAB_DIRECT);
  586.       else
  587.         {
  588.           op0_xhigh = expand_binop (submode, ashr_optab, op0_low, wordm1,
  589.                     0, 0, OPTAB_DIRECT);
  590.           if (op0_xhigh)
  591.         op0_xhigh = expand_binop (submode, sub_optab, op0_high,
  592.                       op0_xhigh, op0_xhigh, 0,
  593.                       OPTAB_DIRECT);
  594.         }
  595.  
  596.       op1_xhigh = expand_binop (submode, lshr_optab, op1_low, wordm1,
  597.                     0, 1, OPTAB_DIRECT);
  598.       if (op1_xhigh)
  599.         op1_xhigh = expand_binop (SImode, add_optab, op1_high, op1_xhigh,
  600.                       op1_xhigh, 0, OPTAB_DIRECT);
  601.       else
  602.         {
  603.           op1_xhigh = expand_binop (submode, ashr_optab, op1_low, wordm1,
  604.                     0, 0, OPTAB_DIRECT);
  605.           if (op1_xhigh)
  606.         op1_xhigh = expand_binop (SImode, sub_optab, op1_high,
  607.                       op1_xhigh, op1_xhigh, 0,
  608.                       OPTAB_DIRECT);
  609.         }
  610.     }
  611.  
  612.       /* If we have been able to directly compute the product of the
  613.      low-order words of the operands and perform any required adjustments
  614.      of the operands, we proceed by trying two more multiplications
  615.      and then computing the appropriate sum.
  616.  
  617.      We have checked above that the required addition is provided.
  618.      Full-word addition will normally always succeed, especially if
  619.      it is provided at all, so we don't worry about its failure.  The
  620.      multiplication may well fail, however, so we do handle that.  */
  621.  
  622.       if (product && op0_xhigh && op1_xhigh)
  623.     {
  624.       rtx product_piece;
  625.       rtx product_high = operand_subword (product, high, 1, mode);
  626.       rtx temp = expand_binop (submode, binoptab, op0_low, op1_xhigh, 0,
  627.                    0, OPTAB_DIRECT);
  628.  
  629.       if (temp)
  630.         {
  631.           product_piece = expand_binop (submode, add_optab, temp,
  632.                         product_high, product_high,
  633.                         0, OPTAB_LIB_WIDEN);
  634.           if (product_piece != product_high)
  635.         emit_move_insn (product_high, product_piece);
  636.  
  637.           temp = expand_binop (submode, binoptab, op1_low, op0_xhigh, 0,
  638.                    0, OPTAB_DIRECT);
  639.  
  640.           product_piece = expand_binop (submode, add_optab, temp,
  641.                         product_high, product_high,
  642.                         0, OPTAB_LIB_WIDEN);
  643.           if (product_piece != product_high)
  644.         emit_move_insn (product_high, product_piece);
  645.  
  646.           temp = emit_move_insn (product, product);
  647.           REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
  648.                       gen_rtx (MULT, mode, op0, op1),
  649.                       REG_NOTES (temp));
  650.  
  651.           return product;
  652.         }
  653.     }
  654.  
  655.       /* If we get here, we couldn't do it for some reason even though we
  656.      originally thought we could.  Delete anything we've emitted in
  657.      trying to do it.  */
  658.  
  659.       delete_insns_since (last);
  660.     }
  661.  
  662.   /* It can't be open-coded in this mode.
  663.      Use a library call if one is available and caller says that's ok.  */
  664.  
  665.   if (binoptab->handlers[(int) mode].libfunc
  666.       && (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
  667.     {
  668.       rtx insn_before, insn_first, insn_last;
  669.       rtx funexp = binoptab->handlers[(int) mode].libfunc;
  670.  
  671.       /* Pass the address through a pseudoreg, if desired,
  672.      before the "beginning" of the library call.
  673.      So this insn isn't "part of" the library call, in case that
  674.      is deleted, or cse'd.  */
  675. #ifndef NO_FUNCTION_CSE
  676.       if (! flag_no_function_cse)
  677.     funexp = copy_to_mode_reg (Pmode, funexp);
  678. #endif
  679.  
  680.       /* Get the means to find, after we emit our insns,
  681.      the first one of them.  */
  682.       insn_before = get_last_insn ();
  683.  
  684.       /* Cannot pass FUNEXP since emit_library_call insists
  685.      on getting a SYMBOL_REF.  But cse will make this SYMBOL_REF
  686.      be replaced with the copy we made just above.  */
  687.       /* Pass 1 for NO_QUEUE so we don't lose any increments
  688.      if the libcall is cse'd or moved.  */
  689.       emit_library_call (binoptab->handlers[(int) mode].libfunc,
  690.              1, mode, 2, op0, mode, op1, mode);
  691.       target = hard_libcall_value (mode);
  692.       temp = copy_to_reg (target);
  693.  
  694.       if (insn_before)
  695.         insn_first = NEXT_INSN (insn_before);
  696.       else
  697.     insn_first = get_insns ();
  698.       insn_last = get_last_insn ();
  699.  
  700.       REG_NOTES (insn_last)
  701.     = gen_rtx (EXPR_LIST, REG_EQUAL,
  702.            gen_rtx (binoptab->code, mode, op0, op1),
  703.            gen_rtx (INSN_LIST, REG_RETVAL, insn_first,
  704.                 REG_NOTES (insn_last)));
  705.       REG_NOTES (insn_first)
  706.     = gen_rtx (INSN_LIST, REG_LIBCALL, insn_last,
  707.            REG_NOTES (insn_first));
  708.       return temp;
  709.     }
  710.  
  711.   delete_insns_since (last);
  712.  
  713.   /* It can't be done in this mode.  Can we do it in a wider mode?  */
  714.  
  715.   if (! (methods == OPTAB_WIDEN || methods == OPTAB_LIB_WIDEN
  716.      || methods == OPTAB_MUST_WIDEN))
  717.     return 0;            /* Caller says, don't even try.  */
  718.  
  719.   /* Compute the value of METHODS to pass to recursive calls.
  720.      Don't allow widening to be tried recursively.  */
  721.  
  722.   methods = (methods == OPTAB_LIB_WIDEN ? OPTAB_LIB : OPTAB_DIRECT);
  723.  
  724.   /* Widening is now independent of specific machine modes.
  725.      It is assumed that widening may be performed to any
  726.      higher numbered mode in the same mode class.  */
  727.  
  728.   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
  729.     {
  730.       for (wider_mode = GET_MODE_WIDER_MODE (mode);
  731.        ((int) wider_mode < (int) MAX_MACHINE_MODE
  732.         && GET_MODE_CLASS (wider_mode) == class);
  733.        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
  734.     {
  735.       if ((binoptab->handlers[(int) wider_mode].insn_code
  736.            != CODE_FOR_nothing)
  737.           || (methods == OPTAB_LIB
  738.           && binoptab->handlers[(int) wider_mode].libfunc))
  739.         {
  740.           rtx xop0 = op0, xop1 = op1;
  741.           int no_extend = 0;
  742.  
  743.           /* For certain operations, we need not actually extend
  744.          the narrow operands, as long as we will truncate
  745.          the results to the same narrowness.  */
  746.  
  747.           if (binoptab == ior_optab || binoptab == and_optab
  748.           || binoptab == xor_optab
  749.           || binoptab == add_optab || binoptab == sub_optab
  750.           || binoptab == smul_optab
  751.           || binoptab == ashl_optab || binoptab == lshl_optab)
  752.         no_extend = 1;
  753.  
  754.           if (GET_MODE (xop0) != VOIDmode
  755.           && GET_MODE_BITSIZE (wider_mode) <= HOST_BITS_PER_INT)
  756.         {
  757.           if (no_extend)
  758.             {
  759.               temp = force_reg (GET_MODE (xop0), xop0);
  760.               xop0 = gen_rtx (SUBREG, wider_mode, temp, 0);
  761.             }
  762.           else
  763.             {
  764.               temp = gen_reg_rtx (wider_mode);
  765.               convert_move (temp, xop0, unsignedp);
  766.               xop0 = temp;
  767.             }
  768.         }
  769.           if (GET_MODE (xop1) != VOIDmode
  770.           && GET_MODE_BITSIZE (wider_mode) <= HOST_BITS_PER_INT)
  771.         {
  772.           if (no_extend)
  773.             {
  774.               temp = force_reg (GET_MODE (xop1), xop1);
  775.               xop1 = gen_rtx (SUBREG, wider_mode, temp, 0);
  776.             }
  777.           else
  778.             {
  779.               temp = gen_reg_rtx (wider_mode);
  780.               convert_move (temp, xop1, unsignedp);
  781.               xop1 = temp;
  782.             }
  783.         }
  784.  
  785.           temp = expand_binop (wider_mode, binoptab, xop0, xop1, 0,
  786.                    unsignedp, methods);
  787.           if (temp)
  788.         {
  789.           if (class == MODE_FLOAT)
  790.             {
  791.               if (target == 0)
  792.             target = gen_reg_rtx (mode);
  793.               convert_move (target, temp, 0);
  794.               return target;
  795.             }
  796.           else
  797.             return gen_lowpart (mode, temp);
  798.         }
  799.           else
  800.         delete_insns_since (last);
  801.         }
  802.     }
  803.     }
  804.  
  805.   return 0;
  806. }
  807.  
  808. /* Expand a binary operator which has both signed and unsigned forms.
  809.    UOPTAB is the optab for unsigned operations, and SOPTAB is for
  810.    signed operations.
  811.  
  812.    If we widen unsigned operands, we may use a signed wider operation instead
  813.    of an unsigned wider operation, since the result would be the same.  */
  814.  
  815. rtx
  816. sign_expand_binop (mode, uoptab, soptab, op0, op1, target, unsignedp, methods)
  817.     enum machine_mode mode;
  818.     optab uoptab, soptab;
  819.     rtx op0, op1, target;
  820.     int unsignedp;
  821.     enum optab_methods methods;
  822. {
  823.   register rtx temp;
  824.   optab direct_optab = unsignedp ? uoptab : soptab;
  825.   struct optab wide_soptab;
  826.  
  827.   /* Do it without widening, if possible.  */
  828.   temp = expand_binop (mode, direct_optab, op0, op1, target,
  829.                unsignedp, OPTAB_DIRECT);
  830.   if (temp || methods == OPTAB_DIRECT)
  831.     return temp;
  832.  
  833.   /* Try widening to a signed int.  Make a fake signed optab that
  834.      hides any signed insn for direct use.  */
  835.   wide_soptab = *soptab;
  836.   wide_soptab.handlers[(int) mode].insn_code = CODE_FOR_nothing;
  837.   wide_soptab.handlers[(int) mode].libfunc = 0;
  838.  
  839.   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
  840.                unsignedp, OPTAB_WIDEN);
  841.  
  842.   /* For unsigned operands, try widening to an unsigned int.  */
  843.   if (temp == 0 && unsignedp)
  844.     temp = expand_binop (mode, uoptab, op0, op1, target,
  845.              unsignedp, OPTAB_WIDEN);
  846.   if (temp || methods == OPTAB_WIDEN)
  847.     return temp;
  848.  
  849.   /* Use the right width lib call if that exists.  */
  850.   temp = expand_binop (mode, direct_optab, op0, op1, target, unsignedp, OPTAB_LIB);
  851.   if (temp || methods == OPTAB_LIB)
  852.     return temp;
  853.  
  854.   /* Must widen and use a lib call, use either signed or unsigned.  */
  855.   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
  856.                unsignedp, methods);
  857.   if (temp != 0)
  858.     return temp;
  859.   if (unsignedp)
  860.     return expand_binop (mode, uoptab, op0, op1, target,
  861.              unsignedp, methods);
  862.   return 0;
  863. }
  864.  
  865. /* Generate code to perform an operation specified by BINOPTAB
  866.    on operands OP0 and OP1, with two results to TARG1 and TARG2.
  867.    We assume that the order of the operands for the instruction
  868.    is TARG0, OP0, OP1, TARG1, which would fit a pattern like
  869.    [(set TARG0 (operate OP0 OP1)) (set TARG1 (operate ...))].
  870.  
  871.    Either TARG0 or TARG1 may be zero, but what that means is that
  872.    that result is not actually wanted.  We will generate it into
  873.    a dummy pseudo-reg and discard it.  They may not both be zero.
  874.  
  875.    Returns 1 if this operation can be performed; 0 if not.  */
  876.  
  877. int
  878. expand_twoval_binop (binoptab, op0, op1, targ0, targ1, unsignedp)
  879.      optab binoptab;
  880.      rtx op0, op1;
  881.      rtx targ0, targ1;
  882.      int unsignedp;
  883. {
  884.   enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
  885.   enum mode_class class;
  886.   enum machine_mode wider_mode;
  887.   rtx last;
  888.  
  889.   class = GET_MODE_CLASS (mode);
  890.  
  891.   op0 = protect_from_queue (op0, 0);
  892.   op1 = protect_from_queue (op1, 0);
  893.  
  894.   if (flag_force_mem)
  895.     {
  896.       op0 = force_not_mem (op0);
  897.       op1 = force_not_mem (op1);
  898.     }
  899.  
  900.   /* If we are inside an appropriately-short loop and one operand is an
  901.      expensive constant, force it into a register.  */
  902.   if (CONSTANT_P (op0) && preserve_subexpressions_p () && rtx_cost (op0) > 2)
  903.     op0 = force_reg (mode, op0);
  904.  
  905.   if (CONSTANT_P (op1) && preserve_subexpressions_p () && rtx_cost (op1) > 2)
  906.     op1 = force_reg (mode, op1);
  907.  
  908.   if (targ0)
  909.     targ0 = protect_from_queue (targ0, 1);
  910.   else
  911.     targ0 = gen_reg_rtx (mode);
  912.   if (targ1)
  913.     targ1 = protect_from_queue (targ1, 1);
  914.   else
  915.     targ1 = gen_reg_rtx (mode);
  916.  
  917.   /* Record where to go back to if we fail.  */
  918.   last = get_last_insn ();
  919.  
  920.   if (binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  921.     {
  922.       int icode = (int) binoptab->handlers[(int) mode].insn_code;
  923.       enum machine_mode mode0 = insn_operand_mode[icode][1];
  924.       enum machine_mode mode1 = insn_operand_mode[icode][2];
  925.       rtx pat;
  926.       rtx xop0 = op0, xop1 = op1;
  927.  
  928.       /* In case this insn wants input operands in modes different from the
  929.      result, convert the operands.  */
  930.       if (GET_MODE (op0) != VOIDmode && GET_MODE (op0) != mode0)
  931.     xop0 = convert_to_mode (mode0, xop0, unsignedp);
  932.  
  933.       if (GET_MODE (op1) != VOIDmode && GET_MODE (op1) != mode1)
  934.     xop1 = convert_to_mode (mode1, xop1, unsignedp);
  935.  
  936.       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
  937.       if (! (*insn_operand_predicate[icode][1]) (xop0, mode0))
  938.     xop0 = copy_to_mode_reg (mode0, xop0);
  939.  
  940.       if (! (*insn_operand_predicate[icode][2]) (xop1, mode1))
  941.     xop1 = copy_to_mode_reg (mode1, xop1);
  942.  
  943.       /* We could handle this, but we should always be called with a pseudo
  944.      for our targets and all insns should take them as outputs.  */
  945.       if (! (*insn_operand_predicate[icode][0]) (targ0, mode)
  946.       || ! (*insn_operand_predicate[icode][3]) (targ1, mode))
  947.     abort ();
  948.     
  949.       pat = GEN_FCN (icode) (targ0, xop0, xop1, targ1);
  950.       if (pat)
  951.     {
  952.       emit_insn (pat);
  953.       return 1;
  954.     }
  955.       else
  956.     delete_insns_since (last);
  957.     }
  958.  
  959.   /* It can't be done in this mode.  Can we do it in a wider mode?  */
  960.  
  961.   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
  962.     {
  963.       for (wider_mode = GET_MODE_WIDER_MODE (mode);
  964.        GET_MODE_CLASS (wider_mode) == class;
  965.        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
  966.     {
  967.       if (binoptab->handlers[(int) wider_mode].insn_code
  968.           != CODE_FOR_nothing)
  969.         {
  970.           register rtx t0 = gen_reg_rtx (wider_mode);
  971.           register rtx t1 = gen_reg_rtx (wider_mode);
  972.  
  973.           if (expand_twoval_binop (binoptab,
  974.                        convert_to_mode (wider_mode, op0,
  975.                             unsignedp),
  976.                        convert_to_mode (wider_mode, op1,
  977.                             unsignedp),
  978.                        t0, t1, unsignedp))
  979.         {
  980.           convert_move (targ0, t0, unsignedp);
  981.           convert_move (targ1, t1, unsignedp);
  982.           return 1;
  983.         }
  984.           else
  985.         delete_insns_since (last);
  986.         }
  987.     }
  988.     }
  989.  
  990.   return 0;
  991. }
  992.  
  993. /* Generate code to perform an operation specified by UNOPTAB
  994.    on operand OP0, with result having machine-mode MODE.
  995.  
  996.    UNSIGNEDP is for the case where we have to widen the operands
  997.    to perform the operation.  It says to use zero-extension.
  998.  
  999.    If TARGET is nonzero, the value
  1000.    is generated there, if it is convenient to do so.
  1001.    In all cases an rtx is returned for the locus of the value;
  1002.    this may or may not be TARGET.  */
  1003.  
  1004. rtx
  1005. expand_unop (mode, unoptab, op0, target, unsignedp)
  1006.      enum machine_mode mode;
  1007.      optab unoptab;
  1008.      rtx op0;
  1009.      rtx target;
  1010.      int unsignedp;
  1011. {
  1012.   enum mode_class class;
  1013.   enum machine_mode wider_mode;
  1014.   enum machine_mode submode = mode_for_size (BITS_PER_WORD, MODE_INT, 0);
  1015.   register rtx temp;
  1016.  
  1017.   class = GET_MODE_CLASS (mode);
  1018.  
  1019.   op0 = protect_from_queue (op0, 0);
  1020.  
  1021.   if (flag_force_mem)
  1022.     {
  1023.       op0 = force_not_mem (op0);
  1024.     }
  1025.  
  1026.   if (target)
  1027.     target = protect_from_queue (target, 1);
  1028.  
  1029.   if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  1030.     {
  1031.       int icode = (int) unoptab->handlers[(int) mode].insn_code;
  1032.       enum machine_mode mode0 = insn_operand_mode[icode][1];
  1033.       rtx prev_insn;
  1034.       rtx insn;
  1035.  
  1036.       if (target)
  1037.     temp = target;
  1038.       else
  1039.     temp = gen_reg_rtx (mode);
  1040.  
  1041.       if (GET_MODE (op0) != VOIDmode
  1042.       && GET_MODE (op0) != mode0)
  1043.     op0 = convert_to_mode (mode0, op0, unsignedp);
  1044.  
  1045.       /* Now, if insn doesn't accept our operand, put it into a pseudo.  */
  1046.  
  1047.       if (! (*insn_operand_predicate[icode][1]) (op0, mode0))
  1048.     op0 = copy_to_mode_reg (mode0, op0);
  1049.  
  1050.       if (! (*insn_operand_predicate[icode][0]) (temp, mode))
  1051.     temp = gen_reg_rtx (mode);
  1052.  
  1053.       prev_insn = get_last_insn ();
  1054.       insn = emit_insn (GEN_FCN (icode) (temp, op0));
  1055.  
  1056.       /* If we just made a multi-insn sequence,
  1057.      record in the last insn an equivalent expression for its value
  1058.      and a pointer to the first insn.  This makes cse possible.  */
  1059.       if (unoptab->code != UNKNOWN && PREV_INSN (insn) != prev_insn)
  1060.     REG_NOTES (insn)
  1061.       = gen_rtx (EXPR_LIST, REG_EQUAL,
  1062.              gen_rtx (unoptab->code, GET_MODE (temp), op0),
  1063.              REG_NOTES (insn));
  1064.   
  1065.       return temp;
  1066.     }
  1067.   /* These can be done a word at a time.  */
  1068.   else if (unoptab == one_cmpl_optab
  1069.        && class == MODE_INT
  1070.        && GET_MODE_SIZE (mode) > UNITS_PER_WORD
  1071.        && unoptab->handlers[(int) submode].insn_code != CODE_FOR_nothing)
  1072.     {
  1073.       int i;
  1074.       rtx seq;
  1075.  
  1076.       if (target == 0)
  1077.     target = gen_reg_rtx (mode);
  1078.  
  1079.       start_sequence ();
  1080.  
  1081.       /* Do the actual arithmetic.  */
  1082.       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
  1083.     {
  1084.       rtx target_piece = operand_subword (target, i, 1, mode);
  1085.       rtx x = expand_unop (submode, unoptab,
  1086.                    operand_subword_force (op0, i, mode),
  1087.                    target_piece, unsignedp);
  1088.       if (target_piece != x)
  1089.         emit_move_insn (target_piece, x);
  1090.     }
  1091.  
  1092.       seq = gen_sequence ();
  1093.       end_sequence ();
  1094.  
  1095.       emit_no_conflict_block (seq, target, op0, 0,
  1096.                   gen_rtx (unoptab->code, mode, op0));
  1097.       return target;
  1098.     }
  1099.   else if (unoptab->handlers[(int) mode].libfunc)
  1100.     {
  1101.       rtx insn_before, insn_last;
  1102.       rtx funexp = unoptab->handlers[(int) mode].libfunc;
  1103.  
  1104.       /* Pass the address through a pseudoreg, if desired,
  1105.      before the "beginning" of the library call (for deletion).  */
  1106. #ifndef NO_FUNCTION_CSE
  1107.       if (! flag_no_function_cse)
  1108.     funexp = copy_to_mode_reg (Pmode, funexp);
  1109. #endif
  1110.  
  1111.       insn_before = get_last_insn ();
  1112.  
  1113.       /* Cannot pass FUNEXP since  emit_library_call insists
  1114.      on getting a SYMBOL_REF.  But cse will make this SYMBOL_REF
  1115.      be replaced with the copy we made just above.  */
  1116.       /* Pass 1 for NO_QUEUE so we don't lose any increments
  1117.      if the libcall is cse'd or moved.  */
  1118.       emit_library_call (unoptab->handlers[(int) mode].libfunc,
  1119.              1, mode, 1, op0, mode);
  1120.       target = hard_libcall_value (mode);
  1121.       temp = copy_to_reg (target);
  1122.       insn_last = get_last_insn ();
  1123.       REG_NOTES (insn_last)
  1124.     = gen_rtx (EXPR_LIST, REG_EQUAL,
  1125.            gen_rtx (unoptab->code, mode, op0),
  1126.            gen_rtx (INSN_LIST, REG_RETVAL,
  1127.                 NEXT_INSN (insn_before),
  1128.                 REG_NOTES (insn_last)));
  1129.       REG_NOTES (NEXT_INSN (insn_before))
  1130.     = gen_rtx (INSN_LIST, REG_LIBCALL, insn_last,
  1131.            REG_NOTES (NEXT_INSN (insn_before)));
  1132.       return temp;
  1133.     }
  1134.  
  1135.   /* It can't be done in this mode.  Can we do it in a wider mode?  */
  1136.  
  1137.   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
  1138.     {
  1139.       for (wider_mode = GET_MODE_WIDER_MODE (mode);
  1140.        GET_MODE_CLASS (wider_mode) == class;
  1141.        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
  1142.     {
  1143.       if ((unoptab->handlers[(int) wider_mode].insn_code
  1144.            != CODE_FOR_nothing)
  1145.           || unoptab->handlers[(int) wider_mode].libfunc)
  1146.         {
  1147.           if (GET_MODE (op0) != VOIDmode
  1148.           && GET_MODE_BITSIZE (wider_mode) <= HOST_BITS_PER_INT)
  1149.         {
  1150.           temp = gen_reg_rtx (wider_mode);
  1151.           convert_move (temp, op0, unsignedp);
  1152.           op0 = temp;
  1153.         }
  1154.           
  1155.           target = expand_unop (wider_mode, unoptab, op0, 0, unsignedp);
  1156.           if (class == MODE_FLOAT)
  1157.         {
  1158.           if (target == 0)
  1159.             target = gen_reg_rtx (mode);
  1160.           convert_move (target, temp, 0);
  1161.           return target;
  1162.         }
  1163.           else
  1164.         return gen_lowpart (mode, target);
  1165.         }
  1166.     }
  1167.     }
  1168.  
  1169.   return 0;
  1170. }
  1171.  
  1172. /* Generate an instruction whose insn-code is INSN_CODE,
  1173.    with two operands: an output TARGET and an input OP0.
  1174.    TARGET *must* be nonzero, and the output is always stored there.
  1175.    CODE is an rtx code such that (CODE OP0) is an rtx that describes
  1176.    the value that is stored into TARGET.  */
  1177.  
  1178. void
  1179. emit_unop_insn (icode, target, op0, code)
  1180.      int icode;
  1181.      rtx target;
  1182.      rtx op0;
  1183.      enum rtx_code code;
  1184. {
  1185.   register rtx temp;
  1186.   enum machine_mode mode0 = insn_operand_mode[icode][1];
  1187. #ifdef NeXT
  1188.   rtx pat;
  1189. #else /* NeXT */
  1190.   rtx insn;
  1191.   rtx prev_insn;
  1192. #endif /* NeXT */
  1193.  
  1194.   temp = target = protect_from_queue (target, 1);
  1195.  
  1196.   op0 = protect_from_queue (op0, 0);
  1197.  
  1198.   if (flag_force_mem)
  1199.     op0 = force_not_mem (op0);
  1200.  
  1201.   /* Now, if insn does not accept our operands, put them into pseudos.  */
  1202.  
  1203.   if (! (*insn_operand_predicate[icode][1]) (op0, mode0))
  1204.     op0 = copy_to_mode_reg (mode0, op0);
  1205.  
  1206.   if (! (*insn_operand_predicate[icode][0]) (temp, GET_MODE (temp))
  1207.       || (flag_force_mem && GET_CODE (temp) == MEM))
  1208.     temp = gen_reg_rtx (GET_MODE (temp));
  1209.  
  1210. #ifdef NeXT
  1211.   pat = GEN_FCN (icode) (temp, op0);
  1212.  
  1213.   if (GET_CODE (pat) == SEQUENCE && code != UNKNOWN)
  1214.     add_equal_note (pat, temp, code, op0, 0);
  1215.   
  1216.   emit_insn (pat);
  1217. #else /* NeXT */
  1218.   prev_insn = get_last_insn ();
  1219.   insn = emit_insn (GEN_FCN (icode) (temp, op0));
  1220.  
  1221.   /* If we just made a multi-insn sequence,
  1222.      record in the last insn an equivalent expression for its value
  1223.      and a pointer to the first insn.  This makes cse possible.  */
  1224.   if (code != UNKNOWN && PREV_INSN (insn) != prev_insn)
  1225.     REG_NOTES (insn)
  1226.       = gen_rtx (EXPR_LIST, REG_EQUAL,
  1227.          gen_rtx (code, GET_MODE (temp), op0),
  1228.          REG_NOTES (insn));
  1229. #endif /* NeXT */
  1230.   
  1231.   if (temp != target)
  1232.     emit_move_insn (target, temp);
  1233. }
  1234.  
  1235. /* Emit code to perform a series of operations on a multi-word quantity, one
  1236.    word at a time.
  1237.  
  1238.    Such a block is preceeded by a CLOBBER of the output, consists of multiple
  1239.    insns, each setting one word of the output, and followed by a SET copying
  1240.    the output to itself.
  1241.  
  1242.    Each of the insns setting words of the output receives a REG_NO_CONFLICT
  1243.    note indicating that it doesn't conflict with the (also multi-word)
  1244.    inputs.  The entire block is surrounded by REG_LIBCALL and REG_RETVAL
  1245.    notes.
  1246.  
  1247.    SEQ is a block of code generated to perform the operation, not including
  1248.    the CLOBBER and final copy.  All insns that compute intermediate values
  1249.    are first emitted, followed by the block as described above.  Only
  1250.    INSNs are allowed in the block; no library calls or jumps may be
  1251.    present.
  1252.  
  1253.    TARGET, OP0, and OP1 are the output and inputs of the operations,
  1254.    respectively.  OP1 may be zero for a unary operation.
  1255.  
  1256.    EQUIV, if non-zero, is an expression to be placed into a REG_EQUAL note
  1257.    on the last insn.
  1258.  
  1259.    If TARGET is not a register, SEQ is simply emitted with no special
  1260.    processing.
  1261.  
  1262.    The final insn emitted is returned.  */
  1263.  
  1264. rtx
  1265. emit_no_conflict_block (seq, target, op0, op1, equiv)
  1266.      rtx seq;
  1267.      rtx target;
  1268.      rtx op0, op1;
  1269.      rtx equiv;
  1270. {
  1271.   int i;
  1272.   rtx prev, first, last, insn;
  1273.  
  1274.   if (GET_CODE (target) != REG || reload_in_progress
  1275.       || GET_CODE (seq) != SEQUENCE || XVEC (seq, 0) == 0)
  1276.     return emit_insn (seq);
  1277.  
  1278.   /* First emit all insns that do not store into words of the output.  */
  1279.   for (i = 0; i < XVECLEN (seq, 0); i++)
  1280.     {
  1281.       rtx body, set;
  1282.       int j;
  1283.  
  1284.       if (GET_CODE (XVECEXP (seq, 0, i)) != INSN)
  1285.     abort ();
  1286.  
  1287.       body = PATTERN (XVECEXP (seq, 0, i));
  1288.       if (GET_CODE (body) == SET)
  1289.     set = body;
  1290.       else if (GET_CODE (body) == PARALLEL)
  1291.     {
  1292.       for (j = 0; j < XVECLEN (body, 0); j++)
  1293.         if (GET_CODE (XVECEXP (body, 0, j)) == SET)
  1294.           {
  1295.         set = XVECEXP (body, 0, j);
  1296.         break;
  1297.           }
  1298.     }
  1299.  
  1300.       if (! reg_overlap_mentioned_p (target, SET_DEST (set)))
  1301.     {
  1302.       emit_insn (body);
  1303.       PUT_CODE (XVECEXP (seq, 0, i), NOTE);
  1304.     }
  1305.     }
  1306.  
  1307.   prev = get_last_insn ();
  1308.  
  1309.   /* Now write the CLOBBER of the output, followed by the setting of each
  1310.      of the words, followed by the final copy.  */
  1311.   if (target != op0 && target != op1)
  1312.     emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
  1313.  
  1314.   for (i = 0; i < XVECLEN (seq, 0); i++)
  1315.     if (GET_CODE (XVECEXP (seq, 0, i)) != NOTE)
  1316.       {
  1317.     insn = emit_insn (PATTERN (XVECEXP (seq, 0, i)));
  1318.     if (op1 && GET_CODE (op1) == REG)
  1319.       REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op1,
  1320.                       REG_NOTES (insn));
  1321.  
  1322.     if (op0 && GET_CODE (op0) == REG)
  1323.       REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op0,
  1324.                       REG_NOTES (insn));
  1325.       }
  1326.  
  1327.   last = emit_move_insn (target, target);
  1328.   if (equiv)
  1329.     REG_NOTES (last) = gen_rtx (EXPR_LIST, REG_EQUAL, equiv, REG_NOTES (last));
  1330.  
  1331.   if (prev == 0)
  1332.     first = get_insns ();
  1333.   else
  1334.     first = NEXT_INSN (prev);
  1335.  
  1336.   /* Encapsulate the block so it gets manipulated as a unit.  */
  1337.   REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
  1338.                    REG_NOTES (first));
  1339.   REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
  1340.  
  1341.   return last;
  1342. }
  1343.  
  1344. /* Generate code to store zero in X.  */
  1345.  
  1346. void
  1347. emit_clr_insn (x)
  1348.      rtx x;
  1349. {
  1350.   emit_move_insn (x, const0_rtx);
  1351. }
  1352.  
  1353. /* Generate code to store 1 in X
  1354.    assuming it contains zero beforehand.  */
  1355.  
  1356. void
  1357. emit_0_to_1_insn (x)
  1358.      rtx x;
  1359. {
  1360.   emit_move_insn (x, const1_rtx);
  1361. }
  1362.  
  1363. /* Generate code to compare X with Y
  1364.    so that the condition codes are set.
  1365.  
  1366.    UNSIGNEDP nonzero says that X and Y are unsigned;
  1367.    this matters if they need to be widened.
  1368.  
  1369.    If they have mode BLKmode, then SIZE specifies the size of both X and Y,
  1370.    and ALIGN specifies the known shared alignment of X and Y.
  1371.  
  1372.    COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).  */
  1373.  
  1374. void
  1375. emit_cmp_insn (x, y, comparison, size, unsignedp, align)
  1376.      rtx x, y;
  1377.      enum rtx_code comparison;
  1378.      rtx size;
  1379.      int unsignedp;
  1380.      int align;
  1381. {
  1382.   enum machine_mode mode = GET_MODE (x);
  1383.   enum mode_class class;
  1384.   enum machine_mode wider_mode;
  1385.  
  1386.   if (mode == VOIDmode) mode = GET_MODE (y);
  1387.   /* They could both be VOIDmode if both args are immediate constants,
  1388.      but we should fold that at an earlier stage.
  1389.      With no special code here, this will call abort,
  1390.      reminding the programmer to implement such folding.  */
  1391.  
  1392.   class = GET_MODE_CLASS (mode);
  1393.  
  1394.   /* They could both be VOIDmode if both args are immediate constants,
  1395.      but we should fold that at an earlier stage.
  1396.      With no special code here, this will call abort,
  1397.      reminding the programmer to implement such folding.  */
  1398.  
  1399.   if (mode != BLKmode && flag_force_mem)
  1400.     {
  1401.       x = force_not_mem (x);
  1402.       y = force_not_mem (y);
  1403.     }
  1404.  
  1405.   /* If we are inside an appropriately-short loop and one operand is an
  1406.      expensive constant, force it into a register.  */
  1407.   if (CONSTANT_P (x) && preserve_subexpressions_p () && rtx_cost (x) > 2)
  1408.     x = force_reg (mode, x);
  1409.  
  1410.   if (CONSTANT_P (y) && preserve_subexpressions_p () && rtx_cost (y) > 2)
  1411.     y = force_reg (mode, y);
  1412.  
  1413.   /* Handle all BLKmode compares.  */
  1414.  
  1415.   if (mode == BLKmode)
  1416.     {
  1417.       emit_queue ();
  1418.       x = protect_from_queue (x, 0);
  1419.       y = protect_from_queue (y, 0);
  1420.  
  1421.       if (size == 0)
  1422.     abort ();
  1423. #ifdef HAVE_cmpstrqi
  1424.       if (HAVE_cmpstrqi
  1425.       && GET_CODE (size) == CONST_INT
  1426.       && INTVAL (size) < (1 << GET_MODE_BITSIZE (QImode)))
  1427.     emit_insn (gen_cmpstrqi (x, y, size,
  1428.                  gen_rtx (CONST_INT, VOIDmode, align)));
  1429.       else
  1430. #endif
  1431. #ifdef HAVE_cmpstrhi
  1432.       if (HAVE_cmpstrhi
  1433.       && GET_CODE (size) == CONST_INT
  1434.       && INTVAL (size) < (1 << GET_MODE_BITSIZE (HImode)))
  1435.     emit_insn (gen_cmpstrhi (x, y, size,
  1436.                  gen_rtx (CONST_INT, VOIDmode, align)));
  1437.       else
  1438. #endif
  1439. #ifdef HAVE_cmpstrsi
  1440.       if (HAVE_cmpstrsi)
  1441.     emit_insn (gen_cmpstrsi (x, y, convert_to_mode (SImode, size, 1),
  1442.                  gen_rtx (CONST_INT, VOIDmode, align)));
  1443.       else
  1444. #endif
  1445.     {
  1446. #ifdef TARGET_MEM_FUNCTIONS
  1447.       emit_library_call (memcmp_libfunc, 0, 
  1448.                  SImode, 3,
  1449.                  XEXP (x, 0), Pmode, XEXP (y, 0), Pmode,
  1450.                  size, Pmode);
  1451. #else
  1452.       emit_library_call (bcmp_libfunc, 0,
  1453.                  SImode, 3,
  1454.                  XEXP (x, 0), Pmode, XEXP (y, 0), Pmode,
  1455.                  size, Pmode);
  1456. #endif
  1457.       emit_cmp_insn (hard_libcall_value (SImode), const0_rtx,
  1458.              comparison, 0, 0, 0);
  1459.     }
  1460.       return;
  1461.     }
  1462.  
  1463.   /* Handle some compares against zero.  */
  1464.  
  1465.   if (y == CONST0_RTX (mode)
  1466.       && tst_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  1467.     {
  1468.       int icode = (int) tst_optab->handlers[(int) mode].insn_code;
  1469.  
  1470.       emit_queue ();
  1471.       x = protect_from_queue (x, 0);
  1472.       y = protect_from_queue (y, 0);
  1473.  
  1474.       /* Now, if insn does accept these operands, put them into pseudos.  */
  1475.       if (! (*insn_operand_predicate[icode][0])
  1476.       (x, insn_operand_mode[icode][0]))
  1477.     x = copy_to_mode_reg (insn_operand_mode[icode][0], x);
  1478.  
  1479.       emit_insn (GEN_FCN (icode) (x));
  1480.       return;
  1481.     }
  1482.  
  1483.   /* Handle compares for which there is a directly suitable insn.  */
  1484.  
  1485.   if (cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
  1486.     {
  1487.       int icode = (int) cmp_optab->handlers[(int) mode].insn_code;
  1488.  
  1489.       emit_queue ();
  1490.       x = protect_from_queue (x, 0);
  1491.       y = protect_from_queue (y, 0);
  1492.  
  1493.       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
  1494.       if (! (*insn_operand_predicate[icode][0])
  1495.       (x, insn_operand_mode[icode][0]))
  1496.     x = copy_to_mode_reg (insn_operand_mode[icode][0], x);
  1497.  
  1498.       if (! (*insn_operand_predicate[icode][1])
  1499.       (y, insn_operand_mode[icode][1]))
  1500.     y = copy_to_mode_reg (insn_operand_mode[icode][1], y);
  1501.  
  1502.       emit_insn (GEN_FCN (icode) (x, y));
  1503.       return;
  1504.     }
  1505.  
  1506.   /* Try widening if we can find a direct insn that way.  */
  1507.  
  1508.   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
  1509.     {
  1510.       for (wider_mode = GET_MODE_WIDER_MODE (mode);
  1511.        GET_MODE_CLASS (wider_mode) == class;
  1512.        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
  1513.     {
  1514.       if (cmp_optab->handlers[(int) wider_mode].insn_code
  1515.           != CODE_FOR_nothing)
  1516.         {
  1517.           x = convert_to_mode (wider_mode, x, unsignedp);
  1518.           y = convert_to_mode (wider_mode, y, unsignedp);
  1519.           emit_cmp_insn (x, y, comparison, 0, unsignedp, align);
  1520.           return;
  1521.         }
  1522.     }
  1523.     }
  1524.  
  1525.   /* Handle a lib call just for the mode we are using.  */
  1526.  
  1527.   if (cmp_optab->handlers[(int) mode].libfunc
  1528.       && class != MODE_FLOAT)
  1529.     {
  1530.       rtx libfunc = cmp_optab->handlers[(int) mode].libfunc;
  1531.       /* If we want unsigned, and this mode has a distinct unsigned
  1532.      comparison routine, use that.  */
  1533.       if (unsignedp && ucmp_optab->handlers[(int) mode].libfunc)
  1534.     libfunc = ucmp_optab->handlers[(int) mode].libfunc;
  1535.  
  1536.       emit_library_call (libfunc, 0,
  1537.              SImode, 2, x, mode, y, mode);
  1538.  
  1539.       /* Integer comparison returns a result that must be compared against 1,
  1540.      so that even if we do an unsigned compare afterward,
  1541.      there is still a value that can represent the result "less than".  */
  1542.       if (GET_MODE_CLASS (mode) != MODE_FLOAT)
  1543.     emit_cmp_insn (hard_libcall_value (SImode), const1_rtx,
  1544.                comparison, 0, unsignedp, 0);
  1545.       else
  1546.     emit_cmp_insn (hard_libcall_value (SImode), const0_rtx,
  1547.                comparison, 0, 0, 0);
  1548.       return;
  1549.     }
  1550.  
  1551.   /* Try widening and then using a libcall.  */
  1552.   if (class == MODE_FLOAT)
  1553.     emit_float_lib_cmp (x, y, comparison);
  1554.   else
  1555.     abort ();
  1556. }
  1557.  
  1558. /* Nonzero if a compare of mode MODE can be done straightforwardly
  1559.    (without splitting it into pieces).  */
  1560.  
  1561. int
  1562. can_compare_p (mode)
  1563.      enum machine_mode mode;
  1564. {
  1565.   do
  1566.     {
  1567.       if (cmp_optab->handlers[(int)mode].insn_code != CODE_FOR_nothing)
  1568.     return 1;
  1569.       mode = GET_MODE_WIDER_MODE (mode);
  1570.     } while (mode != VOIDmode);
  1571.  
  1572.   return 0;
  1573. }
  1574.  
  1575. /* Emit a library call comparison between floating point X and Y.
  1576.    COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).  */
  1577.  
  1578. static void
  1579. emit_float_lib_cmp (x, y, comparison)
  1580.      rtx x, y;
  1581.      enum rtx_code comparison;
  1582. {
  1583.   enum machine_mode mode = GET_MODE (x);
  1584.   rtx libfunc;
  1585.  
  1586.   if (mode == SFmode)
  1587.     switch (comparison)
  1588.       {
  1589.       case EQ:
  1590.     libfunc = eqsf2_libfunc;
  1591.     break;
  1592.  
  1593.       case NE:
  1594.     libfunc = nesf2_libfunc;
  1595.     break;
  1596.  
  1597.       case GT:
  1598.     libfunc = gtsf2_libfunc;
  1599.     break;
  1600.  
  1601.       case GE:
  1602.     libfunc = gesf2_libfunc;
  1603.     break;
  1604.  
  1605.       case LT:
  1606.     libfunc = ltsf2_libfunc;
  1607.     break;
  1608.  
  1609.       case LE:
  1610.     libfunc = lesf2_libfunc;
  1611.     break;
  1612.       }
  1613.   else if (mode == DFmode)
  1614.     switch (comparison)
  1615.       {
  1616.       case EQ:
  1617.     libfunc = eqdf2_libfunc;
  1618.     break;
  1619.  
  1620.       case NE:
  1621.     libfunc = nedf2_libfunc;
  1622.     break;
  1623.  
  1624.       case GT:
  1625.     libfunc = gtdf2_libfunc;
  1626.     break;
  1627.  
  1628.       case GE:
  1629.     libfunc = gedf2_libfunc;
  1630.     break;
  1631.  
  1632.       case LT:
  1633.     libfunc = ltdf2_libfunc;
  1634.     break;
  1635.  
  1636.       case LE:
  1637.     libfunc = ledf2_libfunc;
  1638.     break;
  1639.       }
  1640.   else
  1641.     {
  1642.       enum machine_mode wider_mode;
  1643.  
  1644.       for (wider_mode = GET_MODE_WIDER_MODE (mode);
  1645.        GET_MODE_CLASS (wider_mode) == MODE_FLOAT;
  1646.        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
  1647.     {
  1648.       if ((cmp_optab->handlers[(int) wider_mode].insn_code
  1649.            != CODE_FOR_nothing)
  1650.           || (cmp_optab->handlers[(int) wider_mode].libfunc != 0))
  1651.         {
  1652.           x = convert_to_mode (wider_mode, x, 0);
  1653.           y = convert_to_mode (wider_mode, y, 0);
  1654.           emit_float_lib_cmp (x, y, comparison);
  1655.           return;
  1656.         }
  1657.     }
  1658.       abort ();
  1659.     }
  1660.  
  1661.   emit_library_call (libfunc, 0,
  1662.              SImode, 2, x, mode, y, mode);
  1663.  
  1664.   emit_cmp_insn (hard_libcall_value (SImode), const0_rtx, comparison, 0, 0, 0);
  1665. }
  1666.  
  1667. /* Generate code to indirectly jump to a location given in the rtx LOC.  */
  1668.  
  1669. void
  1670. emit_indirect_jump (loc)
  1671.      rtx loc;
  1672. {
  1673.   if (! ((*insn_operand_predicate[(int)CODE_FOR_indirect_jump][0])
  1674.      (loc, VOIDmode)))
  1675.     loc = copy_to_mode_reg (insn_operand_mode[(int)CODE_FOR_indirect_jump][0],
  1676.                 loc);
  1677.  
  1678.   emit_jump_insn (gen_indirect_jump (loc));
  1679. }
  1680.  
  1681. /* These three functions generate an insn body and return it
  1682.    rather than emitting the insn.
  1683.  
  1684.    They do not protect from queued increments,
  1685.    because they may be used 1) in protect_from_queue itself
  1686.    and 2) in other passes where there is no queue.  */
  1687.  
  1688. /* Generate and return an insn body to add Y to X.  */
  1689.  
  1690. rtx
  1691. gen_add2_insn (x, y)
  1692.      rtx x, y;
  1693. {
  1694.   int icode = (int) add_optab->handlers[(int) GET_MODE (x)].insn_code; 
  1695.  
  1696.   if (! (*insn_operand_predicate[icode][0]) (x, insn_operand_mode[icode][0])
  1697.       || ! (*insn_operand_predicate[icode][1]) (x, insn_operand_mode[icode][1])
  1698.       || ! (*insn_operand_predicate[icode][2]) (y, insn_operand_mode[icode][2]))
  1699.     abort ();
  1700.  
  1701.   return (GEN_FCN (icode) (x, x, y));
  1702. }
  1703.  
  1704. int
  1705. have_add2_insn (mode)
  1706.      enum machine_mode mode;
  1707. {
  1708.   return add_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing;
  1709. }
  1710.  
  1711. /* Generate and return an insn body to subtract Y from X.  */
  1712.  
  1713. rtx
  1714. gen_sub2_insn (x, y)
  1715.      rtx x, y;
  1716. {
  1717.   int icode = (int) sub_optab->handlers[(int) GET_MODE (x)].insn_code; 
  1718.  
  1719.   if (! (*insn_operand_predicate[icode][0]) (x, insn_operand_mode[icode][0])
  1720.       || ! (*insn_operand_predicate[icode][1]) (x, insn_operand_mode[icode][1])
  1721.       || ! (*insn_operand_predicate[icode][2]) (y, insn_operand_mode[icode][2]))
  1722.     abort ();
  1723.  
  1724.   return (GEN_FCN (icode) (x, x, y));
  1725. }
  1726.  
  1727. int
  1728. have_sub2_insn (mode)
  1729.      enum machine_mode mode;
  1730. {
  1731.   return sub_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing;
  1732. }
  1733.  
  1734. /* Generate the body of an instruction to copy Y into X.  */
  1735.  
  1736. rtx
  1737. gen_move_insn (x, y)
  1738.      rtx x, y;
  1739. {
  1740.   register enum machine_mode mode = GET_MODE (x);
  1741.   enum insn_code insn_code;
  1742.  
  1743.   if (mode == VOIDmode)
  1744.     mode = GET_MODE (y); 
  1745.  
  1746.   insn_code = mov_optab->handlers[(int) mode].insn_code;
  1747.  
  1748.   /* Handle MODE_CC modes:  If we don't have a special move insn for this mode,
  1749.      find a mode to do it in.  If we have a movcc, use it.  Otherwise,
  1750.      find the MODE_INT mode of the same width.  */
  1751.  
  1752.   if (insn_code == CODE_FOR_nothing)
  1753.     {
  1754.       enum machine_mode tmode = VOIDmode;
  1755.  
  1756.       if (GET_MODE_CLASS (mode) == MODE_CC && mode != CCmode
  1757.       && mov_optab->handlers[(int) CCmode].insn_code != CODE_FOR_nothing)
  1758.     tmode = CCmode;
  1759.       else if (GET_MODE_CLASS (mode) == MODE_CC)
  1760.     for (tmode = QImode; tmode != VOIDmode;
  1761.          tmode = GET_MODE_WIDER_MODE (tmode))
  1762.       if (GET_MODE_SIZE (tmode) == GET_MODE_SIZE (mode))
  1763.         break;
  1764.  
  1765.       if (tmode == VOIDmode)
  1766.     abort ();
  1767.  
  1768.       x = gen_lowpart (tmode, x);
  1769.       y = gen_lowpart (tmode, y);
  1770.       insn_code = mov_optab->handlers[(int) tmode].insn_code;
  1771.     }
  1772.  
  1773.   return (GEN_FCN (insn_code) (x, y));
  1774. }
  1775.  
  1776. #if 0
  1777. /* Tables of patterns for extending one integer mode to another.  */
  1778. enum insn_code zero_extend_optab[MAX_MACHINE_MODE][MAX_MACHINE_MODE];
  1779. enum insn_code sign_extend_optab[MAX_MACHINE_MODE][MAX_MACHINE_MODE];
  1780.  
  1781. /* Generate the body of an insn to extend Y (with mode MFROM)
  1782.    into X (with mode MTO).  Do zero-extension if UNSIGNEDP is nonzero.  */
  1783.  
  1784. rtx
  1785. gen_extend_insn (x, y, mto, mfrom, unsignedp)
  1786.      rtx x, y;
  1787.      enum machine_mode mto, mfrom;
  1788.      int unsignedp;
  1789. {
  1790.   return (GEN_FCN ((unsignedp ? zero_extend_optab : sign_extend_optab)
  1791.            [(int)mto][(int)mfrom])
  1792.       (x, y));
  1793. }
  1794.  
  1795. static void
  1796. init_extends ()
  1797. {
  1798.   bzero (sign_extend_optab, sizeof sign_extend_optab);
  1799.   bzero (zero_extend_optab, sizeof zero_extend_optab);
  1800.   sign_extend_optab[(int) SImode][(int) HImode] = CODE_FOR_extendhisi2;
  1801.   sign_extend_optab[(int) SImode][(int) QImode] = CODE_FOR_extendqisi2;
  1802.   sign_extend_optab[(int) HImode][(int) QImode] = CODE_FOR_extendqihi2;
  1803.   zero_extend_optab[(int) SImode][(int) HImode] = CODE_FOR_zero_extendhisi2;
  1804.   zero_extend_optab[(int) SImode][(int) QImode] = CODE_FOR_zero_extendqisi2;
  1805.   zero_extend_optab[(int) HImode][(int) QImode] = CODE_FOR_zero_extendqihi2;
  1806. }
  1807. #endif
  1808.  
  1809. /* can_fix_p and can_float_p say whether the target machine
  1810.    can directly convert a given fixed point type to
  1811.    a given floating point type, or vice versa.
  1812.    The returned value is the CODE_FOR_... value to use,
  1813.    or CODE_FOR_nothing if these modes cannot be directly converted.  */
  1814.  
  1815. static enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
  1816. static enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
  1817. static enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
  1818.  
  1819. /* *TRUNCP_PTR is set to 1 if it is necessary to output
  1820.    an explicit FTRUNC insn before the fix insn; otherwise 0.  */
  1821.  
  1822. static enum insn_code
  1823. can_fix_p (fixmode, fltmode, unsignedp, truncp_ptr)
  1824.      enum machine_mode fltmode, fixmode;
  1825.      int unsignedp;
  1826.      int *truncp_ptr;
  1827. {
  1828.   *truncp_ptr = 0;
  1829.   if (fixtrunctab[(int) fltmode][(int) fixmode][unsignedp] != CODE_FOR_nothing)
  1830.     return fixtrunctab[(int) fltmode][(int) fixmode][unsignedp];
  1831.  
  1832.   if (ftrunc_optab->handlers[(int) fltmode].insn_code != CODE_FOR_nothing)
  1833.     {
  1834.       *truncp_ptr = 1;
  1835.       return fixtab[(int) fltmode][(int) fixmode][unsignedp];
  1836.     }
  1837.   return CODE_FOR_nothing;
  1838. }
  1839.  
  1840. static enum insn_code
  1841. can_float_p (fltmode, fixmode, unsignedp)
  1842.      enum machine_mode fixmode, fltmode;
  1843.      int unsignedp;
  1844. {
  1845.   return floattab[(int) fltmode][(int) fixmode][unsignedp];
  1846. }
  1847.  
  1848. void
  1849. init_fixtab ()
  1850. {
  1851.   enum insn_code *p;
  1852.   for (p = fixtab[0][0];
  1853.        p < fixtab[0][0] + sizeof fixtab / sizeof (fixtab[0][0][0]); 
  1854.        p++)
  1855.     *p = CODE_FOR_nothing;
  1856.   for (p = fixtrunctab[0][0];
  1857.        p < fixtrunctab[0][0] + sizeof fixtrunctab / sizeof (fixtrunctab[0][0][0]); 
  1858.        p++)
  1859.     *p = CODE_FOR_nothing;
  1860.  
  1861. #ifdef HAVE_fixsfqi2
  1862.   if (HAVE_fixsfqi2)
  1863.     fixtab[(int) SFmode][(int) QImode][0] = CODE_FOR_fixsfqi2;
  1864. #endif
  1865. #ifdef HAVE_fixsfhi2
  1866.   if (HAVE_fixsfhi2)
  1867.     fixtab[(int) SFmode][(int) HImode][0] = CODE_FOR_fixsfhi2;
  1868. #endif
  1869. #ifdef HAVE_fixsfsi2
  1870.   if (HAVE_fixsfsi2)
  1871.     fixtab[(int) SFmode][(int) SImode][0] = CODE_FOR_fixsfsi2;
  1872. #endif
  1873. #ifdef HAVE_fixsfdi2
  1874.   if (HAVE_fixsfdi2)
  1875.     fixtab[(int) SFmode][(int) DImode][0] = CODE_FOR_fixsfdi2;
  1876. #endif
  1877.  
  1878. #ifdef HAVE_fixdfqi2
  1879.   if (HAVE_fixdfqi2)
  1880.     fixtab[(int) DFmode][(int) QImode][0] = CODE_FOR_fixdfqi2;
  1881. #endif
  1882. #ifdef HAVE_fixdfhi2
  1883.   if (HAVE_fixdfhi2)
  1884.     fixtab[(int) DFmode][(int) HImode][0] = CODE_FOR_fixdfhi2;
  1885. #endif
  1886. #ifdef HAVE_fixdfsi2
  1887.   if (HAVE_fixdfsi2)
  1888.     fixtab[(int) DFmode][(int) SImode][0] = CODE_FOR_fixdfsi2;
  1889. #endif
  1890. #ifdef HAVE_fixdfdi2
  1891.   if (HAVE_fixdfdi2)
  1892.     fixtab[(int) DFmode][(int) DImode][0] = CODE_FOR_fixdfdi2;
  1893. #endif
  1894.  
  1895. #ifdef HAVE_fixunssfqi2
  1896.   if (HAVE_fixunssfqi2)
  1897.     fixtab[(int) SFmode][(int) QImode][1] = CODE_FOR_fixunssfqi2;
  1898. #endif
  1899. #ifdef HAVE_fixunssfhi2
  1900.   if (HAVE_fixunssfhi2)
  1901.     fixtab[(int) SFmode][(int) HImode][1] = CODE_FOR_fixunssfhi2;
  1902. #endif
  1903. #ifdef HAVE_fixunssfsi2
  1904.   if (HAVE_fixunssfsi2)
  1905.     fixtab[(int) SFmode][(int) SImode][1] = CODE_FOR_fixunssfsi2;
  1906. #endif
  1907. #ifdef HAVE_fixunssfdi2
  1908.   if (HAVE_fixunssfdi2)
  1909.     fixtab[(int) SFmode][(int) DImode][1] = CODE_FOR_fixunssfdi2;
  1910. #endif
  1911.  
  1912. #ifdef HAVE_fixunsdfqi2
  1913.   if (HAVE_fixunsdfqi2)
  1914.     fixtab[(int) DFmode][(int) QImode][1] = CODE_FOR_fixunsdfqi2;
  1915. #endif
  1916. #ifdef HAVE_fixunsdfhi2
  1917.   if (HAVE_fixunsdfhi2)
  1918.     fixtab[(int) DFmode][(int) HImode][1] = CODE_FOR_fixunsdfhi2;
  1919. #endif
  1920. #ifdef HAVE_fixunsdfsi2
  1921.   if (HAVE_fixunsdfsi2)
  1922.     fixtab[(int) DFmode][(int) SImode][1] = CODE_FOR_fixunsdfsi2;
  1923. #endif
  1924. #ifdef HAVE_fixunsdfdi2
  1925.   if (HAVE_fixunsdfdi2)
  1926.     fixtab[(int) DFmode][(int) DImode][1] = CODE_FOR_fixunsdfdi2;
  1927. #endif
  1928.  
  1929. #ifdef HAVE_fix_truncsfqi2
  1930.   if (HAVE_fix_truncsfqi2)
  1931.     fixtrunctab[(int) SFmode][(int) QImode][0] = CODE_FOR_fix_truncsfqi2;
  1932. #endif
  1933. #ifdef HAVE_fix_truncsfhi2
  1934.   if (HAVE_fix_truncsfhi2)
  1935.     fixtrunctab[(int) SFmode][(int) HImode][0] = CODE_FOR_fix_truncsfhi2;
  1936. #endif
  1937. #ifdef HAVE_fix_truncsfsi2
  1938.   if (HAVE_fix_truncsfsi2)
  1939.     fixtrunctab[(int) SFmode][(int) SImode][0] = CODE_FOR_fix_truncsfsi2;
  1940. #endif
  1941. #ifdef HAVE_fix_truncsfdi2
  1942.   if (HAVE_fix_truncsfdi2)
  1943.     fixtrunctab[(int) SFmode][(int) DImode][0] = CODE_FOR_fix_truncsfdi2;
  1944. #endif
  1945.  
  1946. #ifdef HAVE_fix_truncdfqi2
  1947.   if (HAVE_fix_truncdfsi2)
  1948.     fixtrunctab[(int) DFmode][(int) QImode][0] = CODE_FOR_fix_truncdfqi2;
  1949. #endif
  1950. #ifdef HAVE_fix_truncdfhi2
  1951.   if (HAVE_fix_truncdfhi2)
  1952.     fixtrunctab[(int) DFmode][(int) HImode][0] = CODE_FOR_fix_truncdfhi2;
  1953. #endif
  1954. #ifdef HAVE_fix_truncdfsi2
  1955.   if (HAVE_fix_truncdfsi2)
  1956.     fixtrunctab[(int) DFmode][(int) SImode][0] = CODE_FOR_fix_truncdfsi2;
  1957. #endif
  1958. #ifdef HAVE_fix_truncdfdi2
  1959.   if (HAVE_fix_truncdfdi2)
  1960.     fixtrunctab[(int) DFmode][(int) DImode][0] = CODE_FOR_fix_truncdfdi2;
  1961. #endif
  1962.  
  1963. #ifdef HAVE_fixuns_truncsfqi2
  1964.   if (HAVE_fixuns_truncsfqi2)
  1965.     fixtrunctab[(int) SFmode][(int) QImode][1] = CODE_FOR_fixuns_truncsfqi2;
  1966. #endif
  1967. #ifdef HAVE_fixuns_truncsfhi2
  1968.   if (HAVE_fixuns_truncsfhi2)
  1969.     fixtrunctab[(int) SFmode][(int) HImode][1] = CODE_FOR_fixuns_truncsfhi2;
  1970. #endif
  1971. #ifdef HAVE_fixuns_truncsfsi2
  1972.   if (HAVE_fixuns_truncsfsi2)
  1973.     fixtrunctab[(int) SFmode][(int) SImode][1] = CODE_FOR_fixuns_truncsfsi2;
  1974. #endif
  1975. #ifdef HAVE_fixuns_truncsfdi2
  1976.   if (HAVE_fixuns_truncsfdi2)
  1977.     fixtrunctab[(int) SFmode][(int) DImode][1] = CODE_FOR_fixuns_truncsfdi2;
  1978. #endif
  1979.  
  1980. #ifdef HAVE_fixuns_truncdfqi2
  1981.   if (HAVE_fixuns_truncdfqi2)
  1982.     fixtrunctab[(int) DFmode][(int) QImode][1] = CODE_FOR_fixuns_truncdfqi2;
  1983. #endif
  1984. #ifdef HAVE_fixuns_truncdfhi2
  1985.   if (HAVE_fixuns_truncdfhi2)
  1986.     fixtrunctab[(int) DFmode][(int) HImode][1] = CODE_FOR_fixuns_truncdfhi2;
  1987. #endif
  1988. #ifdef HAVE_fixuns_truncdfsi2
  1989.   if (HAVE_fixuns_truncdfsi2)
  1990.     fixtrunctab[(int) DFmode][(int) SImode][1] = CODE_FOR_fixuns_truncdfsi2;
  1991. #endif
  1992. #ifdef HAVE_fixuns_truncdfdi2
  1993.   if (HAVE_fixuns_truncdfdi2)
  1994.     fixtrunctab[(int) DFmode][(int) DImode][1] = CODE_FOR_fixuns_truncdfdi2;
  1995. #endif
  1996.  
  1997. #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC
  1998.   /* This flag says the same insns that convert to a signed fixnum
  1999.      also convert validly to an unsigned one.  */
  2000.   {
  2001.     int i;
  2002.     int j;
  2003.     for (i = 0; i < NUM_MACHINE_MODES; i++)
  2004.       for (j = 0; j < NUM_MACHINE_MODES; j++)
  2005.     fixtrunctab[i][j][1] = fixtrunctab[i][j][0];
  2006.   }
  2007. #endif
  2008. }
  2009.  
  2010. void
  2011. init_floattab ()
  2012. {
  2013.   enum insn_code *p;
  2014.   for (p = floattab[0][0];
  2015.        p < floattab[0][0] + sizeof floattab / sizeof (floattab[0][0][0]); 
  2016.        p++)
  2017.     *p = CODE_FOR_nothing;
  2018.  
  2019. #ifdef HAVE_floatqisf2
  2020.   if (HAVE_floatqisf2)
  2021.     floattab[(int) SFmode][(int) QImode][0] = CODE_FOR_floatqisf2;
  2022. #endif
  2023. #ifdef HAVE_floathisf2
  2024.   if (HAVE_floathisf2)
  2025.     floattab[(int) SFmode][(int) HImode][0] = CODE_FOR_floathisf2;
  2026. #endif
  2027. #ifdef HAVE_floatsisf2
  2028.   if (HAVE_floatsisf2)
  2029.     floattab[(int) SFmode][(int) SImode][0] = CODE_FOR_floatsisf2;
  2030. #endif
  2031. #ifdef HAVE_floatdisf2
  2032.   if (HAVE_floatdisf2)
  2033.     floattab[(int) SFmode][(int) DImode][0] = CODE_FOR_floatdisf2;
  2034. #endif
  2035.  
  2036. #ifdef HAVE_floatqidf2
  2037.   if (HAVE_floatqidf2)
  2038.     floattab[(int) DFmode][(int) QImode][0] = CODE_FOR_floatqidf2;
  2039. #endif
  2040. #ifdef HAVE_floathidf2
  2041.   if (HAVE_floathidf2)
  2042.     floattab[(int) DFmode][(int) HImode][0] = CODE_FOR_floathidf2;
  2043. #endif
  2044. #ifdef HAVE_floatsidf2
  2045.   if (HAVE_floatsidf2)
  2046.     floattab[(int) DFmode][(int) SImode][0] = CODE_FOR_floatsidf2;
  2047. #endif
  2048. #ifdef HAVE_floatdidf2
  2049.   if (HAVE_floatdidf2)
  2050.     floattab[(int) DFmode][(int) DImode][0] = CODE_FOR_floatdidf2;
  2051. #endif
  2052.  
  2053. #ifdef HAVE_floatunsqisf2
  2054.   if (HAVE_floatunsqisf2)
  2055.     floattab[(int) SFmode][(int) QImode][1] = CODE_FOR_floatunsqisf2;
  2056. #endif
  2057. #ifdef HAVE_floatunshisf2
  2058.   if (HAVE_floatunshisf2)
  2059.     floattab[(int) SFmode][(int) HImode][1] = CODE_FOR_floatunshisf2;
  2060. #endif
  2061. #ifdef HAVE_floatunssisf2
  2062.   if (HAVE_floatunssisf2)
  2063.     floattab[(int) SFmode][(int) SImode][1] = CODE_FOR_floatunssisf2;
  2064. #endif
  2065. #ifdef HAVE_floatunsdisf2
  2066.   if (HAVE_floatunsdisf2)
  2067.     floattab[(int) SFmode][(int) DImode][1] = CODE_FOR_floatunsdisf2;
  2068. #endif
  2069.  
  2070. #ifdef HAVE_floatunsqidf2
  2071.   if (HAVE_floatunsqidf2)
  2072.     floattab[(int) DFmode][(int) QImode][1] = CODE_FOR_floatunsqidf2;
  2073. #endif
  2074. #ifdef HAVE_floatunshidf2
  2075.   if (HAVE_floatunshidf2)
  2076.     floattab[(int) DFmode][(int) HImode][1] = CODE_FOR_floatunshidf2;
  2077. #endif
  2078. #ifdef HAVE_floatunssidf2
  2079.   if (HAVE_floatunssidf2)
  2080.     floattab[(int) DFmode][(int) SImode][1] = CODE_FOR_floatunssidf2;
  2081. #endif
  2082. #ifdef HAVE_floatunsdidf2
  2083.   if (HAVE_floatunsdidf2)
  2084.     floattab[(int) DFmode][(int) DImode][1] = CODE_FOR_floatunsdidf2;
  2085. #endif
  2086. }
  2087.  
  2088. /* Generate code to convert FROM to floating point
  2089.    and store in TO.  FROM must be fixed point.
  2090.    UNSIGNEDP nonzero means regard FROM as unsigned.
  2091.    Normally this is done by correcting the final value
  2092.    if it is negative.  */
  2093.  
  2094. void
  2095. expand_float (to, from, unsignedp)
  2096.      rtx to, from;
  2097.      int unsignedp;
  2098. {
  2099.   enum insn_code icode;
  2100.   register rtx target = to;
  2101.   enum machine_mode fmode, imode;
  2102.  
  2103.   to = protect_from_queue (to, 1);
  2104.   from = protect_from_queue (from, 0);
  2105.  
  2106.   if (flag_force_mem)
  2107.     from = force_not_mem (from);
  2108.  
  2109.   /* Look for an insn to do the conversion.  Do it in the specified
  2110.      modes if possible; otherwise convert either input, output or both with
  2111.      wider mode.  If the integer mode is wider than the mode of FROM,
  2112.      we can do the conversion either signed or unsigned. */
  2113.  
  2114.   for (imode = GET_MODE (from); imode != VOIDmode;
  2115.        imode = GET_MODE_WIDER_MODE (imode))
  2116.     for (fmode = GET_MODE (to); fmode != VOIDmode;
  2117.      fmode = GET_MODE_WIDER_MODE (fmode))
  2118.       {
  2119.     int doing_unsigned = unsignedp;
  2120.  
  2121.     icode = can_float_p (fmode, imode, unsignedp);
  2122.     if (icode == CODE_FOR_nothing && imode != GET_MODE (from) && unsignedp)
  2123.       icode = can_float_p (fmode, imode, 0), doing_unsigned = 0;
  2124.  
  2125.     if (icode != CODE_FOR_nothing)
  2126.       {
  2127.         if (imode != GET_MODE (from))
  2128.           from = convert_to_mode (imode, from, unsignedp);
  2129.  
  2130.         if (fmode != GET_MODE (to))
  2131.           target = gen_reg_rtx (fmode);
  2132.  
  2133.         emit_unop_insn (icode, target, from,
  2134.                 doing_unsigned ? UNSIGNED_FLOAT : FLOAT);
  2135.  
  2136.         if (target != to)
  2137.           convert_move (to, target, 0);
  2138.         return;
  2139.       }
  2140.     }
  2141.  
  2142. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  2143.  
  2144.   /* Unsigned integer, and no way to convert directly.
  2145.      Convert as signed, then conditionally adjust the result.  */
  2146.   if (unsignedp)
  2147.     {
  2148.       rtx label = gen_label_rtx ();
  2149.       rtx temp;
  2150.       REAL_VALUE_TYPE offset;
  2151.  
  2152.       /* If we are about to do some arithmetic to correct for an
  2153.      unsigned operand, do it in a pseudo-register.  */
  2154.  
  2155.       if (GET_CODE (to) != REG || REGNO (to) <= LAST_VIRTUAL_REGISTER)
  2156.     target = gen_reg_rtx (GET_MODE (to));
  2157.  
  2158.       /* Convert as signed integer to floating.  */
  2159.       expand_float (target, from, 0);
  2160.  
  2161.       /* If FROM is negative (and therefore TO is negative),
  2162.      correct its value by 2**bitwidth.  */
  2163.  
  2164.       do_pending_stack_adjust ();
  2165.       emit_cmp_insn (from, const0_rtx, GE, 0, 0, 0);
  2166.       emit_jump_insn (gen_bge (label));
  2167.       offset = REAL_VALUE_LDEXP (dconst1, GET_MODE_BITSIZE (GET_MODE (from)));
  2168.       temp = expand_binop (GET_MODE (to), add_optab, target,
  2169.                immed_real_const_1 (offset, GET_MODE (to)),
  2170.                target, 0, OPTAB_LIB_WIDEN);
  2171.       if (temp != target)
  2172.     emit_move_insn (target, temp);
  2173.       do_pending_stack_adjust ();
  2174.       emit_label (label);
  2175.     }
  2176.   else
  2177. #endif
  2178.  
  2179.   /* No hardware instruction available; call a library
  2180.      to convert from SImode or DImode into SFmode or DFmode.  */
  2181.     {
  2182.       if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
  2183.     from = convert_to_mode (SImode, from, unsignedp);
  2184.  
  2185.       if (GET_MODE (to) == SFmode)
  2186.     {
  2187.       if (GET_MODE (from) == SImode)
  2188.         emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2189.                     "_floatsisf"),
  2190.                 0, SFmode, 1, from, GET_MODE (from));
  2191.       else if (GET_MODE (from) == DImode)
  2192.         emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2193.                     "_floatdisf"),
  2194.                 0, SFmode, 1, from, GET_MODE (from));
  2195.       else
  2196.         abort ();
  2197.   
  2198.       target = hard_libcall_value (SFmode);
  2199.     }
  2200.       else if (GET_MODE (to) == DFmode)
  2201.     {
  2202.       if (GET_MODE (from) == SImode)
  2203.         emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2204.                     "_floatsidf"),
  2205.                 0, DFmode, 1, from, GET_MODE (from));
  2206.       else if (GET_MODE (from) == DImode)
  2207.         emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2208.                     "_floatdidf"),
  2209.                 0, DFmode, 1, from, GET_MODE (from));
  2210.       else
  2211.         abort ();
  2212.   
  2213.       target = hard_libcall_value (DFmode);
  2214.       }
  2215.       else
  2216.     abort ();
  2217.     }
  2218.  
  2219.   /* Copy result to requested destination
  2220.      if we have been computing in a temp location.  */
  2221.  
  2222.   if (target != to)
  2223.     {
  2224.       if (GET_MODE (target) == GET_MODE (to))
  2225.     emit_move_insn (to, target);
  2226.       else
  2227.     convert_move (to, target, 0);
  2228.     }
  2229. }
  2230.  
  2231. /* expand_fix: generate code to convert FROM to fixed point
  2232.    and store in TO.  FROM must be floating point.  */
  2233.  
  2234. static rtx
  2235. ftruncify (x)
  2236.      rtx x;
  2237. {
  2238.   rtx temp = gen_reg_rtx (GET_MODE (x));
  2239.   return expand_unop (GET_MODE (x), ftrunc_optab, x, temp, 0);
  2240. }
  2241.  
  2242. void
  2243. expand_fix (to, from, unsignedp)
  2244.      register rtx to, from;
  2245.      int unsignedp;
  2246. {
  2247.   enum insn_code icode;
  2248.   register rtx target = to;
  2249.   enum machine_mode fmode, imode;
  2250.   int must_trunc = 0;
  2251.  
  2252.   to = protect_from_queue (to, 1);
  2253.   from = protect_from_queue (from, 0);
  2254.  
  2255.   if (flag_force_mem)
  2256.     from = force_not_mem (from);
  2257.  
  2258.   /* We first try to find a pair of modes, one real and one integer, at
  2259.      least as wide as FROM and TO, respectively, in which we can open-code
  2260.      this conversion.  If the integer mode is wider than the mode of TO,
  2261.      we can do the conversion either signed or unsigned.  */
  2262.  
  2263.   for (imode = GET_MODE (to); imode != VOIDmode;
  2264.        imode = GET_MODE_WIDER_MODE (imode))
  2265.     for (fmode = GET_MODE (from); fmode != VOIDmode;
  2266.      fmode = GET_MODE_WIDER_MODE (fmode))
  2267.       {
  2268.     int doing_unsigned = unsignedp;
  2269.  
  2270.     icode = can_fix_p (imode, fmode, unsignedp, &must_trunc);
  2271.     if (icode == CODE_FOR_nothing && imode != GET_MODE (to) && unsignedp)
  2272.       icode = can_fix_p (imode, fmode, 0, &must_trunc), doing_unsigned = 0;
  2273.  
  2274.     if (icode != CODE_FOR_nothing)
  2275.       {
  2276.         if (fmode != GET_MODE (from))
  2277.           from = convert_to_mode (fmode, from, 0);
  2278.  
  2279.         if (must_trunc)
  2280.           from = ftruncify (from);
  2281.  
  2282.         if (imode != GET_MODE (to))
  2283.           target = gen_reg_rtx (imode);
  2284.  
  2285.         emit_unop_insn (icode, target, from,
  2286.                 doing_unsigned ? UNSIGNED_FIX : FIX);
  2287.         if (target != to)
  2288.           convert_move (to, target, unsignedp);
  2289.         return;
  2290.       }
  2291.       }
  2292.  
  2293. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  2294.   /* For an unsigned conversion, there is one more way to do it.
  2295.      If we have a signed conversion, we generate code that compares
  2296.      the real value to the largest representable positive number.  If if
  2297.      is smaller, the conversion is done normally.  Otherwise, subtract
  2298.      one plus the highest signed number, convert, and add it back.
  2299.  
  2300.      We only need to check all real modes, since we know we didn't find
  2301.      anything with a wider inetger mode.  */
  2302.  
  2303.   if (unsignedp && GET_MODE_BITSIZE (GET_MODE (to)) <= HOST_BITS_PER_INT)
  2304.     for (fmode = GET_MODE (from); fmode != VOIDmode;
  2305.      fmode = GET_MODE_WIDER_MODE (fmode))
  2306.       /* Make sure we won't lose significant bits doing this.  */
  2307.       if (GET_MODE_BITSIZE (fmode) > GET_MODE_BITSIZE (GET_MODE (to))
  2308.       && CODE_FOR_nothing != can_fix_p (GET_MODE (to), fmode,
  2309.                         0, &must_trunc))
  2310.     {
  2311.       int bitsize = GET_MODE_BITSIZE (GET_MODE (to));
  2312.       REAL_VALUE_TYPE offset = REAL_VALUE_LDEXP (dconst1, bitsize - 1);
  2313.       rtx limit = immed_real_const_1 (offset, fmode);
  2314.       rtx lab1 = gen_label_rtx ();
  2315.       rtx lab2 = gen_label_rtx ();
  2316.       rtx insn;
  2317.  
  2318.       if (fmode != GET_MODE (from))
  2319.         from = convert_to_mode (fmode, from, 0);
  2320.  
  2321.       /* See if we need to do the subtraction.  */
  2322.       do_pending_stack_adjust ();
  2323.       emit_cmp_insn (from, limit, GE, 0, 0);
  2324.       emit_jump_insn (gen_bge (lab1));
  2325.  
  2326.       /* If not, do the signed "fix" and branch around fixup code.  */
  2327.       expand_fix (to, from, 0);
  2328.       emit_jump_insn (gen_jump (lab2));
  2329.       emit_barrier ();
  2330.  
  2331.       /* Otherwise, subtract 2**(N-1), convert to signed number,
  2332.          then add 2**(N-1).  */
  2333.       emit_label (lab1);
  2334.       target = expand_binop (GET_MODE (from), sub_optab, from, limit,
  2335.                  0, 0, OPTAB_LIB_WIDEN);
  2336.       expand_fix (to, target, 0);
  2337.       target = expand_binop (GET_MODE (to), add_optab, to,
  2338.                  gen_rtx (CONST_INT, VOIDmode,
  2339.                     1 << (bitsize - 1)),
  2340.                  to, 1, OPTAB_LIB_WIDEN);
  2341.  
  2342.       if (target != to)
  2343.         emit_move_insn (to, target);
  2344.  
  2345.       emit_label (lab2);
  2346.  
  2347.       /* Make a place for a REG_NOTE and add it.  */
  2348.       insn = emit_move_insn (to, to);
  2349.       REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
  2350.                       gen_rtx (UNSIGNED_FIX, GET_MODE (to),
  2351.                            from), REG_NOTES (insn));
  2352.  
  2353.       return;
  2354.     }
  2355. #endif
  2356.  
  2357.   /* We can't do it with an insn, so use a library call.  But first ensure
  2358.      that the mode of TO is at least as wide as SImode, since those are the
  2359.      only library calls we know about.  */
  2360.  
  2361.   if (GET_MODE_SIZE (GET_MODE (to)) < GET_MODE_SIZE (SImode))
  2362.     {
  2363.       target = gen_reg_rtx (SImode);
  2364.  
  2365.       expand_fix (target, from, unsignedp);
  2366.     }
  2367.   else if (GET_MODE (from) == SFmode)
  2368.     {
  2369.       if (GET_MODE (to) == SImode)
  2370.     {
  2371.       emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2372.                       unsignedp ? "_fixunssfsi"
  2373.                       : "_fixsfsi"),
  2374.                  0, SImode, 1, from, SFmode);
  2375.       target = hard_libcall_value (SImode);
  2376.     }
  2377.       else if (GET_MODE (to) == DImode)
  2378.     {
  2379.       emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2380.                       unsignedp ? "_fixunssfdi"
  2381.                       : "_fixsfdi"),
  2382.                  0, DImode, 1, from, SFmode);
  2383.       target = hard_libcall_value (DImode);
  2384.     }
  2385.       else
  2386.     abort ();
  2387.     }
  2388.   else if (GET_MODE (from) == DFmode)
  2389.     {
  2390.       if (GET_MODE (to) == SImode)
  2391.     {
  2392.       emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2393.                       unsignedp ? "_fixunsdfsi"
  2394.                       : "_fixdfsi"),
  2395.                  0, SImode, 1, from, DFmode);
  2396.       target = hard_libcall_value (SImode);
  2397.     }
  2398.       else if (GET_MODE (to) == DImode)
  2399.     {
  2400.       emit_library_call (gen_rtx (SYMBOL_REF, Pmode,
  2401.                       unsignedp ? "_fixunsdfdi"
  2402.                       : "_fixdfdi"),
  2403.                  0, DImode, 1, from, DFmode);
  2404.       target = hard_libcall_value (DImode);
  2405.     }
  2406.       else
  2407.     abort ();
  2408.     }
  2409.   else
  2410.     abort ();
  2411.  
  2412.   if (GET_MODE (to) == GET_MODE (target))
  2413.     emit_move_insn (to, target);
  2414.   else
  2415.     convert_move (to, target, 0);
  2416. }
  2417.  
  2418. static optab
  2419. init_optab (code)
  2420.      enum rtx_code code;
  2421. {
  2422.   int i;
  2423.   optab op = (optab) xmalloc (sizeof (struct optab));
  2424.   op->code = code;
  2425.   for (i = 0; i < NUM_MACHINE_MODES; i++)
  2426.     {
  2427.       op->handlers[i].insn_code = CODE_FOR_nothing;
  2428.       op->handlers[i].libfunc = 0;
  2429.     }
  2430.   return op;
  2431. }
  2432.  
  2433. /* Call this once to initialize the contents of the optabs
  2434.    appropriately for the current target machine.  */
  2435.  
  2436. void
  2437. init_optabs ()
  2438. {
  2439.   int i;
  2440.  
  2441.   init_fixtab ();
  2442.   init_floattab ();
  2443. /*  init_extends (); */
  2444.  
  2445.   add_optab = init_optab (PLUS);
  2446.   sub_optab = init_optab (MINUS);
  2447.   smul_optab = init_optab (MULT);
  2448.   smul_widen_optab = init_optab (UNKNOWN);
  2449.   umul_widen_optab = init_optab (UNKNOWN);
  2450.   sdiv_optab = init_optab (DIV);
  2451.   sdivmod_optab = init_optab (UNKNOWN);
  2452.   udiv_optab = init_optab (UDIV);
  2453.   udivmod_optab = init_optab (UNKNOWN);
  2454.   smod_optab = init_optab (MOD);
  2455.   umod_optab = init_optab (UMOD);
  2456.   flodiv_optab = init_optab (DIV);
  2457.   ftrunc_optab = init_optab (UNKNOWN);
  2458.   and_optab = init_optab (AND);
  2459.   ior_optab = init_optab (IOR);
  2460.   xor_optab = init_optab (XOR);
  2461.   ashl_optab = init_optab (ASHIFT);
  2462.   ashr_optab = init_optab (ASHIFTRT);
  2463.   lshl_optab = init_optab (LSHIFT);
  2464.   lshr_optab = init_optab (LSHIFTRT);
  2465.   rotl_optab = init_optab (ROTATE);
  2466.   rotr_optab = init_optab (ROTATERT);
  2467.   mov_optab = init_optab (UNKNOWN);
  2468.   movstrict_optab = init_optab (UNKNOWN);
  2469.   cmp_optab = init_optab (UNKNOWN);
  2470.   ucmp_optab = init_optab (UNKNOWN);
  2471.   tst_optab = init_optab (UNKNOWN);
  2472.   neg_optab = init_optab (NEG);
  2473.   abs_optab = init_optab (ABS);
  2474.   one_cmpl_optab = init_optab (NOT);
  2475.   ffs_optab = init_optab (FFS);
  2476.  
  2477. #ifdef HAVE_addqi3
  2478.   if (HAVE_addqi3)
  2479.     add_optab->handlers[(int) QImode].insn_code = CODE_FOR_addqi3;
  2480. #endif
  2481. #ifdef HAVE_addhi3
  2482.   if (HAVE_addhi3)
  2483.     add_optab->handlers[(int) HImode].insn_code = CODE_FOR_addhi3;
  2484. #endif
  2485. #ifdef HAVE_addpsi3
  2486.   if (HAVE_addpsi3)
  2487.     add_optab->handlers[(int) PSImode].insn_code = CODE_FOR_addpsi3;
  2488. #endif
  2489. #ifdef HAVE_addsi3
  2490.   if (HAVE_addsi3)
  2491.     add_optab->handlers[(int) SImode].insn_code = CODE_FOR_addsi3;
  2492. #endif
  2493. #ifdef HAVE_adddi3
  2494.   if (HAVE_adddi3)
  2495.     add_optab->handlers[(int) DImode].insn_code = CODE_FOR_adddi3;
  2496. #endif
  2497. #ifdef HAVE_addsf3
  2498.   if (HAVE_addsf3)
  2499.     add_optab->handlers[(int) SFmode].insn_code = CODE_FOR_addsf3;
  2500. #endif
  2501. #ifdef HAVE_adddf3
  2502.   if (HAVE_adddf3)
  2503.     add_optab->handlers[(int) DFmode].insn_code = CODE_FOR_adddf3;
  2504. #endif
  2505.   add_optab->handlers[(int) DImode].libfunc
  2506.     = gen_rtx (SYMBOL_REF, Pmode, "_adddi3");
  2507.   add_optab->handlers[(int) SFmode].libfunc
  2508.     = gen_rtx (SYMBOL_REF, Pmode, "_addsf3");
  2509.   add_optab->handlers[(int) DFmode].libfunc
  2510.     = gen_rtx (SYMBOL_REF, Pmode, "_adddf3");
  2511.  
  2512. #ifdef HAVE_subqi3
  2513.   if (HAVE_subqi3)
  2514.     sub_optab->handlers[(int) QImode].insn_code = CODE_FOR_subqi3;
  2515. #endif
  2516. #ifdef HAVE_subhi3
  2517.   if (HAVE_subhi3)
  2518.     sub_optab->handlers[(int) HImode].insn_code = CODE_FOR_subhi3;
  2519. #endif
  2520. #ifdef HAVE_subpsi3
  2521.   if (HAVE_subpsi3)
  2522.     sub_optab->handlers[(int) PSImode].insn_code = CODE_FOR_subpsi3;
  2523. #endif
  2524. #ifdef HAVE_subsi3
  2525.   if (HAVE_subsi3)
  2526.     sub_optab->handlers[(int) SImode].insn_code = CODE_FOR_subsi3;
  2527. #endif
  2528. #ifdef HAVE_subdi3
  2529.   if (HAVE_subdi3)
  2530.     sub_optab->handlers[(int) DImode].insn_code = CODE_FOR_subdi3;
  2531. #endif
  2532. #ifdef HAVE_subsf3
  2533.   if (HAVE_subsf3)
  2534.     sub_optab->handlers[(int) SFmode].insn_code = CODE_FOR_subsf3;
  2535. #endif
  2536. #ifdef HAVE_subdf3
  2537.   if (HAVE_subdf3)
  2538.     sub_optab->handlers[(int) DFmode].insn_code = CODE_FOR_subdf3;
  2539. #endif
  2540.   sub_optab->handlers[(int) DImode].libfunc
  2541.     = gen_rtx (SYMBOL_REF, Pmode, "_subdi3");
  2542.   sub_optab->handlers[(int) SFmode].libfunc
  2543.     = gen_rtx (SYMBOL_REF, Pmode, "_subsf3");
  2544.   sub_optab->handlers[(int) DFmode].libfunc
  2545.     = gen_rtx (SYMBOL_REF, Pmode, "_subdf3");
  2546.  
  2547. #ifdef HAVE_mulqi3
  2548.   if (HAVE_mulqi3)
  2549.     smul_optab->handlers[(int) QImode].insn_code = CODE_FOR_mulqi3;
  2550. #endif
  2551. #ifdef HAVE_mulhi3
  2552.   if (HAVE_mulhi3)
  2553.     smul_optab->handlers[(int) HImode].insn_code = CODE_FOR_mulhi3;
  2554. #endif
  2555. #ifdef HAVE_mulpsi3
  2556.   if (HAVE_mulpsi3)
  2557.     smul_optab->handlers[(int) PSImode].insn_code = CODE_FOR_mulpsi3;
  2558. #endif
  2559. #ifdef HAVE_mulsi3
  2560.   if (HAVE_mulsi3)
  2561.     smul_optab->handlers[(int) SImode].insn_code = CODE_FOR_mulsi3;
  2562. #endif
  2563. #ifdef HAVE_muldi3
  2564.   if (HAVE_muldi3)
  2565.     smul_optab->handlers[(int) DImode].insn_code = CODE_FOR_muldi3;
  2566. #endif
  2567. #ifdef HAVE_mulsf3
  2568.   if (HAVE_mulsf3)
  2569.     smul_optab->handlers[(int) SFmode].insn_code = CODE_FOR_mulsf3;
  2570. #endif
  2571. #ifdef HAVE_muldf3
  2572.   if (HAVE_muldf3)
  2573.     smul_optab->handlers[(int) DFmode].insn_code = CODE_FOR_muldf3;
  2574. #endif
  2575.  
  2576. #ifdef MULSI3_LIBCALL
  2577.   smul_optab->handlers[(int) SImode].libfunc
  2578.     = gen_rtx (SYMBOL_REF, Pmode, MULSI3_LIBCALL);
  2579. #else
  2580.   smul_optab->handlers[(int) SImode].libfunc
  2581.     = gen_rtx (SYMBOL_REF, Pmode, "_mulsi3");
  2582. #endif
  2583. #ifdef MULDI3_LIBCALL
  2584.   smul_optab->handlers[(int) DImode].libfunc
  2585.     = gen_rtx (SYMBOL_REF, Pmode, MULDI3_LIBCALL);
  2586. #else
  2587.   smul_optab->handlers[(int) DImode].libfunc
  2588.     = gen_rtx (SYMBOL_REF, Pmode, "_muldi3");
  2589. #endif
  2590.   smul_optab->handlers[(int) SFmode].libfunc
  2591.     = gen_rtx (SYMBOL_REF, Pmode, "_mulsf3");
  2592.   smul_optab->handlers[(int) DFmode].libfunc
  2593.     = gen_rtx (SYMBOL_REF, Pmode, "_muldf3");
  2594.  
  2595. #ifdef HAVE_mulqihi3
  2596.   if (HAVE_mulqihi3)
  2597.     smul_widen_optab->handlers[(int) HImode].insn_code = CODE_FOR_mulqihi3;
  2598. #endif
  2599. #ifdef HAVE_mulhisi3
  2600.   if (HAVE_mulhisi3)
  2601.     smul_widen_optab->handlers[(int) SImode].insn_code = CODE_FOR_mulhisi3;
  2602. #endif
  2603. #ifdef HAVE_mulsidi3
  2604.   if (HAVE_mulsidi3)
  2605.     smul_widen_optab->handlers[(int) DImode].insn_code = CODE_FOR_mulsidi3;
  2606. #endif
  2607.  
  2608. #ifdef HAVE_umulqihi3
  2609.   if (HAVE_umulqihi3)
  2610.     umul_widen_optab->handlers[(int) HImode].insn_code = CODE_FOR_umulqihi3;
  2611. #endif
  2612. #ifdef HAVE_umulhisi3
  2613.   if (HAVE_umulhisi3)
  2614.     umul_widen_optab->handlers[(int) SImode].insn_code = CODE_FOR_umulhisi3;
  2615. #endif
  2616. #ifdef HAVE_umulsidi3
  2617.   if (HAVE_umulsidi3)
  2618.     umul_widen_optab->handlers[(int) DImode].insn_code = CODE_FOR_umulsidi3;
  2619. #endif
  2620.  
  2621. #ifdef HAVE_divqi3
  2622.   if (HAVE_divqi3)
  2623.     sdiv_optab->handlers[(int) QImode].insn_code = CODE_FOR_divqi3;
  2624. #endif
  2625. #ifdef HAVE_divhi3
  2626.   if (HAVE_divhi3)
  2627.     sdiv_optab->handlers[(int) HImode].insn_code = CODE_FOR_divhi3;
  2628. #endif
  2629. #ifdef HAVE_divpsi3
  2630.   if (HAVE_divpsi3)
  2631.     sdiv_optab->handlers[(int) PSImode].insn_code = CODE_FOR_divpsi3;
  2632. #endif
  2633. #ifdef HAVE_divsi3
  2634.   if (HAVE_divsi3)
  2635.     sdiv_optab->handlers[(int) SImode].insn_code = CODE_FOR_divsi3;
  2636. #endif
  2637. #ifdef HAVE_divdi3
  2638.   if (HAVE_divdi3)
  2639.     sdiv_optab->handlers[(int) DImode].insn_code = CODE_FOR_divdi3;
  2640. #endif
  2641.  
  2642. #ifdef DIVSI3_LIBCALL
  2643.   sdiv_optab->handlers[(int) SImode].libfunc
  2644.     = gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL);
  2645. #else
  2646.   sdiv_optab->handlers[(int) SImode].libfunc
  2647.     = gen_rtx (SYMBOL_REF, Pmode, "_divsi3");
  2648. #endif
  2649. #ifdef DIVDI3_LIBCALL
  2650.   sdiv_optab->handlers[(int) DImode].libfunc
  2651.     = gen_rtx (SYMBOL_REF, Pmode, DIVDI3_LIBCALL);
  2652. #else
  2653.   sdiv_optab->handlers[(int) DImode].libfunc
  2654.     = gen_rtx (SYMBOL_REF, Pmode, "_divdi3");
  2655. #endif
  2656.  
  2657. #ifdef HAVE_udivqi3
  2658.   if (HAVE_udivqi3)
  2659.     udiv_optab->handlers[(int) QImode].insn_code = CODE_FOR_udivqi3;
  2660. #endif
  2661. #ifdef HAVE_udivhi3
  2662.   if (HAVE_udivhi3)
  2663.     udiv_optab->handlers[(int) HImode].insn_code = CODE_FOR_udivhi3;
  2664. #endif
  2665. #ifdef HAVE_udivpsi3
  2666.   if (HAVE_udivpsi3)
  2667.     udiv_optab->handlers[(int) PSImode].insn_code = CODE_FOR_udivpsi3;
  2668. #endif
  2669. #ifdef HAVE_udivsi3
  2670.   if (HAVE_udivsi3)
  2671.     udiv_optab->handlers[(int) SImode].insn_code = CODE_FOR_udivsi3;
  2672. #endif
  2673. #ifdef HAVE_udivdi3
  2674.   if (HAVE_udivdi3)
  2675.     udiv_optab->handlers[(int) DImode].insn_code = CODE_FOR_udivdi3;
  2676. #endif
  2677.  
  2678. #ifdef UDIVSI3_LIBCALL
  2679.   udiv_optab->handlers[(int) SImode].libfunc
  2680.     = gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL);
  2681. #else
  2682.   udiv_optab->handlers[(int) SImode].libfunc
  2683.     = gen_rtx (SYMBOL_REF, Pmode, "_udivsi3");
  2684. #endif
  2685. #ifdef UDIVDI3_LIBCALL
  2686.   udiv_optab->handlers[(int) DImode].libfunc
  2687.     = gen_rtx (SYMBOL_REF, Pmode, UDIVDI3_LIBCALL);
  2688. #else
  2689.   udiv_optab->handlers[(int) DImode].libfunc
  2690.     = gen_rtx (SYMBOL_REF, Pmode, "_udivdi3");
  2691. #endif
  2692.  
  2693. #ifdef HAVE_divmodqi4
  2694.   if (HAVE_divmodqi4)
  2695.     sdivmod_optab->handlers[(int) QImode].insn_code = CODE_FOR_divmodqi4;
  2696. #endif
  2697. #ifdef HAVE_divmodhi4
  2698.   if (HAVE_divmodhi4)
  2699.     sdivmod_optab->handlers[(int) HImode].insn_code = CODE_FOR_divmodhi4;
  2700. #endif
  2701. #ifdef HAVE_divmodsi4
  2702.   if (HAVE_divmodsi4)
  2703.     sdivmod_optab->handlers[(int) SImode].insn_code = CODE_FOR_divmodsi4;
  2704. #endif
  2705. #ifdef HAVE_divmoddi4
  2706.   if (HAVE_divmoddi4)
  2707.     sdivmod_optab->handlers[(int) DImode].insn_code = CODE_FOR_divmoddi4;
  2708. #endif
  2709.  
  2710. #ifdef HAVE_udivmodqi4
  2711.   if (HAVE_udivmodqi4)
  2712.     udivmod_optab->handlers[(int) QImode].insn_code = CODE_FOR_udivmodqi4;
  2713. #endif
  2714. #ifdef HAVE_udivmodhi4
  2715.   if (HAVE_udivmodhi4)
  2716.     udivmod_optab->handlers[(int) HImode].insn_code = CODE_FOR_udivmodhi4;
  2717. #endif
  2718. #ifdef HAVE_udivmodsi4
  2719.   if (HAVE_udivmodsi4)
  2720.     udivmod_optab->handlers[(int) SImode].insn_code = CODE_FOR_udivmodsi4;
  2721. #endif
  2722. #ifdef HAVE_udivmoddi4
  2723.   if (HAVE_udivmoddi4)
  2724.     udivmod_optab->handlers[(int) DImode].insn_code = CODE_FOR_udivmoddi4;
  2725. #endif
  2726.  
  2727. #ifdef HAVE_modqi3
  2728.   if (HAVE_modqi3)
  2729.     smod_optab->handlers[(int) QImode].insn_code = CODE_FOR_modqi3;
  2730. #endif
  2731. #ifdef HAVE_modhi3
  2732.   if (HAVE_modhi3)
  2733.     smod_optab->handlers[(int) HImode].insn_code = CODE_FOR_modhi3;
  2734. #endif
  2735. #ifdef HAVE_modpsi3
  2736.   if (HAVE_modpsi3)
  2737.     smod_optab->handlers[(int) PSImode].insn_code = CODE_FOR_modpsi3;
  2738. #endif
  2739. #ifdef HAVE_modsi3
  2740.   if (HAVE_modsi3)
  2741.     smod_optab->handlers[(int) SImode].insn_code = CODE_FOR_modsi3;
  2742. #endif
  2743. #ifdef HAVE_moddi3
  2744.   if (HAVE_moddi3)
  2745.     smod_optab->handlers[(int) DImode].insn_code = CODE_FOR_moddi3;
  2746. #endif
  2747.  
  2748. #ifdef MODSI3_LIBCALL
  2749.   smod_optab->handlers[(int) SImode].libfunc
  2750.     = gen_rtx (SYMBOL_REF, Pmode, MODSI3_LIBCALL);
  2751. #else
  2752.   smod_optab->handlers[(int) SImode].libfunc
  2753.     = gen_rtx (SYMBOL_REF, Pmode, "_modsi3");
  2754. #endif
  2755. #ifdef MODDI3_LIBCALL
  2756.   smod_optab->handlers[(int) DImode].libfunc
  2757.     = gen_rtx (SYMBOL_REF, Pmode, MODDI3_LIBCALL);
  2758. #else
  2759.   smod_optab->handlers[(int) DImode].libfunc
  2760.     = gen_rtx (SYMBOL_REF, Pmode, "_moddi3");
  2761. #endif
  2762.  
  2763. #ifdef HAVE_umodqi3
  2764.   if (HAVE_umodqi3)
  2765.     umod_optab->handlers[(int) QImode].insn_code = CODE_FOR_umodqi3;
  2766. #endif
  2767. #ifdef HAVE_umodhi3
  2768.   if (HAVE_umodhi3)
  2769.     umod_optab->handlers[(int) HImode].insn_code = CODE_FOR_umodhi3;
  2770. #endif
  2771. #ifdef HAVE_umodpsi3
  2772.   if (HAVE_umodpsi3)
  2773.     umod_optab->handlers[(int) PSImode].insn_code = CODE_FOR_umodpsi3;
  2774. #endif
  2775. #ifdef HAVE_umodsi3
  2776.   if (HAVE_umodsi3)
  2777.     umod_optab->handlers[(int) SImode].insn_code = CODE_FOR_umodsi3;
  2778. #endif
  2779. #ifdef HAVE_umoddi3
  2780.   if (HAVE_umoddi3)
  2781.     umod_optab->handlers[(int) DImode].insn_code = CODE_FOR_umoddi3;
  2782. #endif
  2783.  
  2784. #ifdef UMODSI3_LIBCALL
  2785.   umod_optab->handlers[(int) SImode].libfunc
  2786.     = gen_rtx (SYMBOL_REF, Pmode, UMODSI3_LIBCALL);
  2787. #else
  2788.   umod_optab->handlers[(int) SImode].libfunc
  2789.     = gen_rtx (SYMBOL_REF, Pmode, "_umodsi3");
  2790. #endif
  2791. #ifdef UMODDI3_LIBCALL
  2792.   umod_optab->handlers[(int) DImode].libfunc
  2793.     = gen_rtx (SYMBOL_REF, Pmode, UMODDI3_LIBCALL);
  2794. #else
  2795.   umod_optab->handlers[(int) DImode].libfunc
  2796.     = gen_rtx (SYMBOL_REF, Pmode, "_umoddi3");
  2797. #endif
  2798.  
  2799. #ifdef HAVE_divsf3
  2800.   if (HAVE_divsf3)
  2801.     flodiv_optab->handlers[(int) SFmode].insn_code = CODE_FOR_divsf3;
  2802. #endif
  2803. #ifdef HAVE_divdf3
  2804.   if (HAVE_divdf3)
  2805.     flodiv_optab->handlers[(int) DFmode].insn_code = CODE_FOR_divdf3;
  2806. #endif
  2807.   flodiv_optab->handlers[(int) SFmode].libfunc
  2808.     = gen_rtx (SYMBOL_REF, Pmode, "_divsf3");
  2809.   flodiv_optab->handlers[(int) DFmode].libfunc
  2810.     = gen_rtx (SYMBOL_REF, Pmode, "_divdf3");
  2811.  
  2812. #ifdef HAVE_ftruncsf2
  2813.   if (HAVE_ftruncsf2)
  2814.     ftrunc_optab->handlers[(int) SFmode].insn_code = CODE_FOR_ftruncsf2;
  2815. #endif
  2816. #ifdef HAVE_ftruncdf2
  2817.   if (HAVE_ftruncdf2)
  2818.     ftrunc_optab->handlers[(int) DFmode].insn_code = CODE_FOR_ftruncdf2;
  2819. #endif
  2820.  
  2821. #ifdef HAVE_andqi3
  2822.   if (HAVE_andqi3)
  2823.     and_optab->handlers[(int) QImode].insn_code = CODE_FOR_andqi3;
  2824. #endif
  2825. #ifdef HAVE_andhi3
  2826.   if (HAVE_andhi3)
  2827.     and_optab->handlers[(int) HImode].insn_code = CODE_FOR_andhi3;
  2828. #endif
  2829. #ifdef HAVE_andpsi3
  2830.   if (HAVE_andpsi3)
  2831.     and_optab->handlers[(int) PSImode].insn_code = CODE_FOR_andpsi3;
  2832. #endif
  2833. #ifdef HAVE_andsi3
  2834.   if (HAVE_andsi3)
  2835.     and_optab->handlers[(int) SImode].insn_code = CODE_FOR_andsi3;
  2836. #endif
  2837. #ifdef HAVE_anddi3
  2838.   if (HAVE_anddi3)
  2839.     and_optab->handlers[(int) DImode].insn_code = CODE_FOR_anddi3;
  2840. #endif
  2841.   and_optab->handlers[(int) DImode].libfunc
  2842.     = gen_rtx (SYMBOL_REF, Pmode, "_anddi3");
  2843.  
  2844. #ifdef HAVE_iorqi3
  2845.   if (HAVE_iorqi3)
  2846.     ior_optab->handlers[(int) QImode].insn_code = CODE_FOR_iorqi3;
  2847. #endif
  2848. #ifdef HAVE_iorhi3
  2849.   if (HAVE_iorhi3)
  2850.     ior_optab->handlers[(int) HImode].insn_code = CODE_FOR_iorhi3;
  2851. #endif
  2852. #ifdef HAVE_iorpsi3
  2853.   if (HAVE_iorpsi3)
  2854.     ior_optab->handlers[(int) PSImode].insn_code = CODE_FOR_iorpsi3;
  2855. #endif
  2856. #ifdef HAVE_iorsi3
  2857.   if (HAVE_iorsi3)
  2858.     ior_optab->handlers[(int) SImode].insn_code = CODE_FOR_iorsi3;
  2859. #endif
  2860. #ifdef HAVE_iordi3
  2861.   if (HAVE_iordi3)
  2862.     ior_optab->handlers[(int) DImode].insn_code = CODE_FOR_iordi3;
  2863. #endif
  2864.   ior_optab->handlers[(int) DImode].libfunc
  2865.     = gen_rtx (SYMBOL_REF, Pmode, "_iordi3");
  2866.  
  2867. #ifdef HAVE_xorqi3
  2868.   if (HAVE_xorqi3)
  2869.     xor_optab->handlers[(int) QImode].insn_code = CODE_FOR_xorqi3;
  2870. #endif
  2871. #ifdef HAVE_xorhi3
  2872.   if (HAVE_xorhi3)
  2873.     xor_optab->handlers[(int) HImode].insn_code = CODE_FOR_xorhi3;
  2874. #endif
  2875. #ifdef HAVE_xorpsi3
  2876.   if (HAVE_xorpsi3)
  2877.     xor_optab->handlers[(int) PSImode].insn_code = CODE_FOR_xorpsi3;
  2878. #endif
  2879. #ifdef HAVE_xorsi3
  2880.   if (HAVE_xorsi3)
  2881.     xor_optab->handlers[(int) SImode].insn_code = CODE_FOR_xorsi3;
  2882. #endif
  2883. #ifdef HAVE_xordi3
  2884.   if (HAVE_xordi3)
  2885.     xor_optab->handlers[(int) DImode].insn_code = CODE_FOR_xordi3;
  2886. #endif
  2887.   xor_optab->handlers[(int) DImode].libfunc
  2888.     = gen_rtx (SYMBOL_REF, Pmode, "_xordi3");
  2889.  
  2890. #ifdef HAVE_ashlqi3
  2891.   if (HAVE_ashlqi3)
  2892.     ashl_optab->handlers[(int) QImode].insn_code = CODE_FOR_ashlqi3;
  2893. #endif
  2894. #ifdef HAVE_ashlhi3
  2895.   if (HAVE_ashlhi3)
  2896.     ashl_optab->handlers[(int) HImode].insn_code = CODE_FOR_ashlhi3;
  2897. #endif
  2898. #ifdef HAVE_ashlpsi3
  2899.   if (HAVE_ashlpsi3)
  2900.     ashl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ashlpsi3;
  2901. #endif
  2902. #ifdef HAVE_ashlsi3
  2903.   if (HAVE_ashlsi3)
  2904.     ashl_optab->handlers[(int) SImode].insn_code = CODE_FOR_ashlsi3;
  2905. #endif
  2906. #ifdef HAVE_ashldi3
  2907.   if (HAVE_ashldi3)
  2908.     ashl_optab->handlers[(int) DImode].insn_code = CODE_FOR_ashldi3;
  2909. #endif
  2910.   ashl_optab->handlers[(int) SImode].libfunc
  2911.     = gen_rtx (SYMBOL_REF, Pmode, "_ashlsi3");
  2912.   ashl_optab->handlers[(int) DImode].libfunc
  2913.     = gen_rtx (SYMBOL_REF, Pmode, "_ashldi3");
  2914.  
  2915. #ifdef HAVE_ashrqi3
  2916.   if (HAVE_ashrqi3)
  2917.     ashr_optab->handlers[(int) QImode].insn_code = CODE_FOR_ashrqi3;
  2918. #endif
  2919. #ifdef HAVE_ashrhi3
  2920.   if (HAVE_ashrhi3)
  2921.     ashr_optab->handlers[(int) HImode].insn_code = CODE_FOR_ashrhi3;
  2922. #endif
  2923. #ifdef HAVE_ashrpsi3
  2924.   if (HAVE_ashrpsi3)
  2925.     ashr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ashrpsi3;
  2926. #endif
  2927. #ifdef HAVE_ashrsi3
  2928.   if (HAVE_ashrsi3)
  2929.     ashr_optab->handlers[(int) SImode].insn_code = CODE_FOR_ashrsi3;
  2930. #endif
  2931. #ifdef HAVE_ashrdi3
  2932.   if (HAVE_ashrdi3)
  2933.     ashr_optab->handlers[(int) DImode].insn_code = CODE_FOR_ashrdi3;
  2934. #endif
  2935.   ashr_optab->handlers[(int) SImode].libfunc
  2936.     = gen_rtx (SYMBOL_REF, Pmode, "_ashrsi3");
  2937.   ashr_optab->handlers[(int) DImode].libfunc
  2938.     = gen_rtx (SYMBOL_REF, Pmode, "_ashrdi3");
  2939.  
  2940. #ifdef HAVE_lshlqi3
  2941.   if (HAVE_lshlqi3)
  2942.     lshl_optab->handlers[(int) QImode].insn_code = CODE_FOR_lshlqi3;
  2943. #endif
  2944. #ifdef HAVE_lshlhi3
  2945.   if (HAVE_lshlhi3)
  2946.     lshl_optab->handlers[(int) HImode].insn_code = CODE_FOR_lshlhi3;
  2947. #endif
  2948. #ifdef HAVE_lshlpsi3
  2949.   if (HAVE_lshlpsi3)
  2950.     lshl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_lshlpsi3;
  2951. #endif
  2952. #ifdef HAVE_lshlsi3
  2953.   if (HAVE_lshlsi3)
  2954.     lshl_optab->handlers[(int) SImode].insn_code = CODE_FOR_lshlsi3;
  2955. #endif
  2956. #ifdef HAVE_lshldi3
  2957.   if (HAVE_lshldi3)
  2958.     lshl_optab->handlers[(int) DImode].insn_code = CODE_FOR_lshldi3;
  2959. #endif
  2960.   lshl_optab->handlers[(int) SImode].libfunc
  2961.     = gen_rtx (SYMBOL_REF, Pmode, "_lshlsi3");
  2962.   lshl_optab->handlers[(int) DImode].libfunc
  2963.     = gen_rtx (SYMBOL_REF, Pmode, "_lshldi3");
  2964.  
  2965. #ifdef HAVE_lshrqi3
  2966.   if (HAVE_lshrqi3)
  2967.     lshr_optab->handlers[(int) QImode].insn_code = CODE_FOR_lshrqi3;
  2968. #endif
  2969. #ifdef HAVE_lshrhi3
  2970.   if (HAVE_lshrhi3)
  2971.     lshr_optab->handlers[(int) HImode].insn_code = CODE_FOR_lshrhi3;
  2972. #endif
  2973. #ifdef HAVE_lshrpsi3
  2974.   if (HAVE_lshrpsi3)
  2975.     lshr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_lshrpsi3;
  2976. #endif
  2977. #ifdef HAVE_lshrsi3
  2978.   if (HAVE_lshrsi3)
  2979.     lshr_optab->handlers[(int) SImode].insn_code = CODE_FOR_lshrsi3;
  2980. #endif
  2981. #ifdef HAVE_lshrdi3
  2982.   if (HAVE_lshrdi3)
  2983.     lshr_optab->handlers[(int) DImode].insn_code = CODE_FOR_lshrdi3;
  2984. #endif
  2985.   lshr_optab->handlers[(int) SImode].libfunc
  2986.     = gen_rtx (SYMBOL_REF, Pmode, "_lshrsi3");
  2987.   lshr_optab->handlers[(int) DImode].libfunc
  2988.     = gen_rtx (SYMBOL_REF, Pmode, "_lshrdi3");
  2989.  
  2990. #ifdef HAVE_rotlqi3
  2991.   if (HAVE_rotlqi3)
  2992.     rotl_optab->handlers[(int) QImode].insn_code = CODE_FOR_rotlqi3;
  2993. #endif
  2994. #ifdef HAVE_rotlhi3
  2995.   if (HAVE_rotlhi3)
  2996.     rotl_optab->handlers[(int) HImode].insn_code = CODE_FOR_rotlhi3;
  2997. #endif
  2998. #ifdef HAVE_rotlpsi3
  2999.   if (HAVE_rotlpsi3)
  3000.     rotl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_rotlpsi3;
  3001. #endif
  3002. #ifdef HAVE_rotlsi3
  3003.   if (HAVE_rotlsi3)
  3004.     rotl_optab->handlers[(int) SImode].insn_code = CODE_FOR_rotlsi3;
  3005. #endif
  3006. #ifdef HAVE_rotldi3
  3007.   if (HAVE_rotldi3)
  3008.     rotl_optab->handlers[(int) DImode].insn_code = CODE_FOR_rotldi3;
  3009. #endif
  3010.   rotl_optab->handlers[(int) SImode].libfunc
  3011.     = gen_rtx (SYMBOL_REF, Pmode, "_rotlsi3");
  3012.   rotl_optab->handlers[(int) DImode].libfunc
  3013.     = gen_rtx (SYMBOL_REF, Pmode, "_rotldi3");
  3014.  
  3015. #ifdef HAVE_rotrqi3
  3016.   if (HAVE_rotrqi3)
  3017.     rotr_optab->handlers[(int) QImode].insn_code = CODE_FOR_rotrqi3;
  3018. #endif
  3019. #ifdef HAVE_rotrhi3
  3020.   if (HAVE_rotrhi3)
  3021.     rotr_optab->handlers[(int) HImode].insn_code = CODE_FOR_rotrhi3;
  3022. #endif
  3023. #ifdef HAVE_rotrpsi3
  3024.   if (HAVE_rotrpsi3)
  3025.     rotr_optab->handlers[(int) PSImode].insn_code = CODE_FOR_rotrpsi3;
  3026. #endif
  3027. #ifdef HAVE_rotrsi3
  3028.   if (HAVE_rotrsi3)
  3029.     rotr_optab->handlers[(int) SImode].insn_code = CODE_FOR_rotrsi3;
  3030. #endif
  3031. #ifdef HAVE_rotrdi3
  3032.   if (HAVE_rotrdi3)
  3033.     rotr_optab->handlers[(int) DImode].insn_code = CODE_FOR_rotrdi3;
  3034. #endif
  3035.   rotr_optab->handlers[(int) SImode].libfunc
  3036.     = gen_rtx (SYMBOL_REF, Pmode, "_rotrsi3");
  3037.   rotr_optab->handlers[(int) DImode].libfunc
  3038.     = gen_rtx (SYMBOL_REF, Pmode, "_rotrdi3");
  3039.  
  3040. #ifdef HAVE_negqi2
  3041.   if (HAVE_negqi2)
  3042.     neg_optab->handlers[(int) QImode].insn_code = CODE_FOR_negqi2;
  3043. #endif
  3044. #ifdef HAVE_neghi2
  3045.   if (HAVE_neghi2)
  3046.     neg_optab->handlers[(int) HImode].insn_code = CODE_FOR_neghi2;
  3047. #endif
  3048. #ifdef HAVE_negpsi2
  3049.   if (HAVE_negpsi2)
  3050.     neg_optab->handlers[(int) PSImode].insn_code = CODE_FOR_negpsi2;
  3051. #endif
  3052. #ifdef HAVE_negsi2
  3053.   if (HAVE_negsi2)
  3054.     neg_optab->handlers[(int) SImode].insn_code = CODE_FOR_negsi2;
  3055. #endif
  3056. #ifdef HAVE_negdi2
  3057.   if (HAVE_negdi2)
  3058.     neg_optab->handlers[(int) DImode].insn_code = CODE_FOR_negdi2;
  3059. #endif
  3060. #ifdef HAVE_negsf2
  3061.   if (HAVE_negsf2)
  3062.     neg_optab->handlers[(int) SFmode].insn_code = CODE_FOR_negsf2;
  3063. #endif
  3064. #ifdef HAVE_negdf2
  3065.   if (HAVE_negdf2)
  3066.     neg_optab->handlers[(int) DFmode].insn_code = CODE_FOR_negdf2;
  3067. #endif
  3068.   neg_optab->handlers[(int) SImode].libfunc
  3069.     = gen_rtx (SYMBOL_REF, Pmode, "_negsi2"); 
  3070.   neg_optab->handlers[(int) DImode].libfunc
  3071.     = gen_rtx (SYMBOL_REF, Pmode, "_negdi2");
  3072.   neg_optab->handlers[(int) SFmode].libfunc
  3073.     = gen_rtx (SYMBOL_REF, Pmode, "_negsf2");
  3074.   neg_optab->handlers[(int) DFmode].libfunc
  3075.     = gen_rtx (SYMBOL_REF, Pmode, "_negdf2");
  3076.  
  3077. #ifdef HAVE_absqi2
  3078.   if (HAVE_absqi2)
  3079.     abs_optab->handlers[(int) QImode].insn_code = CODE_FOR_absqi2;
  3080. #endif
  3081. #ifdef HAVE_abshi2
  3082.   if (HAVE_abshi2)
  3083.     abs_optab->handlers[(int) HImode].insn_code = CODE_FOR_abshi2;
  3084. #endif
  3085. #ifdef HAVE_abspsi2
  3086.   if (HAVE_abspsi2)
  3087.     abs_optab->handlers[(int) PSImode].insn_code = CODE_FOR_abspsi2;
  3088. #endif
  3089. #ifdef HAVE_abssi2
  3090.   if (HAVE_abssi2)
  3091.     abs_optab->handlers[(int) SImode].insn_code = CODE_FOR_abssi2;
  3092. #endif
  3093. #ifdef HAVE_absdi2
  3094.   if (HAVE_absdi2)
  3095.     abs_optab->handlers[(int) DImode].insn_code = CODE_FOR_absdi2;
  3096. #endif
  3097. #ifdef HAVE_abssf2
  3098.   if (HAVE_abssf2)
  3099.     abs_optab->handlers[(int) SFmode].insn_code = CODE_FOR_abssf2;
  3100. #endif
  3101. #ifdef HAVE_absdf2
  3102.   if (HAVE_absdf2)
  3103.     abs_optab->handlers[(int) DFmode].insn_code = CODE_FOR_absdf2;
  3104. #endif
  3105.   /* No library calls here!  If there is no abs instruction,
  3106.      expand_expr will generate a conditional negation.  */
  3107.  
  3108. #ifdef HAVE_one_cmplqi2
  3109.   if (HAVE_one_cmplqi2)
  3110.     one_cmpl_optab->handlers[(int) QImode].insn_code = CODE_FOR_one_cmplqi2;
  3111. #endif
  3112. #ifdef HAVE_one_cmplhi2
  3113.   if (HAVE_one_cmplhi2)
  3114.     one_cmpl_optab->handlers[(int) HImode].insn_code = CODE_FOR_one_cmplhi2;
  3115. #endif
  3116. #ifdef HAVE_one_cmplpsi2
  3117.   if (HAVE_one_cmplpsi2)
  3118.     one_cmpl_optab->handlers[(int) PSImode].insn_code = CODE_FOR_one_cmplpsi2;
  3119. #endif
  3120. #ifdef HAVE_one_cmplsi2
  3121.   if (HAVE_one_cmplsi2)
  3122.     one_cmpl_optab->handlers[(int) SImode].insn_code = CODE_FOR_one_cmplsi2;
  3123. #endif
  3124. #ifdef HAVE_one_cmpldi2
  3125.   if (HAVE_one_cmpldi2)
  3126.     one_cmpl_optab->handlers[(int) DImode].insn_code = CODE_FOR_one_cmpldi2;
  3127. #endif
  3128.   one_cmpl_optab->handlers[(int) SImode].libfunc
  3129.     = gen_rtx (SYMBOL_REF, Pmode, "_one_cmplsi2"); 
  3130.   one_cmpl_optab->handlers[(int) DImode].libfunc
  3131.     = gen_rtx (SYMBOL_REF, Pmode, "_one_cmpldi2");
  3132.  
  3133. #ifdef HAVE_ffsqi2
  3134.   if (HAVE_ffsqi2)
  3135.     ffs_optab->handlers[(int) QImode].insn_code = CODE_FOR_ffsqi2;
  3136. #endif
  3137. #ifdef HAVE_ffshi2
  3138.   if (HAVE_ffshi2)
  3139.     ffs_optab->handlers[(int) HImode].insn_code = CODE_FOR_ffshi2;
  3140. #endif
  3141. #ifdef HAVE_ffspsi2
  3142.   if (HAVE_ffspsi2)
  3143.     ffs_optab->handlers[(int) PSImode].insn_code = CODE_FOR_ffspsi2;
  3144. #endif
  3145. #ifdef HAVE_ffssi2
  3146.   if (HAVE_ffssi2)
  3147.     ffs_optab->handlers[(int) SImode].insn_code = CODE_FOR_ffssi2;
  3148. #endif
  3149. #ifdef HAVE_ffsdi2
  3150.   if (HAVE_ffsdi2)
  3151.     ffs_optab->handlers[(int) DImode].insn_code = CODE_FOR_ffsdi2;
  3152. #endif
  3153.   ffs_optab->handlers[(int) SImode].libfunc
  3154.     = gen_rtx (SYMBOL_REF, Pmode, "ffs"); 
  3155.  
  3156. #ifdef HAVE_movqi
  3157.   if (HAVE_movqi)
  3158.     mov_optab->handlers[(int) QImode].insn_code = CODE_FOR_movqi;
  3159. #endif
  3160. #ifdef HAVE_movhi
  3161.   if (HAVE_movhi)
  3162.     mov_optab->handlers[(int) HImode].insn_code = CODE_FOR_movhi;
  3163. #endif
  3164. #ifdef HAVE_movpsi
  3165.   if (HAVE_movpsi)
  3166.     mov_optab->handlers[(int) PSImode].insn_code = CODE_FOR_movpsi;
  3167. #endif
  3168. #ifdef HAVE_movsi
  3169.   if (HAVE_movsi)
  3170.     mov_optab->handlers[(int) SImode].insn_code = CODE_FOR_movsi;
  3171. #endif
  3172. #ifdef HAVE_movdi
  3173.   if (HAVE_movdi)
  3174.     mov_optab->handlers[(int) DImode].insn_code = CODE_FOR_movdi;
  3175. #endif
  3176. #ifdef HAVE_movti
  3177.   if (HAVE_movti)
  3178.     mov_optab->handlers[(int) TImode].insn_code = CODE_FOR_movti;
  3179. #endif
  3180. #ifdef HAVE_movsf
  3181.   if (HAVE_movsf)
  3182.     mov_optab->handlers[(int) SFmode].insn_code = CODE_FOR_movsf;
  3183. #endif
  3184. #ifdef HAVE_movdf
  3185.   if (HAVE_movdf)
  3186.     mov_optab->handlers[(int) DFmode].insn_code = CODE_FOR_movdf;
  3187. #endif
  3188. #ifdef HAVE_movtf
  3189.   if (HAVE_movtf)
  3190.     mov_optab->handlers[(int) TFmode].insn_code = CODE_FOR_movtf;
  3191. #endif
  3192. #ifdef HAVE_movcc
  3193.   if (HAVE_movcc)
  3194.     mov_optab->handlers[(int) CCmode].insn_code = CODE_FOR_movcc;
  3195. #endif
  3196.  
  3197. #ifdef EXTRA_CC_MODES
  3198.   init_mov_optab ();
  3199. #endif
  3200.  
  3201. #ifdef HAVE_movstrictqi
  3202.   if (HAVE_movstrictqi)
  3203.     movstrict_optab->handlers[(int) QImode].insn_code = CODE_FOR_movstrictqi;
  3204. #endif
  3205. #ifdef HAVE_movstricthi
  3206.   if (HAVE_movstricthi)
  3207.     movstrict_optab->handlers[(int) HImode].insn_code = CODE_FOR_movstricthi;
  3208. #endif
  3209. #ifdef HAVE_movstrictpsi
  3210.   if (HAVE_movstrictpsi)
  3211.     movstrict_optab->handlers[(int) PSImode].insn_code = CODE_FOR_movstrictpsi;
  3212. #endif
  3213. #ifdef HAVE_movstrictsi
  3214.   if (HAVE_movstrictsi)
  3215.     movstrict_optab->handlers[(int) SImode].insn_code = CODE_FOR_movstrictsi;
  3216. #endif
  3217. #ifdef HAVE_movstrictdi
  3218.   if (HAVE_movstrictdi)
  3219.     movstrict_optab->handlers[(int) DImode].insn_code = CODE_FOR_movstrictdi;
  3220. #endif
  3221.  
  3222. #ifdef HAVE_cmpqi
  3223.   if (HAVE_cmpqi)
  3224.     cmp_optab->handlers[(int) QImode].insn_code = CODE_FOR_cmpqi;
  3225. #endif
  3226. #ifdef HAVE_cmphi
  3227.   if (HAVE_cmphi)
  3228.     cmp_optab->handlers[(int) HImode].insn_code = CODE_FOR_cmphi;
  3229. #endif
  3230. #ifdef HAVE_cmppsi
  3231.   if (HAVE_cmppsi)
  3232.     cmp_optab->handlers[(int) PSImode].insn_code = CODE_FOR_cmppsi;
  3233. #endif
  3234. #ifdef HAVE_cmpsi
  3235.   if (HAVE_cmpsi)
  3236.     cmp_optab->handlers[(int) SImode].insn_code = CODE_FOR_cmpsi;
  3237. #endif
  3238. #ifdef HAVE_cmpdi
  3239.   if (HAVE_cmpdi)
  3240.     cmp_optab->handlers[(int) DImode].insn_code = CODE_FOR_cmpdi;
  3241. #endif
  3242. #ifdef HAVE_cmpsf
  3243.   if (HAVE_cmpsf)
  3244.     cmp_optab->handlers[(int) SFmode].insn_code = CODE_FOR_cmpsf;
  3245. #endif
  3246. #ifdef HAVE_cmpdf
  3247.   if (HAVE_cmpdf)
  3248.     cmp_optab->handlers[(int) DFmode].insn_code = CODE_FOR_cmpdf;
  3249. #endif
  3250. #ifdef HAVE_tstqi
  3251.   if (HAVE_tstqi)
  3252.     tst_optab->handlers[(int) QImode].insn_code = CODE_FOR_tstqi;
  3253. #endif
  3254. #ifdef HAVE_tsthi
  3255.   if (HAVE_tsthi)
  3256.     tst_optab->handlers[(int) HImode].insn_code = CODE_FOR_tsthi;
  3257. #endif
  3258. #ifdef HAVE_tstpsi
  3259.   if (HAVE_tstpsi)
  3260.     tst_optab->handlers[(int) PSImode].insn_code = CODE_FOR_tstpsi;
  3261. #endif
  3262. #ifdef HAVE_tstsi
  3263.   if (HAVE_tstsi)
  3264.     tst_optab->handlers[(int) SImode].insn_code = CODE_FOR_tstsi;
  3265. #endif
  3266. #ifdef HAVE_tstdi
  3267.   if (HAVE_tstdi)
  3268.     tst_optab->handlers[(int) DImode].insn_code = CODE_FOR_tstdi;
  3269. #endif
  3270. #ifdef HAVE_tstsf
  3271.   if (HAVE_tstsf)
  3272.     tst_optab->handlers[(int) SFmode].insn_code = CODE_FOR_tstsf;
  3273. #endif
  3274. #ifdef HAVE_tstdf
  3275.   if (HAVE_tstdf)
  3276.     tst_optab->handlers[(int) DFmode].insn_code = CODE_FOR_tstdf;
  3277. #endif
  3278.   /* Comparison libcalls for integers MUST come in pairs, signed/unsigned.  */
  3279.   cmp_optab->handlers[(int) DImode].libfunc
  3280.     = gen_rtx (SYMBOL_REF, Pmode, "_cmpdi2");
  3281.   ucmp_optab->handlers[(int) DImode].libfunc
  3282.     = gen_rtx (SYMBOL_REF, Pmode, "_ucmpdi2");
  3283.   cmp_optab->handlers[(int) SFmode].libfunc
  3284.     = gen_rtx (SYMBOL_REF, Pmode, "_cmpsf2");
  3285.   cmp_optab->handlers[(int) DFmode].libfunc
  3286.     = gen_rtx (SYMBOL_REF, Pmode, "_cmpdf2");
  3287.  
  3288. #ifdef HAVE_beq
  3289.   if (HAVE_beq)
  3290.     bcc_gen_fctn[(int) EQ] = gen_beq;
  3291. #endif
  3292. #ifdef HAVE_bne
  3293.   if (HAVE_bne)
  3294.     bcc_gen_fctn[(int) NE] = gen_bne;
  3295. #endif
  3296. #ifdef HAVE_bgt
  3297.   if (HAVE_bgt)
  3298.     bcc_gen_fctn[(int) GT] = gen_bgt;
  3299. #endif
  3300. #ifdef HAVE_bge
  3301.   if (HAVE_bge)
  3302.     bcc_gen_fctn[(int) GE] = gen_bge;
  3303. #endif
  3304. #ifdef HAVE_bgtu
  3305.   if (HAVE_bgtu)
  3306.     bcc_gen_fctn[(int) GTU] = gen_bgtu;
  3307. #endif
  3308. #ifdef HAVE_bgeu
  3309.   if (HAVE_bgeu)
  3310.     bcc_gen_fctn[(int) GEU] = gen_bgeu;
  3311. #endif
  3312. #ifdef HAVE_blt
  3313.   if (HAVE_blt)
  3314.     bcc_gen_fctn[(int) LT] = gen_blt;
  3315. #endif
  3316. #ifdef HAVE_ble
  3317.   if (HAVE_ble)
  3318.     bcc_gen_fctn[(int) LE] = gen_ble;
  3319. #endif
  3320. #ifdef HAVE_bltu
  3321.   if (HAVE_bltu)
  3322.     bcc_gen_fctn[(int) LTU] = gen_bltu;
  3323. #endif
  3324. #ifdef HAVE_bleu
  3325.   if (HAVE_bleu)
  3326.     bcc_gen_fctn[(int) LEU] = gen_bleu;
  3327. #endif
  3328.  
  3329.   for (i = 0; i < NUM_RTX_CODE; i++)
  3330.     setcc_gen_code[i] = CODE_FOR_nothing;
  3331.  
  3332. #ifdef HAVE_seq
  3333.   if (HAVE_seq)
  3334.     setcc_gen_code[(int) EQ] = CODE_FOR_seq;
  3335. #endif
  3336. #ifdef HAVE_sne
  3337.   if (HAVE_sne)
  3338.     setcc_gen_code[(int) NE] = CODE_FOR_sne;
  3339. #endif
  3340. #ifdef HAVE_sgt
  3341.   if (HAVE_sgt)
  3342.     setcc_gen_code[(int) GT] = CODE_FOR_sgt;
  3343. #endif
  3344. #ifdef HAVE_sge
  3345.   if (HAVE_sge)
  3346.     setcc_gen_code[(int) GE] = CODE_FOR_sge;
  3347. #endif
  3348. #ifdef HAVE_sgtu
  3349.   if (HAVE_sgtu)
  3350.     setcc_gen_code[(int) GTU] = CODE_FOR_sgtu;
  3351. #endif
  3352. #ifdef HAVE_sgeu
  3353.   if (HAVE_sgeu)
  3354.     setcc_gen_code[(int) GEU] = CODE_FOR_sgeu;
  3355. #endif
  3356. #ifdef HAVE_slt
  3357.   if (HAVE_slt)
  3358.     setcc_gen_code[(int) LT] = CODE_FOR_slt;
  3359. #endif
  3360. #ifdef HAVE_sle
  3361.   if (HAVE_sle)
  3362.     setcc_gen_code[(int) LE] = CODE_FOR_sle;
  3363. #endif
  3364. #ifdef HAVE_sltu
  3365.   if (HAVE_sltu)
  3366.     setcc_gen_code[(int) LTU] = CODE_FOR_sltu;
  3367. #endif
  3368. #ifdef HAVE_sleu
  3369.   if (HAVE_sleu)
  3370.     setcc_gen_code[(int) LEU] = CODE_FOR_sleu;
  3371. #endif
  3372.  
  3373.   extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_extendsfdf2");
  3374.   truncdfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_truncdfsf2");
  3375.   memcpy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcpy");
  3376.   bcopy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcopy");
  3377.   memcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcmp");
  3378.   bcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcmp");
  3379.   memset_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memset");
  3380.   bzero_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bzero");
  3381.   eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_eqsf2");
  3382.   nesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_nesf2");
  3383.   gtsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_gtsf2");
  3384.   gesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_gesf2");
  3385.   ltsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_ltsf2");
  3386.   lesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_lesf2");
  3387.   eqdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_eqdf2");
  3388.   nedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_nedf2");
  3389.   gtdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_gtdf2");
  3390.   gedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_gedf2");
  3391.   ltdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_ltdf2");
  3392.   ledf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "_ledf2");
  3393. }
  3394.