OSDN Git Service

* optabs.c (no_conflict_move_test): Check if a result of a
[pf3gnuchains/gcc-fork.git] / gcc / optabs.c
1 /* Expand the basic unary and binary arithmetic operations, for GNU compiler.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA.  */
21
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "toplev.h"
28
29 /* Include insn-config.h before expr.h so that HAVE_conditional_move
30    is properly defined.  */
31 #include "insn-config.h"
32 #include "rtl.h"
33 #include "tree.h"
34 #include "tm_p.h"
35 #include "flags.h"
36 #include "function.h"
37 #include "except.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "libfuncs.h"
41 #include "recog.h"
42 #include "reload.h"
43 #include "ggc.h"
44 #include "real.h"
45 #include "basic-block.h"
46 #include "target.h"
47
48 /* Each optab contains info on how this target machine
49    can perform a particular operation
50    for all sizes and kinds of operands.
51
52    The operation to be performed is often specified
53    by passing one of these optabs as an argument.
54
55    See expr.h for documentation of these optabs.  */
56
57 optab optab_table[OTI_MAX];
58
59 rtx libfunc_table[LTI_MAX];
60
61 /* Tables of patterns for converting one mode to another.  */
62 convert_optab convert_optab_table[COI_MAX];
63
64 /* Contains the optab used for each rtx code.  */
65 optab code_to_optab[NUM_RTX_CODE + 1];
66
67 /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
68    gives the gen_function to make a branch to test that condition.  */
69
70 rtxfun bcc_gen_fctn[NUM_RTX_CODE];
71
72 /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
73    gives the insn code to make a store-condition insn
74    to test that condition.  */
75
76 enum insn_code setcc_gen_code[NUM_RTX_CODE];
77
78 #ifdef HAVE_conditional_move
79 /* Indexed by the machine mode, gives the insn code to make a conditional
80    move insn.  This is not indexed by the rtx-code like bcc_gen_fctn and
81    setcc_gen_code to cut down on the number of named patterns.  Consider a day
82    when a lot more rtx codes are conditional (eg: for the ARM).  */
83
84 enum insn_code movcc_gen_code[NUM_MACHINE_MODES];
85 #endif
86
87 /* Indexed by the machine mode, gives the insn code for vector conditional
88    operation.  */
89
90 enum insn_code vcond_gen_code[NUM_MACHINE_MODES];
91 enum insn_code vcondu_gen_code[NUM_MACHINE_MODES];
92
93 /* The insn generating function can not take an rtx_code argument.
94    TRAP_RTX is used as an rtx argument.  Its code is replaced with
95    the code to be used in the trap insn and all other fields are ignored.  */
96 static GTY(()) rtx trap_rtx;
97
98 static int add_equal_note (rtx, rtx, enum rtx_code, rtx, rtx);
99 static rtx widen_operand (rtx, enum machine_mode, enum machine_mode, int,
100                           int);
101 static void prepare_cmp_insn (rtx *, rtx *, enum rtx_code *, rtx,
102                               enum machine_mode *, int *,
103                               enum can_compare_purpose);
104 static enum insn_code can_fix_p (enum machine_mode, enum machine_mode, int,
105                                  int *);
106 static enum insn_code can_float_p (enum machine_mode, enum machine_mode, int);
107 static optab new_optab (void);
108 static convert_optab new_convert_optab (void);
109 static inline optab init_optab (enum rtx_code);
110 static inline optab init_optabv (enum rtx_code);
111 static inline convert_optab init_convert_optab (enum rtx_code);
112 static void init_libfuncs (optab, int, int, const char *, int);
113 static void init_integral_libfuncs (optab, const char *, int);
114 static void init_floating_libfuncs (optab, const char *, int);
115 static void init_interclass_conv_libfuncs (convert_optab, const char *,
116                                            enum mode_class, enum mode_class);
117 static void init_intraclass_conv_libfuncs (convert_optab, const char *,
118                                            enum mode_class, bool);
119 static void emit_cmp_and_jump_insn_1 (rtx, rtx, enum machine_mode,
120                                       enum rtx_code, int, rtx);
121 static void prepare_float_lib_cmp (rtx *, rtx *, enum rtx_code *,
122                                    enum machine_mode *, int *);
123 static rtx widen_clz (enum machine_mode, rtx, rtx);
124 static rtx expand_parity (enum machine_mode, rtx, rtx);
125 static enum rtx_code get_rtx_code (enum tree_code, bool);
126 static rtx vector_compare_rtx (tree, bool, enum insn_code);
127
128 #ifndef HAVE_conditional_trap
129 #define HAVE_conditional_trap 0
130 #define gen_conditional_trap(a,b) (gcc_unreachable (), NULL_RTX)
131 #endif
132 \f
133 /* Add a REG_EQUAL note to the last insn in INSNS.  TARGET is being set to
134    the result of operation CODE applied to OP0 (and OP1 if it is a binary
135    operation).
136
137    If the last insn does not set TARGET, don't do anything, but return 1.
138
139    If a previous insn sets TARGET and TARGET is one of OP0 or OP1,
140    don't add the REG_EQUAL note but return 0.  Our caller can then try
141    again, ensuring that TARGET is not one of the operands.  */
142
143 static int
144 add_equal_note (rtx insns, rtx target, enum rtx_code code, rtx op0, rtx op1)
145 {
146   rtx last_insn, insn, set;
147   rtx note;
148
149   gcc_assert (insns && INSN_P (insns) && NEXT_INSN (insns));
150
151   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH
152       && GET_RTX_CLASS (code) != RTX_BIN_ARITH
153       && GET_RTX_CLASS (code) != RTX_COMM_COMPARE
154       && GET_RTX_CLASS (code) != RTX_COMPARE
155       && GET_RTX_CLASS (code) != RTX_UNARY)
156     return 1;
157
158   if (GET_CODE (target) == ZERO_EXTRACT)
159     return 1;
160
161   for (last_insn = insns;
162        NEXT_INSN (last_insn) != NULL_RTX;
163        last_insn = NEXT_INSN (last_insn))
164     ;
165
166   set = single_set (last_insn);
167   if (set == NULL_RTX)
168     return 1;
169
170   if (! rtx_equal_p (SET_DEST (set), target)
171       /* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside it.  */
172       && (GET_CODE (SET_DEST (set)) != STRICT_LOW_PART
173           || ! rtx_equal_p (XEXP (SET_DEST (set), 0), target)))
174     return 1;
175
176   /* If TARGET is in OP0 or OP1, check if anything in SEQ sets TARGET
177      besides the last insn.  */
178   if (reg_overlap_mentioned_p (target, op0)
179       || (op1 && reg_overlap_mentioned_p (target, op1)))
180     {
181       insn = PREV_INSN (last_insn);
182       while (insn != NULL_RTX)
183         {
184           if (reg_set_p (target, insn))
185             return 0;
186
187           insn = PREV_INSN (insn);
188         }
189     }
190
191   if (GET_RTX_CLASS (code) == RTX_UNARY)
192     note = gen_rtx_fmt_e (code, GET_MODE (target), copy_rtx (op0));
193   else
194     note = gen_rtx_fmt_ee (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
195
196   set_unique_reg_note (last_insn, REG_EQUAL, note);
197
198   return 1;
199 }
200 \f
201 /* Widen OP to MODE and return the rtx for the widened operand.  UNSIGNEDP
202    says whether OP is signed or unsigned.  NO_EXTEND is nonzero if we need
203    not actually do a sign-extend or zero-extend, but can leave the
204    higher-order bits of the result rtx undefined, for example, in the case
205    of logical operations, but not right shifts.  */
206
207 static rtx
208 widen_operand (rtx op, enum machine_mode mode, enum machine_mode oldmode,
209                int unsignedp, int no_extend)
210 {
211   rtx result;
212
213   /* If we don't have to extend and this is a constant, return it.  */
214   if (no_extend && GET_MODE (op) == VOIDmode)
215     return op;
216
217   /* If we must extend do so.  If OP is a SUBREG for a promoted object, also
218      extend since it will be more efficient to do so unless the signedness of
219      a promoted object differs from our extension.  */
220   if (! no_extend
221       || (GET_CODE (op) == SUBREG && SUBREG_PROMOTED_VAR_P (op)
222           && SUBREG_PROMOTED_UNSIGNED_P (op) == unsignedp))
223     return convert_modes (mode, oldmode, op, unsignedp);
224
225   /* If MODE is no wider than a single word, we return a paradoxical
226      SUBREG.  */
227   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
228     return gen_rtx_SUBREG (mode, force_reg (GET_MODE (op), op), 0);
229
230   /* Otherwise, get an object of MODE, clobber it, and set the low-order
231      part to OP.  */
232
233   result = gen_reg_rtx (mode);
234   emit_insn (gen_rtx_CLOBBER (VOIDmode, result));
235   emit_move_insn (gen_lowpart (GET_MODE (op), result), op);
236   return result;
237 }
238 \f
239 /* Return the optab used for computing the operation given by
240    the tree code, CODE.  This function is not always usable (for
241    example, it cannot give complete results for multiplication
242    or division) but probably ought to be relied on more widely
243    throughout the expander.  */
244 optab
245 optab_for_tree_code (enum tree_code code, tree type)
246 {
247   bool trapv;
248   switch (code)
249     {
250     case BIT_AND_EXPR:
251       return and_optab;
252
253     case BIT_IOR_EXPR:
254       return ior_optab;
255
256     case BIT_NOT_EXPR:
257       return one_cmpl_optab;
258
259     case BIT_XOR_EXPR:
260       return xor_optab;
261
262     case TRUNC_MOD_EXPR:
263     case CEIL_MOD_EXPR:
264     case FLOOR_MOD_EXPR:
265     case ROUND_MOD_EXPR:
266       return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
267
268     case RDIV_EXPR:
269     case TRUNC_DIV_EXPR:
270     case CEIL_DIV_EXPR:
271     case FLOOR_DIV_EXPR:
272     case ROUND_DIV_EXPR:
273     case EXACT_DIV_EXPR:
274       return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
275
276     case LSHIFT_EXPR:
277       return ashl_optab;
278
279     case RSHIFT_EXPR:
280       return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
281
282     case LROTATE_EXPR:
283       return rotl_optab;
284
285     case RROTATE_EXPR:
286       return rotr_optab;
287
288     case MAX_EXPR:
289       return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
290
291     case MIN_EXPR:
292       return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
293
294     case REALIGN_LOAD_EXPR:
295       return vec_realign_load_optab;
296
297     case REDUC_MAX_EXPR:
298       return TYPE_UNSIGNED (type) ? reduc_umax_optab : reduc_smax_optab;
299
300     case REDUC_MIN_EXPR:
301       return TYPE_UNSIGNED (type) ? reduc_umin_optab : reduc_smin_optab;
302
303     case REDUC_PLUS_EXPR:
304       return TYPE_UNSIGNED (type) ? reduc_uplus_optab : reduc_splus_optab;
305
306     case VEC_LSHIFT_EXPR:
307       return vec_shl_optab;
308
309     case VEC_RSHIFT_EXPR:
310       return vec_shr_optab;
311
312     default:
313       break;
314     }
315
316   trapv = flag_trapv && INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type);
317   switch (code)
318     {
319     case PLUS_EXPR:
320       return trapv ? addv_optab : add_optab;
321
322     case MINUS_EXPR:
323       return trapv ? subv_optab : sub_optab;
324
325     case MULT_EXPR:
326       return trapv ? smulv_optab : smul_optab;
327
328     case NEGATE_EXPR:
329       return trapv ? negv_optab : neg_optab;
330
331     case ABS_EXPR:
332       return trapv ? absv_optab : abs_optab;
333
334     default:
335       return NULL;
336     }
337 }
338 \f
339
340 /* Generate code to perform an operation specified by TERNARY_OPTAB
341    on operands OP0, OP1 and OP2, with result having machine-mode MODE.
342
343    UNSIGNEDP is for the case where we have to widen the operands
344    to perform the operation.  It says to use zero-extension.
345
346    If TARGET is nonzero, the value
347    is generated there, if it is convenient to do so.
348    In all cases an rtx is returned for the locus of the value;
349    this may or may not be TARGET.  */
350
351 rtx
352 expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
353                    rtx op1, rtx op2, rtx target, int unsignedp)
354 {
355   int icode = (int) ternary_optab->handlers[(int) mode].insn_code;
356   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
357   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
358   enum machine_mode mode2 = insn_data[icode].operand[3].mode;
359   rtx temp;
360   rtx pat;
361   rtx xop0 = op0, xop1 = op1, xop2 = op2;
362
363   gcc_assert (ternary_optab->handlers[(int) mode].insn_code
364               != CODE_FOR_nothing);
365
366   if (!target || !insn_data[icode].operand[0].predicate (target, mode))
367     temp = gen_reg_rtx (mode);
368   else
369     temp = target;
370
371   /* In case the insn wants input operands in modes different from
372      those of the actual operands, convert the operands.  It would
373      seem that we don't need to convert CONST_INTs, but we do, so
374      that they're properly zero-extended, sign-extended or truncated
375      for their mode.  */
376
377   if (GET_MODE (op0) != mode0 && mode0 != VOIDmode)
378     xop0 = convert_modes (mode0,
379                           GET_MODE (op0) != VOIDmode
380                           ? GET_MODE (op0)
381                           : mode,
382                           xop0, unsignedp);
383
384   if (GET_MODE (op1) != mode1 && mode1 != VOIDmode)
385     xop1 = convert_modes (mode1,
386                           GET_MODE (op1) != VOIDmode
387                           ? GET_MODE (op1)
388                           : mode,
389                           xop1, unsignedp);
390
391   if (GET_MODE (op2) != mode2 && mode2 != VOIDmode)
392     xop2 = convert_modes (mode2,
393                           GET_MODE (op2) != VOIDmode
394                           ? GET_MODE (op2)
395                           : mode,
396                           xop2, unsignedp);
397
398   /* Now, if insn's predicates don't allow our operands, put them into
399      pseudo regs.  */
400
401   if (!insn_data[icode].operand[1].predicate (xop0, mode0)
402       && mode0 != VOIDmode)
403     xop0 = copy_to_mode_reg (mode0, xop0);
404
405   if (!insn_data[icode].operand[2].predicate (xop1, mode1)
406       && mode1 != VOIDmode)
407     xop1 = copy_to_mode_reg (mode1, xop1);
408
409   if (!insn_data[icode].operand[3].predicate (xop2, mode2)
410       && mode2 != VOIDmode)
411     xop2 = copy_to_mode_reg (mode2, xop2);
412
413   pat = GEN_FCN (icode) (temp, xop0, xop1, xop2);
414
415   emit_insn (pat);
416   return temp;
417 }
418
419
420 /* Like expand_binop, but return a constant rtx if the result can be
421    calculated at compile time.  The arguments and return value are
422    otherwise the same as for expand_binop.  */
423
424 static rtx
425 simplify_expand_binop (enum machine_mode mode, optab binoptab,
426                        rtx op0, rtx op1, rtx target, int unsignedp,
427                        enum optab_methods methods)
428 {
429   if (CONSTANT_P (op0) && CONSTANT_P (op1))
430     return simplify_gen_binary (binoptab->code, mode, op0, op1);
431   else
432     return expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods);
433 }
434
435 /* Like simplify_expand_binop, but always put the result in TARGET.
436    Return true if the expansion succeeded.  */
437
438 bool
439 force_expand_binop (enum machine_mode mode, optab binoptab,
440                     rtx op0, rtx op1, rtx target, int unsignedp,
441                     enum optab_methods methods)
442 {
443   rtx x = simplify_expand_binop (mode, binoptab, op0, op1,
444                                  target, unsignedp, methods);
445   if (x == 0)
446     return false;
447   if (x != target)
448     emit_move_insn (target, x);
449   return true;
450 }
451
452 /* Generate insns for VEC_LSHIFT_EXPR, VEC_RSHIFT_EXPR.  */
453
454 rtx
455 expand_vec_shift_expr (tree vec_shift_expr, rtx target)
456 {
457   enum insn_code icode;
458   rtx rtx_op1, rtx_op2;
459   enum machine_mode mode1;
460   enum machine_mode mode2;
461   enum machine_mode mode = TYPE_MODE (TREE_TYPE (vec_shift_expr));
462   tree vec_oprnd = TREE_OPERAND (vec_shift_expr, 0);
463   tree shift_oprnd = TREE_OPERAND (vec_shift_expr, 1);
464   optab shift_optab;
465   rtx pat;
466
467   switch (TREE_CODE (vec_shift_expr))
468     {
469       case VEC_RSHIFT_EXPR:
470         shift_optab = vec_shr_optab;
471         break;
472       case VEC_LSHIFT_EXPR:
473         shift_optab = vec_shl_optab;
474         break;
475       default:
476         gcc_unreachable ();
477     }
478
479   icode = (int) shift_optab->handlers[(int) mode].insn_code;
480   gcc_assert (icode != CODE_FOR_nothing);
481
482   mode1 = insn_data[icode].operand[1].mode;
483   mode2 = insn_data[icode].operand[2].mode;
484
485   rtx_op1 = expand_expr (vec_oprnd, NULL_RTX, VOIDmode, EXPAND_NORMAL);
486   if (!(*insn_data[icode].operand[1].predicate) (rtx_op1, mode1)
487       && mode1 != VOIDmode)
488     rtx_op1 = force_reg (mode1, rtx_op1);
489
490   rtx_op2 = expand_expr (shift_oprnd, NULL_RTX, VOIDmode, EXPAND_NORMAL);
491   if (!(*insn_data[icode].operand[2].predicate) (rtx_op2, mode2)
492       && mode2 != VOIDmode)
493     rtx_op2 = force_reg (mode2, rtx_op2);
494
495   if (!target
496       || ! (*insn_data[icode].operand[0].predicate) (target, mode))
497     target = gen_reg_rtx (mode);
498
499   /* Emit instruction */
500   pat = GEN_FCN (icode) (target, rtx_op1, rtx_op2);
501   gcc_assert (pat);
502   emit_insn (pat);
503
504   return target;
505 }
506
507 /* This subroutine of expand_doubleword_shift handles the cases in which
508    the effective shift value is >= BITS_PER_WORD.  The arguments and return
509    value are the same as for the parent routine, except that SUPERWORD_OP1
510    is the shift count to use when shifting OUTOF_INPUT into INTO_TARGET.
511    INTO_TARGET may be null if the caller has decided to calculate it.  */
512
513 static bool
514 expand_superword_shift (optab binoptab, rtx outof_input, rtx superword_op1,
515                         rtx outof_target, rtx into_target,
516                         int unsignedp, enum optab_methods methods)
517 {
518   if (into_target != 0)
519     if (!force_expand_binop (word_mode, binoptab, outof_input, superword_op1,
520                              into_target, unsignedp, methods))
521       return false;
522
523   if (outof_target != 0)
524     {
525       /* For a signed right shift, we must fill OUTOF_TARGET with copies
526          of the sign bit, otherwise we must fill it with zeros.  */
527       if (binoptab != ashr_optab)
528         emit_move_insn (outof_target, CONST0_RTX (word_mode));
529       else
530         if (!force_expand_binop (word_mode, binoptab,
531                                  outof_input, GEN_INT (BITS_PER_WORD - 1),
532                                  outof_target, unsignedp, methods))
533           return false;
534     }
535   return true;
536 }
537
538 /* This subroutine of expand_doubleword_shift handles the cases in which
539    the effective shift value is < BITS_PER_WORD.  The arguments and return
540    value are the same as for the parent routine.  */
541
542 static bool
543 expand_subword_shift (enum machine_mode op1_mode, optab binoptab,
544                       rtx outof_input, rtx into_input, rtx op1,
545                       rtx outof_target, rtx into_target,
546                       int unsignedp, enum optab_methods methods,
547                       unsigned HOST_WIDE_INT shift_mask)
548 {
549   optab reverse_unsigned_shift, unsigned_shift;
550   rtx tmp, carries;
551
552   reverse_unsigned_shift = (binoptab == ashl_optab ? lshr_optab : ashl_optab);
553   unsigned_shift = (binoptab == ashl_optab ? ashl_optab : lshr_optab);
554
555   /* The low OP1 bits of INTO_TARGET come from the high bits of OUTOF_INPUT.
556      We therefore need to shift OUTOF_INPUT by (BITS_PER_WORD - OP1) bits in
557      the opposite direction to BINOPTAB.  */
558   if (CONSTANT_P (op1) || shift_mask >= BITS_PER_WORD)
559     {
560       carries = outof_input;
561       tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
562       tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
563                                    0, true, methods);
564     }
565   else
566     {
567       /* We must avoid shifting by BITS_PER_WORD bits since that is either
568          the same as a zero shift (if shift_mask == BITS_PER_WORD - 1) or
569          has unknown behavior.  Do a single shift first, then shift by the
570          remainder.  It's OK to use ~OP1 as the remainder if shift counts
571          are truncated to the mode size.  */
572       carries = expand_binop (word_mode, reverse_unsigned_shift,
573                               outof_input, const1_rtx, 0, unsignedp, methods);
574       if (shift_mask == BITS_PER_WORD - 1)
575         {
576           tmp = immed_double_const (-1, -1, op1_mode);
577           tmp = simplify_expand_binop (op1_mode, xor_optab, op1, tmp,
578                                        0, true, methods);
579         }
580       else
581         {
582           tmp = immed_double_const (BITS_PER_WORD - 1, 0, op1_mode);
583           tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
584                                        0, true, methods);
585         }
586     }
587   if (tmp == 0 || carries == 0)
588     return false;
589   carries = expand_binop (word_mode, reverse_unsigned_shift,
590                           carries, tmp, 0, unsignedp, methods);
591   if (carries == 0)
592     return false;
593
594   /* Shift INTO_INPUT logically by OP1.  This is the last use of INTO_INPUT
595      so the result can go directly into INTO_TARGET if convenient.  */
596   tmp = expand_binop (word_mode, unsigned_shift, into_input, op1,
597                       into_target, unsignedp, methods);
598   if (tmp == 0)
599     return false;
600
601   /* Now OR in the bits carried over from OUTOF_INPUT.  */
602   if (!force_expand_binop (word_mode, ior_optab, tmp, carries,
603                            into_target, unsignedp, methods))
604     return false;
605
606   /* Use a standard word_mode shift for the out-of half.  */
607   if (outof_target != 0)
608     if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
609                              outof_target, unsignedp, methods))
610       return false;
611
612   return true;
613 }
614
615
616 #ifdef HAVE_conditional_move
617 /* Try implementing expand_doubleword_shift using conditional moves.
618    The shift is by < BITS_PER_WORD if (CMP_CODE CMP1 CMP2) is true,
619    otherwise it is by >= BITS_PER_WORD.  SUBWORD_OP1 and SUPERWORD_OP1
620    are the shift counts to use in the former and latter case.  All other
621    arguments are the same as the parent routine.  */
622
623 static bool
624 expand_doubleword_shift_condmove (enum machine_mode op1_mode, optab binoptab,
625                                   enum rtx_code cmp_code, rtx cmp1, rtx cmp2,
626                                   rtx outof_input, rtx into_input,
627                                   rtx subword_op1, rtx superword_op1,
628                                   rtx outof_target, rtx into_target,
629                                   int unsignedp, enum optab_methods methods,
630                                   unsigned HOST_WIDE_INT shift_mask)
631 {
632   rtx outof_superword, into_superword;
633
634   /* Put the superword version of the output into OUTOF_SUPERWORD and
635      INTO_SUPERWORD.  */
636   outof_superword = outof_target != 0 ? gen_reg_rtx (word_mode) : 0;
637   if (outof_target != 0 && subword_op1 == superword_op1)
638     {
639       /* The value INTO_TARGET >> SUBWORD_OP1, which we later store in
640          OUTOF_TARGET, is the same as the value of INTO_SUPERWORD.  */
641       into_superword = outof_target;
642       if (!expand_superword_shift (binoptab, outof_input, superword_op1,
643                                    outof_superword, 0, unsignedp, methods))
644         return false;
645     }
646   else
647     {
648       into_superword = gen_reg_rtx (word_mode);
649       if (!expand_superword_shift (binoptab, outof_input, superword_op1,
650                                    outof_superword, into_superword,
651                                    unsignedp, methods))
652         return false;
653     }
654
655   /* Put the subword version directly in OUTOF_TARGET and INTO_TARGET.  */
656   if (!expand_subword_shift (op1_mode, binoptab,
657                              outof_input, into_input, subword_op1,
658                              outof_target, into_target,
659                              unsignedp, methods, shift_mask))
660     return false;
661
662   /* Select between them.  Do the INTO half first because INTO_SUPERWORD
663      might be the current value of OUTOF_TARGET.  */
664   if (!emit_conditional_move (into_target, cmp_code, cmp1, cmp2, op1_mode,
665                               into_target, into_superword, word_mode, false))
666     return false;
667
668   if (outof_target != 0)
669     if (!emit_conditional_move (outof_target, cmp_code, cmp1, cmp2, op1_mode,
670                                 outof_target, outof_superword,
671                                 word_mode, false))
672       return false;
673
674   return true;
675 }
676 #endif
677
678 /* Expand a doubleword shift (ashl, ashr or lshr) using word-mode shifts.
679    OUTOF_INPUT and INTO_INPUT are the two word-sized halves of the first
680    input operand; the shift moves bits in the direction OUTOF_INPUT->
681    INTO_TARGET.  OUTOF_TARGET and INTO_TARGET are the equivalent words
682    of the target.  OP1 is the shift count and OP1_MODE is its mode.
683    If OP1 is constant, it will have been truncated as appropriate
684    and is known to be nonzero.
685
686    If SHIFT_MASK is zero, the result of word shifts is undefined when the
687    shift count is outside the range [0, BITS_PER_WORD).  This routine must
688    avoid generating such shifts for OP1s in the range [0, BITS_PER_WORD * 2).
689
690    If SHIFT_MASK is nonzero, all word-mode shift counts are effectively
691    masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
692    fill with zeros or sign bits as appropriate.
693
694    If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
695    a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
696    Doing this preserves semantics required by SHIFT_COUNT_TRUNCATED.
697    In all other cases, shifts by values outside [0, BITS_PER_UNIT * 2)
698    are undefined.
699
700    BINOPTAB, UNSIGNEDP and METHODS are as for expand_binop.  This function
701    may not use INTO_INPUT after modifying INTO_TARGET, and similarly for
702    OUTOF_INPUT and OUTOF_TARGET.  OUTOF_TARGET can be null if the parent
703    function wants to calculate it itself.
704
705    Return true if the shift could be successfully synthesized.  */
706
707 static bool
708 expand_doubleword_shift (enum machine_mode op1_mode, optab binoptab,
709                          rtx outof_input, rtx into_input, rtx op1,
710                          rtx outof_target, rtx into_target,
711                          int unsignedp, enum optab_methods methods,
712                          unsigned HOST_WIDE_INT shift_mask)
713 {
714   rtx superword_op1, tmp, cmp1, cmp2;
715   rtx subword_label, done_label;
716   enum rtx_code cmp_code;
717
718   /* See if word-mode shifts by BITS_PER_WORD...BITS_PER_WORD * 2 - 1 will
719      fill the result with sign or zero bits as appropriate.  If so, the value
720      of OUTOF_TARGET will always be (SHIFT OUTOF_INPUT OP1).   Recursively call
721      this routine to calculate INTO_TARGET (which depends on both OUTOF_INPUT
722      and INTO_INPUT), then emit code to set up OUTOF_TARGET.
723
724      This isn't worthwhile for constant shifts since the optimizers will
725      cope better with in-range shift counts.  */
726   if (shift_mask >= BITS_PER_WORD
727       && outof_target != 0
728       && !CONSTANT_P (op1))
729     {
730       if (!expand_doubleword_shift (op1_mode, binoptab,
731                                     outof_input, into_input, op1,
732                                     0, into_target,
733                                     unsignedp, methods, shift_mask))
734         return false;
735       if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
736                                outof_target, unsignedp, methods))
737         return false;
738       return true;
739     }
740
741   /* Set CMP_CODE, CMP1 and CMP2 so that the rtx (CMP_CODE CMP1 CMP2)
742      is true when the effective shift value is less than BITS_PER_WORD.
743      Set SUPERWORD_OP1 to the shift count that should be used to shift
744      OUTOF_INPUT into INTO_TARGET when the condition is false.  */
745   tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
746   if (!CONSTANT_P (op1) && shift_mask == BITS_PER_WORD - 1)
747     {
748       /* Set CMP1 to OP1 & BITS_PER_WORD.  The result is zero iff OP1
749          is a subword shift count.  */
750       cmp1 = simplify_expand_binop (op1_mode, and_optab, op1, tmp,
751                                     0, true, methods);
752       cmp2 = CONST0_RTX (op1_mode);
753       cmp_code = EQ;
754       superword_op1 = op1;
755     }
756   else
757     {
758       /* Set CMP1 to OP1 - BITS_PER_WORD.  */
759       cmp1 = simplify_expand_binop (op1_mode, sub_optab, op1, tmp,
760                                     0, true, methods);
761       cmp2 = CONST0_RTX (op1_mode);
762       cmp_code = LT;
763       superword_op1 = cmp1;
764     }
765   if (cmp1 == 0)
766     return false;
767
768   /* If we can compute the condition at compile time, pick the
769      appropriate subroutine.  */
770   tmp = simplify_relational_operation (cmp_code, SImode, op1_mode, cmp1, cmp2);
771   if (tmp != 0 && GET_CODE (tmp) == CONST_INT)
772     {
773       if (tmp == const0_rtx)
774         return expand_superword_shift (binoptab, outof_input, superword_op1,
775                                        outof_target, into_target,
776                                        unsignedp, methods);
777       else
778         return expand_subword_shift (op1_mode, binoptab,
779                                      outof_input, into_input, op1,
780                                      outof_target, into_target,
781                                      unsignedp, methods, shift_mask);
782     }
783
784 #ifdef HAVE_conditional_move
785   /* Try using conditional moves to generate straight-line code.  */
786   {
787     rtx start = get_last_insn ();
788     if (expand_doubleword_shift_condmove (op1_mode, binoptab,
789                                           cmp_code, cmp1, cmp2,
790                                           outof_input, into_input,
791                                           op1, superword_op1,
792                                           outof_target, into_target,
793                                           unsignedp, methods, shift_mask))
794       return true;
795     delete_insns_since (start);
796   }
797 #endif
798
799   /* As a last resort, use branches to select the correct alternative.  */
800   subword_label = gen_label_rtx ();
801   done_label = gen_label_rtx ();
802
803   do_compare_rtx_and_jump (cmp1, cmp2, cmp_code, false, op1_mode,
804                            0, 0, subword_label);
805
806   if (!expand_superword_shift (binoptab, outof_input, superword_op1,
807                                outof_target, into_target,
808                                unsignedp, methods))
809     return false;
810
811   emit_jump_insn (gen_jump (done_label));
812   emit_barrier ();
813   emit_label (subword_label);
814
815   if (!expand_subword_shift (op1_mode, binoptab,
816                              outof_input, into_input, op1,
817                              outof_target, into_target,
818                              unsignedp, methods, shift_mask))
819     return false;
820
821   emit_label (done_label);
822   return true;
823 }
824 \f
825 /* Subroutine of expand_binop.  Perform a double word multiplication of
826    operands OP0 and OP1 both of mode MODE, which is exactly twice as wide
827    as the target's word_mode.  This function return NULL_RTX if anything
828    goes wrong, in which case it may have already emitted instructions
829    which need to be deleted.
830
831    If we want to multiply two two-word values and have normal and widening
832    multiplies of single-word values, we can do this with three smaller
833    multiplications.  Note that we do not make a REG_NO_CONFLICT block here
834    because we are not operating on one word at a time.
835
836    The multiplication proceeds as follows:
837                                  _______________________
838                                 [__op0_high_|__op0_low__]
839                                  _______________________
840         *                       [__op1_high_|__op1_low__]
841         _______________________________________________
842                                  _______________________
843     (1)                         [__op0_low__*__op1_low__]
844                      _______________________
845     (2a)            [__op0_low__*__op1_high_]
846                      _______________________
847     (2b)            [__op0_high_*__op1_low__]
848          _______________________
849     (3) [__op0_high_*__op1_high_]
850
851
852   This gives a 4-word result.  Since we are only interested in the
853   lower 2 words, partial result (3) and the upper words of (2a) and
854   (2b) don't need to be calculated.  Hence (2a) and (2b) can be
855   calculated using non-widening multiplication.
856
857   (1), however, needs to be calculated with an unsigned widening
858   multiplication.  If this operation is not directly supported we
859   try using a signed widening multiplication and adjust the result.
860   This adjustment works as follows:
861
862       If both operands are positive then no adjustment is needed.
863
864       If the operands have different signs, for example op0_low < 0 and
865       op1_low >= 0, the instruction treats the most significant bit of
866       op0_low as a sign bit instead of a bit with significance
867       2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
868       with 2**BITS_PER_WORD - op0_low, and two's complements the
869       result.  Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
870       the result.
871
872       Similarly, if both operands are negative, we need to add
873       (op0_low + op1_low) * 2**BITS_PER_WORD.
874
875       We use a trick to adjust quickly.  We logically shift op0_low right
876       (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
877       op0_high (op1_high) before it is used to calculate 2b (2a).  If no
878       logical shift exists, we do an arithmetic right shift and subtract
879       the 0 or -1.  */
880
881 static rtx
882 expand_doubleword_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
883                        bool umulp, enum optab_methods methods)
884 {
885   int low = (WORDS_BIG_ENDIAN ? 1 : 0);
886   int high = (WORDS_BIG_ENDIAN ? 0 : 1);
887   rtx wordm1 = umulp ? NULL_RTX : GEN_INT (BITS_PER_WORD - 1);
888   rtx product, adjust, product_high, temp;
889
890   rtx op0_high = operand_subword_force (op0, high, mode);
891   rtx op0_low = operand_subword_force (op0, low, mode);
892   rtx op1_high = operand_subword_force (op1, high, mode);
893   rtx op1_low = operand_subword_force (op1, low, mode);
894
895   /* If we're using an unsigned multiply to directly compute the product
896      of the low-order words of the operands and perform any required
897      adjustments of the operands, we begin by trying two more multiplications
898      and then computing the appropriate sum.
899
900      We have checked above that the required addition is provided.
901      Full-word addition will normally always succeed, especially if
902      it is provided at all, so we don't worry about its failure.  The
903      multiplication may well fail, however, so we do handle that.  */
904
905   if (!umulp)
906     {
907       /* ??? This could be done with emit_store_flag where available.  */
908       temp = expand_binop (word_mode, lshr_optab, op0_low, wordm1,
909                            NULL_RTX, 1, methods);
910       if (temp)
911         op0_high = expand_binop (word_mode, add_optab, op0_high, temp,
912                                  NULL_RTX, 0, OPTAB_DIRECT);
913       else
914         {
915           temp = expand_binop (word_mode, ashr_optab, op0_low, wordm1,
916                                NULL_RTX, 0, methods);
917           if (!temp)
918             return NULL_RTX;
919           op0_high = expand_binop (word_mode, sub_optab, op0_high, temp,
920                                    NULL_RTX, 0, OPTAB_DIRECT);
921         }
922
923       if (!op0_high)
924         return NULL_RTX;
925     }
926
927   adjust = expand_binop (word_mode, smul_optab, op0_high, op1_low,
928                          NULL_RTX, 0, OPTAB_DIRECT);
929   if (!adjust)
930     return NULL_RTX;
931
932   /* OP0_HIGH should now be dead.  */
933
934   if (!umulp)
935     {
936       /* ??? This could be done with emit_store_flag where available.  */
937       temp = expand_binop (word_mode, lshr_optab, op1_low, wordm1,
938                            NULL_RTX, 1, methods);
939       if (temp)
940         op1_high = expand_binop (word_mode, add_optab, op1_high, temp,
941                                  NULL_RTX, 0, OPTAB_DIRECT);
942       else
943         {
944           temp = expand_binop (word_mode, ashr_optab, op1_low, wordm1,
945                                NULL_RTX, 0, methods);
946           if (!temp)
947             return NULL_RTX;
948           op1_high = expand_binop (word_mode, sub_optab, op1_high, temp,
949                                    NULL_RTX, 0, OPTAB_DIRECT);
950         }
951
952       if (!op1_high)
953         return NULL_RTX;
954     }
955
956   temp = expand_binop (word_mode, smul_optab, op1_high, op0_low,
957                        NULL_RTX, 0, OPTAB_DIRECT);
958   if (!temp)
959     return NULL_RTX;
960
961   /* OP1_HIGH should now be dead.  */
962
963   adjust = expand_binop (word_mode, add_optab, adjust, temp,
964                          adjust, 0, OPTAB_DIRECT);
965
966   if (target && !REG_P (target))
967     target = NULL_RTX;
968
969   if (umulp)
970     product = expand_binop (mode, umul_widen_optab, op0_low, op1_low,
971                             target, 1, OPTAB_DIRECT);
972   else
973     product = expand_binop (mode, smul_widen_optab, op0_low, op1_low,
974                             target, 1, OPTAB_DIRECT);
975
976   if (!product)
977     return NULL_RTX;
978
979   product_high = operand_subword (product, high, 1, mode);
980   adjust = expand_binop (word_mode, add_optab, product_high, adjust,
981                          REG_P (product_high) ? product_high : adjust,
982                          0, OPTAB_DIRECT);
983   emit_move_insn (product_high, adjust);
984   return product;
985 }
986 \f
987 /* Wrapper around expand_binop which takes an rtx code to specify
988    the operation to perform, not an optab pointer.  All other
989    arguments are the same.  */
990 rtx
991 expand_simple_binop (enum machine_mode mode, enum rtx_code code, rtx op0,
992                      rtx op1, rtx target, int unsignedp,
993                      enum optab_methods methods)
994 {
995   optab binop = code_to_optab[(int) code];
996   gcc_assert (binop);
997
998   return expand_binop (mode, binop, op0, op1, target, unsignedp, methods);
999 }
1000
1001
1002 /* Return whether OP0 and OP1 should be swapped when expanding a commutative
1003    binop.  Order them according to commutative_operand_precedence and, if
1004    possible, try to put TARGET first.  */
1005 static bool
1006 swap_commutative_operands_with_target (rtx target, rtx op0, rtx op1)
1007 {
1008   int op0_prec = commutative_operand_precedence (op0);
1009   int op1_prec = commutative_operand_precedence (op1);
1010
1011   if (op0_prec < op1_prec)
1012     return true;
1013
1014   if (op0_prec > op1_prec)
1015     return false;
1016
1017   /* With equal precedence, both orders are ok, but try to put the
1018      target first.  */
1019   return target && rtx_equal_p (op1, target);
1020 }
1021
1022
1023 /* Generate code to perform an operation specified by BINOPTAB
1024    on operands OP0 and OP1, with result having machine-mode MODE.
1025
1026    UNSIGNEDP is for the case where we have to widen the operands
1027    to perform the operation.  It says to use zero-extension.
1028
1029    If TARGET is nonzero, the value
1030    is generated there, if it is convenient to do so.
1031    In all cases an rtx is returned for the locus of the value;
1032    this may or may not be TARGET.  */
1033
1034 rtx
1035 expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
1036               rtx target, int unsignedp, enum optab_methods methods)
1037 {
1038   enum optab_methods next_methods
1039     = (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN
1040        ? OPTAB_WIDEN : methods);
1041   enum mode_class class;
1042   enum machine_mode wider_mode;
1043   rtx temp;
1044   int commutative_op = 0;
1045   int shift_op = (binoptab->code == ASHIFT
1046                   || binoptab->code == ASHIFTRT
1047                   || binoptab->code == LSHIFTRT
1048                   || binoptab->code == ROTATE
1049                   || binoptab->code == ROTATERT);
1050   rtx entry_last = get_last_insn ();
1051   rtx last;
1052
1053   class = GET_MODE_CLASS (mode);
1054
1055   /* If subtracting an integer constant, convert this into an addition of
1056      the negated constant.  */
1057
1058   if (binoptab == sub_optab && GET_CODE (op1) == CONST_INT)
1059     {
1060       op1 = negate_rtx (mode, op1);
1061       binoptab = add_optab;
1062     }
1063
1064   /* If we are inside an appropriately-short loop and we are optimizing,
1065      force expensive constants into a register.  */
1066   if (CONSTANT_P (op0) && optimize
1067       && rtx_cost (op0, binoptab->code) > COSTS_N_INSNS (1))
1068     {
1069       if (GET_MODE (op0) != VOIDmode)
1070         op0 = convert_modes (mode, VOIDmode, op0, unsignedp);
1071       op0 = force_reg (mode, op0);
1072     }
1073
1074   if (CONSTANT_P (op1) && optimize
1075       && ! shift_op && rtx_cost (op1, binoptab->code) > COSTS_N_INSNS (1))
1076     {
1077       if (GET_MODE (op1) != VOIDmode)
1078         op1 = convert_modes (mode, VOIDmode, op1, unsignedp);
1079       op1 = force_reg (mode, op1);
1080     }
1081
1082   /* Record where to delete back to if we backtrack.  */
1083   last = get_last_insn ();
1084
1085   /* If operation is commutative, canonicalize the order of the operands.  */
1086   if (GET_RTX_CLASS (binoptab->code) == RTX_COMM_ARITH
1087       || binoptab == smul_widen_optab
1088       || binoptab == umul_widen_optab
1089       || binoptab == smul_highpart_optab
1090       || binoptab == umul_highpart_optab)
1091     {
1092       commutative_op = 1;
1093       if (swap_commutative_operands_with_target (target, op0, op1))
1094         {
1095           temp = op1;
1096           op1 = op0;
1097           op0 = temp;
1098         }
1099     }
1100
1101   /* If we can do it with a three-operand insn, do so.  */
1102
1103   if (methods != OPTAB_MUST_WIDEN
1104       && binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1105     {
1106       int icode = (int) binoptab->handlers[(int) mode].insn_code;
1107       enum machine_mode mode0 = insn_data[icode].operand[1].mode;
1108       enum machine_mode mode1 = insn_data[icode].operand[2].mode;
1109       rtx pat;
1110       rtx xop0 = op0, xop1 = op1;
1111
1112       if (target)
1113         temp = target;
1114       else
1115         temp = gen_reg_rtx (mode);
1116
1117       /* If it is a commutative operator and the modes would match
1118          if we would swap the operands, we can save the conversions.  */
1119       if (commutative_op)
1120         {
1121           if (GET_MODE (op0) != mode0 && GET_MODE (op1) != mode1
1122               && GET_MODE (op0) == mode1 && GET_MODE (op1) == mode0)
1123             {
1124               rtx tmp;
1125
1126               tmp = op0; op0 = op1; op1 = tmp;
1127               tmp = xop0; xop0 = xop1; xop1 = tmp;
1128             }
1129         }
1130
1131       /* In case the insn wants input operands in modes different from
1132          those of the actual operands, convert the operands.  It would
1133          seem that we don't need to convert CONST_INTs, but we do, so
1134          that they're properly zero-extended, sign-extended or truncated
1135          for their mode.  */
1136
1137       if (GET_MODE (op0) != mode0 && mode0 != VOIDmode)
1138         xop0 = convert_modes (mode0,
1139                               GET_MODE (op0) != VOIDmode
1140                               ? GET_MODE (op0)
1141                               : mode,
1142                               xop0, unsignedp);
1143
1144       if (GET_MODE (op1) != mode1 && mode1 != VOIDmode)
1145         xop1 = convert_modes (mode1,
1146                               GET_MODE (op1) != VOIDmode
1147                               ? GET_MODE (op1)
1148                               : mode,
1149                               xop1, unsignedp);
1150
1151       /* Now, if insn's predicates don't allow our operands, put them into
1152          pseudo regs.  */
1153
1154       if (!insn_data[icode].operand[1].predicate (xop0, mode0)
1155           && mode0 != VOIDmode)
1156         xop0 = copy_to_mode_reg (mode0, xop0);
1157
1158       if (!insn_data[icode].operand[2].predicate (xop1, mode1)
1159           && mode1 != VOIDmode)
1160         xop1 = copy_to_mode_reg (mode1, xop1);
1161
1162       if (!insn_data[icode].operand[0].predicate (temp, mode))
1163         temp = gen_reg_rtx (mode);
1164
1165       pat = GEN_FCN (icode) (temp, xop0, xop1);
1166       if (pat)
1167         {
1168           /* If PAT is composed of more than one insn, try to add an appropriate
1169              REG_EQUAL note to it.  If we can't because TEMP conflicts with an
1170              operand, call ourselves again, this time without a target.  */
1171           if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
1172               && ! add_equal_note (pat, temp, binoptab->code, xop0, xop1))
1173             {
1174               delete_insns_since (last);
1175               return expand_binop (mode, binoptab, op0, op1, NULL_RTX,
1176                                    unsignedp, methods);
1177             }
1178
1179           emit_insn (pat);
1180           return temp;
1181         }
1182       else
1183         delete_insns_since (last);
1184     }
1185
1186   /* If this is a multiply, see if we can do a widening operation that
1187      takes operands of this mode and makes a wider mode.  */
1188
1189   if (binoptab == smul_optab && GET_MODE_WIDER_MODE (mode) != VOIDmode
1190       && (((unsignedp ? umul_widen_optab : smul_widen_optab)
1191            ->handlers[(int) GET_MODE_WIDER_MODE (mode)].insn_code)
1192           != CODE_FOR_nothing))
1193     {
1194       temp = expand_binop (GET_MODE_WIDER_MODE (mode),
1195                            unsignedp ? umul_widen_optab : smul_widen_optab,
1196                            op0, op1, NULL_RTX, unsignedp, OPTAB_DIRECT);
1197
1198       if (temp != 0)
1199         {
1200           if (GET_MODE_CLASS (mode) == MODE_INT
1201               && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1202                                         GET_MODE_BITSIZE (GET_MODE (temp))))
1203             return gen_lowpart (mode, temp);
1204           else
1205             return convert_to_mode (mode, temp, unsignedp);
1206         }
1207     }
1208
1209   /* Look for a wider mode of the same class for which we think we
1210      can open-code the operation.  Check for a widening multiply at the
1211      wider mode as well.  */
1212
1213   if ((class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
1214       && methods != OPTAB_DIRECT && methods != OPTAB_LIB)
1215     for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
1216          wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1217       {
1218         if (binoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing
1219             || (binoptab == smul_optab
1220                 && GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
1221                 && (((unsignedp ? umul_widen_optab : smul_widen_optab)
1222                      ->handlers[(int) GET_MODE_WIDER_MODE (wider_mode)].insn_code)
1223                     != CODE_FOR_nothing)))
1224           {
1225             rtx xop0 = op0, xop1 = op1;
1226             int no_extend = 0;
1227
1228             /* For certain integer operations, we need not actually extend
1229                the narrow operands, as long as we will truncate
1230                the results to the same narrowness.  */
1231
1232             if ((binoptab == ior_optab || binoptab == and_optab
1233                  || binoptab == xor_optab
1234                  || binoptab == add_optab || binoptab == sub_optab
1235                  || binoptab == smul_optab || binoptab == ashl_optab)
1236                 && class == MODE_INT)
1237               no_extend = 1;
1238
1239             xop0 = widen_operand (xop0, wider_mode, mode, unsignedp, no_extend);
1240
1241             /* The second operand of a shift must always be extended.  */
1242             xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
1243                                   no_extend && binoptab != ashl_optab);
1244
1245             temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
1246                                  unsignedp, OPTAB_DIRECT);
1247             if (temp)
1248               {
1249                 if (class != MODE_INT
1250                     || !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1251                                                GET_MODE_BITSIZE (wider_mode)))
1252                   {
1253                     if (target == 0)
1254                       target = gen_reg_rtx (mode);
1255                     convert_move (target, temp, 0);
1256                     return target;
1257                   }
1258                 else
1259                   return gen_lowpart (mode, temp);
1260               }
1261             else
1262               delete_insns_since (last);
1263           }
1264       }
1265
1266   /* These can be done a word at a time.  */
1267   if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
1268       && class == MODE_INT
1269       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
1270       && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
1271     {
1272       int i;
1273       rtx insns;
1274       rtx equiv_value;
1275
1276       /* If TARGET is the same as one of the operands, the REG_EQUAL note
1277          won't be accurate, so use a new target.  */
1278       if (target == 0 || target == op0 || target == op1)
1279         target = gen_reg_rtx (mode);
1280
1281       start_sequence ();
1282
1283       /* Do the actual arithmetic.  */
1284       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
1285         {
1286           rtx target_piece = operand_subword (target, i, 1, mode);
1287           rtx x = expand_binop (word_mode, binoptab,
1288                                 operand_subword_force (op0, i, mode),
1289                                 operand_subword_force (op1, i, mode),
1290                                 target_piece, unsignedp, next_methods);
1291
1292           if (x == 0)
1293             break;
1294
1295           if (target_piece != x)
1296             emit_move_insn (target_piece, x);
1297         }
1298
1299       insns = get_insns ();
1300       end_sequence ();
1301
1302       if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
1303         {
1304           if (binoptab->code != UNKNOWN)
1305             equiv_value
1306               = gen_rtx_fmt_ee (binoptab->code, mode,
1307                                 copy_rtx (op0), copy_rtx (op1));
1308           else
1309             equiv_value = 0;
1310
1311           emit_no_conflict_block (insns, target, op0, op1, equiv_value);
1312           return target;
1313         }
1314     }
1315
1316   /* Synthesize double word shifts from single word shifts.  */
1317   if ((binoptab == lshr_optab || binoptab == ashl_optab
1318        || binoptab == ashr_optab)
1319       && class == MODE_INT
1320       && (GET_CODE (op1) == CONST_INT || !optimize_size)
1321       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1322       && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
1323       && ashl_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
1324       && lshr_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
1325     {
1326       unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
1327       enum machine_mode op1_mode;
1328
1329       double_shift_mask = targetm.shift_truncation_mask (mode);
1330       shift_mask = targetm.shift_truncation_mask (word_mode);
1331       op1_mode = GET_MODE (op1) != VOIDmode ? GET_MODE (op1) : word_mode;
1332
1333       /* Apply the truncation to constant shifts.  */
1334       if (double_shift_mask > 0 && GET_CODE (op1) == CONST_INT)
1335         op1 = GEN_INT (INTVAL (op1) & double_shift_mask);
1336
1337       if (op1 == CONST0_RTX (op1_mode))
1338         return op0;
1339
1340       /* Make sure that this is a combination that expand_doubleword_shift
1341          can handle.  See the comments there for details.  */
1342       if (double_shift_mask == 0
1343           || (shift_mask == BITS_PER_WORD - 1
1344               && double_shift_mask == BITS_PER_WORD * 2 - 1))
1345         {
1346           rtx insns, equiv_value;
1347           rtx into_target, outof_target;
1348           rtx into_input, outof_input;
1349           int left_shift, outof_word;
1350
1351           /* If TARGET is the same as one of the operands, the REG_EQUAL note
1352              won't be accurate, so use a new target.  */
1353           if (target == 0 || target == op0 || target == op1)
1354             target = gen_reg_rtx (mode);
1355
1356           start_sequence ();
1357
1358           /* OUTOF_* is the word we are shifting bits away from, and
1359              INTO_* is the word that we are shifting bits towards, thus
1360              they differ depending on the direction of the shift and
1361              WORDS_BIG_ENDIAN.  */
1362
1363           left_shift = binoptab == ashl_optab;
1364           outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1365
1366           outof_target = operand_subword (target, outof_word, 1, mode);
1367           into_target = operand_subword (target, 1 - outof_word, 1, mode);
1368
1369           outof_input = operand_subword_force (op0, outof_word, mode);
1370           into_input = operand_subword_force (op0, 1 - outof_word, mode);
1371
1372           if (expand_doubleword_shift (op1_mode, binoptab,
1373                                        outof_input, into_input, op1,
1374                                        outof_target, into_target,
1375                                        unsignedp, methods, shift_mask))
1376             {
1377               insns = get_insns ();
1378               end_sequence ();
1379
1380               equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
1381               emit_no_conflict_block (insns, target, op0, op1, equiv_value);
1382               return target;
1383             }
1384           end_sequence ();
1385         }
1386     }
1387
1388   /* Synthesize double word rotates from single word shifts.  */
1389   if ((binoptab == rotl_optab || binoptab == rotr_optab)
1390       && class == MODE_INT
1391       && GET_CODE (op1) == CONST_INT
1392       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1393       && ashl_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
1394       && lshr_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
1395     {
1396       rtx insns, equiv_value;
1397       rtx into_target, outof_target;
1398       rtx into_input, outof_input;
1399       rtx inter;
1400       int shift_count, left_shift, outof_word;
1401
1402       /* If TARGET is the same as one of the operands, the REG_EQUAL note
1403          won't be accurate, so use a new target. Do this also if target is not
1404          a REG, first because having a register instead may open optimization
1405          opportunities, and second because if target and op0 happen to be MEMs
1406          designating the same location, we would risk clobbering it too early
1407          in the code sequence we generate below.  */
1408       if (target == 0 || target == op0 || target == op1 || ! REG_P (target))
1409         target = gen_reg_rtx (mode);
1410
1411       start_sequence ();
1412
1413       shift_count = INTVAL (op1);
1414
1415       /* OUTOF_* is the word we are shifting bits away from, and
1416          INTO_* is the word that we are shifting bits towards, thus
1417          they differ depending on the direction of the shift and
1418          WORDS_BIG_ENDIAN.  */
1419
1420       left_shift = (binoptab == rotl_optab);
1421       outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1422
1423       outof_target = operand_subword (target, outof_word, 1, mode);
1424       into_target = operand_subword (target, 1 - outof_word, 1, mode);
1425
1426       outof_input = operand_subword_force (op0, outof_word, mode);
1427       into_input = operand_subword_force (op0, 1 - outof_word, mode);
1428
1429       if (shift_count == BITS_PER_WORD)
1430         {
1431           /* This is just a word swap.  */
1432           emit_move_insn (outof_target, into_input);
1433           emit_move_insn (into_target, outof_input);
1434           inter = const0_rtx;
1435         }
1436       else
1437         {
1438           rtx into_temp1, into_temp2, outof_temp1, outof_temp2;
1439           rtx first_shift_count, second_shift_count;
1440           optab reverse_unsigned_shift, unsigned_shift;
1441
1442           reverse_unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1443                                     ? lshr_optab : ashl_optab);
1444
1445           unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1446                             ? ashl_optab : lshr_optab);
1447
1448           if (shift_count > BITS_PER_WORD)
1449             {
1450               first_shift_count = GEN_INT (shift_count - BITS_PER_WORD);
1451               second_shift_count = GEN_INT (2 * BITS_PER_WORD - shift_count);
1452             }
1453           else
1454             {
1455               first_shift_count = GEN_INT (BITS_PER_WORD - shift_count);
1456               second_shift_count = GEN_INT (shift_count);
1457             }
1458
1459           into_temp1 = expand_binop (word_mode, unsigned_shift,
1460                                      outof_input, first_shift_count,
1461                                      NULL_RTX, unsignedp, next_methods);
1462           into_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1463                                      into_input, second_shift_count,
1464                                      NULL_RTX, unsignedp, next_methods);
1465
1466           if (into_temp1 != 0 && into_temp2 != 0)
1467             inter = expand_binop (word_mode, ior_optab, into_temp1, into_temp2,
1468                                   into_target, unsignedp, next_methods);
1469           else
1470             inter = 0;
1471
1472           if (inter != 0 && inter != into_target)
1473             emit_move_insn (into_target, inter);
1474
1475           outof_temp1 = expand_binop (word_mode, unsigned_shift,
1476                                       into_input, first_shift_count,
1477                                       NULL_RTX, unsignedp, next_methods);
1478           outof_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1479                                       outof_input, second_shift_count,
1480                                       NULL_RTX, unsignedp, next_methods);
1481
1482           if (inter != 0 && outof_temp1 != 0 && outof_temp2 != 0)
1483             inter = expand_binop (word_mode, ior_optab,
1484                                   outof_temp1, outof_temp2,
1485                                   outof_target, unsignedp, next_methods);
1486
1487           if (inter != 0 && inter != outof_target)
1488             emit_move_insn (outof_target, inter);
1489         }
1490
1491       insns = get_insns ();
1492       end_sequence ();
1493
1494       if (inter != 0)
1495         {
1496           if (binoptab->code != UNKNOWN)
1497             equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
1498           else
1499             equiv_value = 0;
1500
1501           /* We can't make this a no conflict block if this is a word swap,
1502              because the word swap case fails if the input and output values
1503              are in the same register.  */
1504           if (shift_count != BITS_PER_WORD)
1505             emit_no_conflict_block (insns, target, op0, op1, equiv_value);
1506           else
1507             emit_insn (insns);
1508
1509
1510           return target;
1511         }
1512     }
1513
1514   /* These can be done a word at a time by propagating carries.  */
1515   if ((binoptab == add_optab || binoptab == sub_optab)
1516       && class == MODE_INT
1517       && GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
1518       && binoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
1519     {
1520       unsigned int i;
1521       optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
1522       const unsigned int nwords = GET_MODE_BITSIZE (mode) / BITS_PER_WORD;
1523       rtx carry_in = NULL_RTX, carry_out = NULL_RTX;
1524       rtx xop0, xop1, xtarget;
1525
1526       /* We can handle either a 1 or -1 value for the carry.  If STORE_FLAG
1527          value is one of those, use it.  Otherwise, use 1 since it is the
1528          one easiest to get.  */
1529 #if STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1
1530       int normalizep = STORE_FLAG_VALUE;
1531 #else
1532       int normalizep = 1;
1533 #endif
1534
1535       /* Prepare the operands.  */
1536       xop0 = force_reg (mode, op0);
1537       xop1 = force_reg (mode, op1);
1538
1539       xtarget = gen_reg_rtx (mode);
1540
1541       if (target == 0 || !REG_P (target))
1542         target = xtarget;
1543
1544       /* Indicate for flow that the entire target reg is being set.  */
1545       if (REG_P (target))
1546         emit_insn (gen_rtx_CLOBBER (VOIDmode, xtarget));
1547
1548       /* Do the actual arithmetic.  */
1549       for (i = 0; i < nwords; i++)
1550         {
1551           int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
1552           rtx target_piece = operand_subword (xtarget, index, 1, mode);
1553           rtx op0_piece = operand_subword_force (xop0, index, mode);
1554           rtx op1_piece = operand_subword_force (xop1, index, mode);
1555           rtx x;
1556
1557           /* Main add/subtract of the input operands.  */
1558           x = expand_binop (word_mode, binoptab,
1559                             op0_piece, op1_piece,
1560                             target_piece, unsignedp, next_methods);
1561           if (x == 0)
1562             break;
1563
1564           if (i + 1 < nwords)
1565             {
1566               /* Store carry from main add/subtract.  */
1567               carry_out = gen_reg_rtx (word_mode);
1568               carry_out = emit_store_flag_force (carry_out,
1569                                                  (binoptab == add_optab
1570                                                   ? LT : GT),
1571                                                  x, op0_piece,
1572                                                  word_mode, 1, normalizep);
1573             }
1574
1575           if (i > 0)
1576             {
1577               rtx newx;
1578
1579               /* Add/subtract previous carry to main result.  */
1580               newx = expand_binop (word_mode,
1581                                    normalizep == 1 ? binoptab : otheroptab,
1582                                    x, carry_in,
1583                                    NULL_RTX, 1, next_methods);
1584
1585               if (i + 1 < nwords)
1586                 {
1587                   /* Get out carry from adding/subtracting carry in.  */
1588                   rtx carry_tmp = gen_reg_rtx (word_mode);
1589                   carry_tmp = emit_store_flag_force (carry_tmp,
1590                                                      (binoptab == add_optab
1591                                                       ? LT : GT),
1592                                                      newx, x,
1593                                                      word_mode, 1, normalizep);
1594
1595                   /* Logical-ior the two poss. carry together.  */
1596                   carry_out = expand_binop (word_mode, ior_optab,
1597                                             carry_out, carry_tmp,
1598                                             carry_out, 0, next_methods);
1599                   if (carry_out == 0)
1600                     break;
1601                 }
1602               emit_move_insn (target_piece, newx);
1603             }
1604           else
1605             {
1606               if (x != target_piece)
1607                 emit_move_insn (target_piece, x);
1608             }
1609
1610           carry_in = carry_out;
1611         }
1612
1613       if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
1614         {
1615           if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
1616               || ! rtx_equal_p (target, xtarget))
1617             {
1618               rtx temp = emit_move_insn (target, xtarget);
1619
1620               set_unique_reg_note (temp,
1621                                    REG_EQUAL,
1622                                    gen_rtx_fmt_ee (binoptab->code, mode,
1623                                                    copy_rtx (xop0),
1624                                                    copy_rtx (xop1)));
1625             }
1626           else
1627             target = xtarget;
1628
1629           return target;
1630         }
1631
1632       else
1633         delete_insns_since (last);
1634     }
1635
1636   /* Attempt to synthesize double word multiplies using a sequence of word
1637      mode multiplications.  We first attempt to generate a sequence using a
1638      more efficient unsigned widening multiply, and if that fails we then
1639      try using a signed widening multiply.  */
1640
1641   if (binoptab == smul_optab
1642       && class == MODE_INT
1643       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1644       && smul_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing
1645       && add_optab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
1646     {
1647       rtx product = NULL_RTX;
1648
1649       if (umul_widen_optab->handlers[(int) mode].insn_code
1650           != CODE_FOR_nothing)
1651         {
1652           product = expand_doubleword_mult (mode, op0, op1, target,
1653                                             true, methods);
1654           if (!product)
1655             delete_insns_since (last);
1656         }
1657
1658       if (product == NULL_RTX
1659           && smul_widen_optab->handlers[(int) mode].insn_code
1660              != CODE_FOR_nothing)
1661         {
1662           product = expand_doubleword_mult (mode, op0, op1, target,
1663                                             false, methods);
1664           if (!product)
1665             delete_insns_since (last);
1666         }
1667
1668       if (product != NULL_RTX)
1669         {
1670           if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1671             {
1672               temp = emit_move_insn (target ? target : product, product);
1673               set_unique_reg_note (temp,
1674                                    REG_EQUAL,
1675                                    gen_rtx_fmt_ee (MULT, mode,
1676                                                    copy_rtx (op0),
1677                                                    copy_rtx (op1)));
1678             }
1679           return product;
1680         }
1681     }
1682
1683   /* It can't be open-coded in this mode.
1684      Use a library call if one is available and caller says that's ok.  */
1685
1686   if (binoptab->handlers[(int) mode].libfunc
1687       && (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
1688     {
1689       rtx insns;
1690       rtx op1x = op1;
1691       enum machine_mode op1_mode = mode;
1692       rtx value;
1693
1694       start_sequence ();
1695
1696       if (shift_op)
1697         {
1698           op1_mode = word_mode;
1699           /* Specify unsigned here,
1700              since negative shift counts are meaningless.  */
1701           op1x = convert_to_mode (word_mode, op1, 1);
1702         }
1703
1704       if (GET_MODE (op0) != VOIDmode
1705           && GET_MODE (op0) != mode)
1706         op0 = convert_to_mode (mode, op0, unsignedp);
1707
1708       /* Pass 1 for NO_QUEUE so we don't lose any increments
1709          if the libcall is cse'd or moved.  */
1710       value = emit_library_call_value (binoptab->handlers[(int) mode].libfunc,
1711                                        NULL_RTX, LCT_CONST, mode, 2,
1712                                        op0, mode, op1x, op1_mode);
1713
1714       insns = get_insns ();
1715       end_sequence ();
1716
1717       target = gen_reg_rtx (mode);
1718       emit_libcall_block (insns, target, value,
1719                           gen_rtx_fmt_ee (binoptab->code, mode, op0, op1));
1720
1721       return target;
1722     }
1723
1724   delete_insns_since (last);
1725
1726   /* It can't be done in this mode.  Can we do it in a wider mode?  */
1727
1728   if (! (methods == OPTAB_WIDEN || methods == OPTAB_LIB_WIDEN
1729          || methods == OPTAB_MUST_WIDEN))
1730     {
1731       /* Caller says, don't even try.  */
1732       delete_insns_since (entry_last);
1733       return 0;
1734     }
1735
1736   /* Compute the value of METHODS to pass to recursive calls.
1737      Don't allow widening to be tried recursively.  */
1738
1739   methods = (methods == OPTAB_LIB_WIDEN ? OPTAB_LIB : OPTAB_DIRECT);
1740
1741   /* Look for a wider mode of the same class for which it appears we can do
1742      the operation.  */
1743
1744   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
1745     {
1746       for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
1747            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1748         {
1749           if ((binoptab->handlers[(int) wider_mode].insn_code
1750                != CODE_FOR_nothing)
1751               || (methods == OPTAB_LIB
1752                   && binoptab->handlers[(int) wider_mode].libfunc))
1753             {
1754               rtx xop0 = op0, xop1 = op1;
1755               int no_extend = 0;
1756
1757               /* For certain integer operations, we need not actually extend
1758                  the narrow operands, as long as we will truncate
1759                  the results to the same narrowness.  */
1760
1761               if ((binoptab == ior_optab || binoptab == and_optab
1762                    || binoptab == xor_optab
1763                    || binoptab == add_optab || binoptab == sub_optab
1764                    || binoptab == smul_optab || binoptab == ashl_optab)
1765                   && class == MODE_INT)
1766                 no_extend = 1;
1767
1768               xop0 = widen_operand (xop0, wider_mode, mode,
1769                                     unsignedp, no_extend);
1770
1771               /* The second operand of a shift must always be extended.  */
1772               xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
1773                                     no_extend && binoptab != ashl_optab);
1774
1775               temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
1776                                    unsignedp, methods);
1777               if (temp)
1778                 {
1779                   if (class != MODE_INT
1780                       || !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1781                                                  GET_MODE_BITSIZE (wider_mode)))
1782                     {
1783                       if (target == 0)
1784                         target = gen_reg_rtx (mode);
1785                       convert_move (target, temp, 0);
1786                       return target;
1787                     }
1788                   else
1789                     return gen_lowpart (mode, temp);
1790                 }
1791               else
1792                 delete_insns_since (last);
1793             }
1794         }
1795     }
1796
1797   delete_insns_since (entry_last);
1798   return 0;
1799 }
1800 \f
1801 /* Expand a binary operator which has both signed and unsigned forms.
1802    UOPTAB is the optab for unsigned operations, and SOPTAB is for
1803    signed operations.
1804
1805    If we widen unsigned operands, we may use a signed wider operation instead
1806    of an unsigned wider operation, since the result would be the same.  */
1807
1808 rtx
1809 sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
1810                    rtx op0, rtx op1, rtx target, int unsignedp,
1811                    enum optab_methods methods)
1812 {
1813   rtx temp;
1814   optab direct_optab = unsignedp ? uoptab : soptab;
1815   struct optab wide_soptab;
1816
1817   /* Do it without widening, if possible.  */
1818   temp = expand_binop (mode, direct_optab, op0, op1, target,
1819                        unsignedp, OPTAB_DIRECT);
1820   if (temp || methods == OPTAB_DIRECT)
1821     return temp;
1822
1823   /* Try widening to a signed int.  Make a fake signed optab that
1824      hides any signed insn for direct use.  */
1825   wide_soptab = *soptab;
1826   wide_soptab.handlers[(int) mode].insn_code = CODE_FOR_nothing;
1827   wide_soptab.handlers[(int) mode].libfunc = 0;
1828
1829   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
1830                        unsignedp, OPTAB_WIDEN);
1831
1832   /* For unsigned operands, try widening to an unsigned int.  */
1833   if (temp == 0 && unsignedp)
1834     temp = expand_binop (mode, uoptab, op0, op1, target,
1835                          unsignedp, OPTAB_WIDEN);
1836   if (temp || methods == OPTAB_WIDEN)
1837     return temp;
1838
1839   /* Use the right width lib call if that exists.  */
1840   temp = expand_binop (mode, direct_optab, op0, op1, target, unsignedp, OPTAB_LIB);
1841   if (temp || methods == OPTAB_LIB)
1842     return temp;
1843
1844   /* Must widen and use a lib call, use either signed or unsigned.  */
1845   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
1846                        unsignedp, methods);
1847   if (temp != 0)
1848     return temp;
1849   if (unsignedp)
1850     return expand_binop (mode, uoptab, op0, op1, target,
1851                          unsignedp, methods);
1852   return 0;
1853 }
1854 \f
1855 /* Generate code to perform an operation specified by UNOPPTAB
1856    on operand OP0, with two results to TARG0 and TARG1.
1857    We assume that the order of the operands for the instruction
1858    is TARG0, TARG1, OP0.
1859
1860    Either TARG0 or TARG1 may be zero, but what that means is that
1861    the result is not actually wanted.  We will generate it into
1862    a dummy pseudo-reg and discard it.  They may not both be zero.
1863
1864    Returns 1 if this operation can be performed; 0 if not.  */
1865
1866 int
1867 expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
1868                     int unsignedp)
1869 {
1870   enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
1871   enum mode_class class;
1872   enum machine_mode wider_mode;
1873   rtx entry_last = get_last_insn ();
1874   rtx last;
1875
1876   class = GET_MODE_CLASS (mode);
1877
1878   if (!targ0)
1879     targ0 = gen_reg_rtx (mode);
1880   if (!targ1)
1881     targ1 = gen_reg_rtx (mode);
1882
1883   /* Record where to go back to if we fail.  */
1884   last = get_last_insn ();
1885
1886   if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1887     {
1888       int icode = (int) unoptab->handlers[(int) mode].insn_code;
1889       enum machine_mode mode0 = insn_data[icode].operand[2].mode;
1890       rtx pat;
1891       rtx xop0 = op0;
1892
1893       if (GET_MODE (xop0) != VOIDmode
1894           && GET_MODE (xop0) != mode0)
1895         xop0 = convert_to_mode (mode0, xop0, unsignedp);
1896
1897       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
1898       if (!insn_data[icode].operand[2].predicate (xop0, mode0))
1899         xop0 = copy_to_mode_reg (mode0, xop0);
1900
1901       /* We could handle this, but we should always be called with a pseudo
1902          for our targets and all insns should take them as outputs.  */
1903       gcc_assert (insn_data[icode].operand[0].predicate (targ0, mode));
1904       gcc_assert (insn_data[icode].operand[1].predicate (targ1, mode));
1905
1906       pat = GEN_FCN (icode) (targ0, targ1, xop0);
1907       if (pat)
1908         {
1909           emit_insn (pat);
1910           return 1;
1911         }
1912       else
1913         delete_insns_since (last);
1914     }
1915
1916   /* It can't be done in this mode.  Can we do it in a wider mode?  */
1917
1918   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
1919     {
1920       for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
1921            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1922         {
1923           if (unoptab->handlers[(int) wider_mode].insn_code
1924               != CODE_FOR_nothing)
1925             {
1926               rtx t0 = gen_reg_rtx (wider_mode);
1927               rtx t1 = gen_reg_rtx (wider_mode);
1928               rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
1929
1930               if (expand_twoval_unop (unoptab, cop0, t0, t1, unsignedp))
1931                 {
1932                   convert_move (targ0, t0, unsignedp);
1933                   convert_move (targ1, t1, unsignedp);
1934                   return 1;
1935                 }
1936               else
1937                 delete_insns_since (last);
1938             }
1939         }
1940     }
1941
1942   delete_insns_since (entry_last);
1943   return 0;
1944 }
1945 \f
1946 /* Generate code to perform an operation specified by BINOPTAB
1947    on operands OP0 and OP1, with two results to TARG1 and TARG2.
1948    We assume that the order of the operands for the instruction
1949    is TARG0, OP0, OP1, TARG1, which would fit a pattern like
1950    [(set TARG0 (operate OP0 OP1)) (set TARG1 (operate ...))].
1951
1952    Either TARG0 or TARG1 may be zero, but what that means is that
1953    the result is not actually wanted.  We will generate it into
1954    a dummy pseudo-reg and discard it.  They may not both be zero.
1955
1956    Returns 1 if this operation can be performed; 0 if not.  */
1957
1958 int
1959 expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
1960                      int unsignedp)
1961 {
1962   enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
1963   enum mode_class class;
1964   enum machine_mode wider_mode;
1965   rtx entry_last = get_last_insn ();
1966   rtx last;
1967
1968   class = GET_MODE_CLASS (mode);
1969
1970   /* If we are inside an appropriately-short loop and we are optimizing,
1971      force expensive constants into a register.  */
1972   if (CONSTANT_P (op0) && optimize
1973       && rtx_cost (op0, binoptab->code) > COSTS_N_INSNS (1))
1974     op0 = force_reg (mode, op0);
1975
1976   if (CONSTANT_P (op1) && optimize
1977       && rtx_cost (op1, binoptab->code) > COSTS_N_INSNS (1))
1978     op1 = force_reg (mode, op1);
1979
1980   if (!targ0)
1981     targ0 = gen_reg_rtx (mode);
1982   if (!targ1)
1983     targ1 = gen_reg_rtx (mode);
1984
1985   /* Record where to go back to if we fail.  */
1986   last = get_last_insn ();
1987
1988   if (binoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1989     {
1990       int icode = (int) binoptab->handlers[(int) mode].insn_code;
1991       enum machine_mode mode0 = insn_data[icode].operand[1].mode;
1992       enum machine_mode mode1 = insn_data[icode].operand[2].mode;
1993       rtx pat;
1994       rtx xop0 = op0, xop1 = op1;
1995
1996       /* In case the insn wants input operands in modes different from
1997          those of the actual operands, convert the operands.  It would
1998          seem that we don't need to convert CONST_INTs, but we do, so
1999          that they're properly zero-extended, sign-extended or truncated
2000          for their mode.  */
2001
2002       if (GET_MODE (op0) != mode0 && mode0 != VOIDmode)
2003         xop0 = convert_modes (mode0,
2004                               GET_MODE (op0) != VOIDmode
2005                               ? GET_MODE (op0)
2006                               : mode,
2007                               xop0, unsignedp);
2008
2009       if (GET_MODE (op1) != mode1 && mode1 != VOIDmode)
2010         xop1 = convert_modes (mode1,
2011                               GET_MODE (op1) != VOIDmode
2012                               ? GET_MODE (op1)
2013                               : mode,
2014                               xop1, unsignedp);
2015
2016       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
2017       if (!insn_data[icode].operand[1].predicate (xop0, mode0))
2018         xop0 = copy_to_mode_reg (mode0, xop0);
2019
2020       if (!insn_data[icode].operand[2].predicate (xop1, mode1))
2021         xop1 = copy_to_mode_reg (mode1, xop1);
2022
2023       /* We could handle this, but we should always be called with a pseudo
2024          for our targets and all insns should take them as outputs.  */
2025       gcc_assert (insn_data[icode].operand[0].predicate (targ0, mode));
2026       gcc_assert (insn_data[icode].operand[3].predicate (targ1, mode));
2027
2028       pat = GEN_FCN (icode) (targ0, xop0, xop1, targ1);
2029       if (pat)
2030         {
2031           emit_insn (pat);
2032           return 1;
2033         }
2034       else
2035         delete_insns_since (last);
2036     }
2037
2038   /* It can't be done in this mode.  Can we do it in a wider mode?  */
2039
2040   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
2041     {
2042       for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
2043            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2044         {
2045           if (binoptab->handlers[(int) wider_mode].insn_code
2046               != CODE_FOR_nothing)
2047             {
2048               rtx t0 = gen_reg_rtx (wider_mode);
2049               rtx t1 = gen_reg_rtx (wider_mode);
2050               rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
2051               rtx cop1 = convert_modes (wider_mode, mode, op1, unsignedp);
2052
2053               if (expand_twoval_binop (binoptab, cop0, cop1,
2054                                        t0, t1, unsignedp))
2055                 {
2056                   convert_move (targ0, t0, unsignedp);
2057                   convert_move (targ1, t1, unsignedp);
2058                   return 1;
2059                 }
2060               else
2061                 delete_insns_since (last);
2062             }
2063         }
2064     }
2065
2066   delete_insns_since (entry_last);
2067   return 0;
2068 }
2069
2070 /* Expand the two-valued library call indicated by BINOPTAB, but
2071    preserve only one of the values.  If TARG0 is non-NULL, the first
2072    value is placed into TARG0; otherwise the second value is placed
2073    into TARG1.  Exactly one of TARG0 and TARG1 must be non-NULL.  The
2074    value stored into TARG0 or TARG1 is equivalent to (CODE OP0 OP1).
2075    This routine assumes that the value returned by the library call is
2076    as if the return value was of an integral mode twice as wide as the
2077    mode of OP0.  Returns 1 if the call was successful.  */
2078
2079 bool
2080 expand_twoval_binop_libfunc (optab binoptab, rtx op0, rtx op1,
2081                              rtx targ0, rtx targ1, enum rtx_code code)
2082 {
2083   enum machine_mode mode;
2084   enum machine_mode libval_mode;
2085   rtx libval;
2086   rtx insns;
2087
2088   /* Exactly one of TARG0 or TARG1 should be non-NULL.  */
2089   gcc_assert (!targ0 != !targ1);
2090
2091   mode = GET_MODE (op0);
2092   if (!binoptab->handlers[(int) mode].libfunc)
2093     return false;
2094
2095   /* The value returned by the library function will have twice as
2096      many bits as the nominal MODE.  */
2097   libval_mode = smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode),
2098                                         MODE_INT);
2099   start_sequence ();
2100   libval = emit_library_call_value (binoptab->handlers[(int) mode].libfunc,
2101                                     NULL_RTX, LCT_CONST,
2102                                     libval_mode, 2,
2103                                     op0, mode,
2104                                     op1, mode);
2105   /* Get the part of VAL containing the value that we want.  */
2106   libval = simplify_gen_subreg (mode, libval, libval_mode,
2107                                 targ0 ? 0 : GET_MODE_SIZE (mode));
2108   insns = get_insns ();
2109   end_sequence ();
2110   /* Move the into the desired location.  */
2111   emit_libcall_block (insns, targ0 ? targ0 : targ1, libval,
2112                       gen_rtx_fmt_ee (code, mode, op0, op1));
2113
2114   return true;
2115 }
2116
2117 \f
2118 /* Wrapper around expand_unop which takes an rtx code to specify
2119    the operation to perform, not an optab pointer.  All other
2120    arguments are the same.  */
2121 rtx
2122 expand_simple_unop (enum machine_mode mode, enum rtx_code code, rtx op0,
2123                     rtx target, int unsignedp)
2124 {
2125   optab unop = code_to_optab[(int) code];
2126   gcc_assert (unop);
2127
2128   return expand_unop (mode, unop, op0, target, unsignedp);
2129 }
2130
2131 /* Try calculating
2132         (clz:narrow x)
2133    as
2134         (clz:wide (zero_extend:wide x)) - ((width wide) - (width narrow)).  */
2135 static rtx
2136 widen_clz (enum machine_mode mode, rtx op0, rtx target)
2137 {
2138   enum mode_class class = GET_MODE_CLASS (mode);
2139   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
2140     {
2141       enum machine_mode wider_mode;
2142       for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
2143            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2144         {
2145           if (clz_optab->handlers[(int) wider_mode].insn_code
2146               != CODE_FOR_nothing)
2147             {
2148               rtx xop0, temp, last;
2149
2150               last = get_last_insn ();
2151
2152               if (target == 0)
2153                 target = gen_reg_rtx (mode);
2154               xop0 = widen_operand (op0, wider_mode, mode, true, false);
2155               temp = expand_unop (wider_mode, clz_optab, xop0, NULL_RTX, true);
2156               if (temp != 0)
2157                 temp = expand_binop (wider_mode, sub_optab, temp,
2158                                      GEN_INT (GET_MODE_BITSIZE (wider_mode)
2159                                               - GET_MODE_BITSIZE (mode)),
2160                                      target, true, OPTAB_DIRECT);
2161               if (temp == 0)
2162                 delete_insns_since (last);
2163
2164               return temp;
2165             }
2166         }
2167     }
2168   return 0;
2169 }
2170
2171 /* Try calculating (parity x) as (and (popcount x) 1), where
2172    popcount can also be done in a wider mode.  */
2173 static rtx
2174 expand_parity (enum machine_mode mode, rtx op0, rtx target)
2175 {
2176   enum mode_class class = GET_MODE_CLASS (mode);
2177   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
2178     {
2179       enum machine_mode wider_mode;
2180       for (wider_mode = mode; wider_mode != VOIDmode;
2181            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2182         {
2183           if (popcount_optab->handlers[(int) wider_mode].insn_code
2184               != CODE_FOR_nothing)
2185             {
2186               rtx xop0, temp, last;
2187
2188               last = get_last_insn ();
2189
2190               if (target == 0)
2191                 target = gen_reg_rtx (mode);
2192               xop0 = widen_operand (op0, wider_mode, mode, true, false);
2193               temp = expand_unop (wider_mode, popcount_optab, xop0, NULL_RTX,
2194                                   true);
2195               if (temp != 0)
2196                 temp = expand_binop (wider_mode, and_optab, temp, const1_rtx,
2197                                      target, true, OPTAB_DIRECT);
2198               if (temp == 0)
2199                 delete_insns_since (last);
2200
2201               return temp;
2202             }
2203         }
2204     }
2205   return 0;
2206 }
2207
2208 /* Extract the OMODE lowpart from VAL, which has IMODE.  Under certain
2209    conditions, VAL may already be a SUBREG against which we cannot generate
2210    a further SUBREG.  In this case, we expect forcing the value into a
2211    register will work around the situation.  */
2212
2213 static rtx
2214 lowpart_subreg_maybe_copy (enum machine_mode omode, rtx val,
2215                            enum machine_mode imode)
2216 {
2217   rtx ret;
2218   ret = lowpart_subreg (omode, val, imode);
2219   if (ret == NULL)
2220     {
2221       val = force_reg (imode, val);
2222       ret = lowpart_subreg (omode, val, imode);
2223       gcc_assert (ret != NULL);
2224     }
2225   return ret;
2226 }
2227
2228 /* Expand a floating point absolute value or negation operation via a
2229    logical operation on the sign bit.  */
2230
2231 static rtx
2232 expand_absneg_bit (enum rtx_code code, enum machine_mode mode,
2233                    rtx op0, rtx target)
2234 {
2235   const struct real_format *fmt;
2236   int bitpos, word, nwords, i;
2237   enum machine_mode imode;
2238   HOST_WIDE_INT hi, lo;
2239   rtx temp, insns;
2240
2241   /* The format has to have a simple sign bit.  */
2242   fmt = REAL_MODE_FORMAT (mode);
2243   if (fmt == NULL)
2244     return NULL_RTX;
2245
2246   bitpos = fmt->signbit_rw;
2247   if (bitpos < 0)
2248     return NULL_RTX;
2249
2250   /* Don't create negative zeros if the format doesn't support them.  */
2251   if (code == NEG && !fmt->has_signed_zero)
2252     return NULL_RTX;
2253
2254   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
2255     {
2256       imode = int_mode_for_mode (mode);
2257       if (imode == BLKmode)
2258         return NULL_RTX;
2259       word = 0;
2260       nwords = 1;
2261     }
2262   else
2263     {
2264       imode = word_mode;
2265
2266       if (FLOAT_WORDS_BIG_ENDIAN)
2267         word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2268       else
2269         word = bitpos / BITS_PER_WORD;
2270       bitpos = bitpos % BITS_PER_WORD;
2271       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
2272     }
2273
2274   if (bitpos < HOST_BITS_PER_WIDE_INT)
2275     {
2276       hi = 0;
2277       lo = (HOST_WIDE_INT) 1 << bitpos;
2278     }
2279   else
2280     {
2281       hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
2282       lo = 0;
2283     }
2284   if (code == ABS)
2285     lo = ~lo, hi = ~hi;
2286
2287   if (target == 0 || target == op0)
2288     target = gen_reg_rtx (mode);
2289
2290   if (nwords > 1)
2291     {
2292       start_sequence ();
2293
2294       for (i = 0; i < nwords; ++i)
2295         {
2296           rtx targ_piece = operand_subword (target, i, 1, mode);
2297           rtx op0_piece = operand_subword_force (op0, i, mode);
2298
2299           if (i == word)
2300             {
2301               temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
2302                                    op0_piece,
2303                                    immed_double_const (lo, hi, imode),
2304                                    targ_piece, 1, OPTAB_LIB_WIDEN);
2305               if (temp != targ_piece)
2306                 emit_move_insn (targ_piece, temp);
2307             }
2308           else
2309             emit_move_insn (targ_piece, op0_piece);
2310         }
2311
2312       insns = get_insns ();
2313       end_sequence ();
2314
2315       temp = gen_rtx_fmt_e (code, mode, copy_rtx (op0));
2316       emit_no_conflict_block (insns, target, op0, NULL_RTX, temp);
2317     }
2318   else
2319     {
2320       temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
2321                            gen_lowpart (imode, op0),
2322                            immed_double_const (lo, hi, imode),
2323                            gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
2324       target = lowpart_subreg_maybe_copy (mode, temp, imode);
2325
2326       set_unique_reg_note (get_last_insn (), REG_EQUAL,
2327                            gen_rtx_fmt_e (code, mode, copy_rtx (op0)));
2328     }
2329
2330   return target;
2331 }
2332
2333 /* Generate code to perform an operation specified by UNOPTAB
2334    on operand OP0, with result having machine-mode MODE.
2335
2336    UNSIGNEDP is for the case where we have to widen the operands
2337    to perform the operation.  It says to use zero-extension.
2338
2339    If TARGET is nonzero, the value
2340    is generated there, if it is convenient to do so.
2341    In all cases an rtx is returned for the locus of the value;
2342    this may or may not be TARGET.  */
2343
2344 rtx
2345 expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
2346              int unsignedp)
2347 {
2348   enum mode_class class;
2349   enum machine_mode wider_mode;
2350   rtx temp;
2351   rtx last = get_last_insn ();
2352   rtx pat;
2353
2354   class = GET_MODE_CLASS (mode);
2355
2356   if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2357     {
2358       int icode = (int) unoptab->handlers[(int) mode].insn_code;
2359       enum machine_mode mode0 = insn_data[icode].operand[1].mode;
2360       rtx xop0 = op0;
2361
2362       if (target)
2363         temp = target;
2364       else
2365         temp = gen_reg_rtx (mode);
2366
2367       if (GET_MODE (xop0) != VOIDmode
2368           && GET_MODE (xop0) != mode0)
2369         xop0 = convert_to_mode (mode0, xop0, unsignedp);
2370
2371       /* Now, if insn doesn't accept our operand, put it into a pseudo.  */
2372
2373       if (!insn_data[icode].operand[1].predicate (xop0, mode0))
2374         xop0 = copy_to_mode_reg (mode0, xop0);
2375
2376       if (!insn_data[icode].operand[0].predicate (temp, mode))
2377         temp = gen_reg_rtx (mode);
2378
2379       pat = GEN_FCN (icode) (temp, xop0);
2380       if (pat)
2381         {
2382           if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
2383               && ! add_equal_note (pat, temp, unoptab->code, xop0, NULL_RTX))
2384             {
2385               delete_insns_since (last);
2386               return expand_unop (mode, unoptab, op0, NULL_RTX, unsignedp);
2387             }
2388
2389           emit_insn (pat);
2390
2391           return temp;
2392         }
2393       else
2394         delete_insns_since (last);
2395     }
2396
2397   /* It can't be done in this mode.  Can we open-code it in a wider mode?  */
2398
2399   /* Widening clz needs special treatment.  */
2400   if (unoptab == clz_optab)
2401     {
2402       temp = widen_clz (mode, op0, target);
2403       if (temp)
2404         return temp;
2405       else
2406         goto try_libcall;
2407     }
2408
2409   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
2410     for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
2411          wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2412       {
2413         if (unoptab->handlers[(int) wider_mode].insn_code != CODE_FOR_nothing)
2414           {
2415             rtx xop0 = op0;
2416
2417             /* For certain operations, we need not actually extend
2418                the narrow operand, as long as we will truncate the
2419                results to the same narrowness.  */
2420
2421             xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
2422                                   (unoptab == neg_optab
2423                                    || unoptab == one_cmpl_optab)
2424                                   && class == MODE_INT);
2425
2426             temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
2427                                 unsignedp);
2428
2429             if (temp)
2430               {
2431                 if (class != MODE_INT)
2432                   {
2433                     if (target == 0)
2434                       target = gen_reg_rtx (mode);
2435                     convert_move (target, temp, 0);
2436                     return target;
2437                   }
2438                 else
2439                   return gen_lowpart (mode, temp);
2440               }
2441             else
2442               delete_insns_since (last);
2443           }
2444       }
2445
2446   /* These can be done a word at a time.  */
2447   if (unoptab == one_cmpl_optab
2448       && class == MODE_INT
2449       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
2450       && unoptab->handlers[(int) word_mode].insn_code != CODE_FOR_nothing)
2451     {
2452       int i;
2453       rtx insns;
2454
2455       if (target == 0 || target == op0)
2456         target = gen_reg_rtx (mode);
2457
2458       start_sequence ();
2459
2460       /* Do the actual arithmetic.  */
2461       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
2462         {
2463           rtx target_piece = operand_subword (target, i, 1, mode);
2464           rtx x = expand_unop (word_mode, unoptab,
2465                                operand_subword_force (op0, i, mode),
2466                                target_piece, unsignedp);
2467
2468           if (target_piece != x)
2469             emit_move_insn (target_piece, x);
2470         }
2471
2472       insns = get_insns ();
2473       end_sequence ();
2474
2475       emit_no_conflict_block (insns, target, op0, NULL_RTX,
2476                               gen_rtx_fmt_e (unoptab->code, mode,
2477                                              copy_rtx (op0)));
2478       return target;
2479     }
2480
2481   if (unoptab->code == NEG)
2482     {
2483       /* Try negating floating point values by flipping the sign bit.  */
2484       if (class == MODE_FLOAT)
2485         {
2486           temp = expand_absneg_bit (NEG, mode, op0, target);
2487           if (temp)
2488             return temp;
2489         }
2490
2491       /* If there is no negation pattern, and we have no negative zero,
2492          try subtracting from zero.  */
2493       if (!HONOR_SIGNED_ZEROS (mode))
2494         {
2495           temp = expand_binop (mode, (unoptab == negv_optab
2496                                       ? subv_optab : sub_optab),
2497                                CONST0_RTX (mode), op0, target,
2498                                unsignedp, OPTAB_DIRECT);
2499           if (temp)
2500             return temp;
2501         }
2502     }
2503
2504   /* Try calculating parity (x) as popcount (x) % 2.  */
2505   if (unoptab == parity_optab)
2506     {
2507       temp = expand_parity (mode, op0, target);
2508       if (temp)
2509         return temp;
2510     }
2511
2512  try_libcall:
2513   /* Now try a library call in this mode.  */
2514   if (unoptab->handlers[(int) mode].libfunc)
2515     {
2516       rtx insns;
2517       rtx value;
2518       enum machine_mode outmode = mode;
2519
2520       /* All of these functions return small values.  Thus we choose to
2521          have them return something that isn't a double-word.  */
2522       if (unoptab == ffs_optab || unoptab == clz_optab || unoptab == ctz_optab
2523           || unoptab == popcount_optab || unoptab == parity_optab)
2524         outmode
2525             = GET_MODE (hard_libcall_value (TYPE_MODE (integer_type_node)));
2526
2527       start_sequence ();
2528
2529       /* Pass 1 for NO_QUEUE so we don't lose any increments
2530          if the libcall is cse'd or moved.  */
2531       value = emit_library_call_value (unoptab->handlers[(int) mode].libfunc,
2532                                        NULL_RTX, LCT_CONST, outmode,
2533                                        1, op0, mode);
2534       insns = get_insns ();
2535       end_sequence ();
2536
2537       target = gen_reg_rtx (outmode);
2538       emit_libcall_block (insns, target, value,
2539                           gen_rtx_fmt_e (unoptab->code, mode, op0));
2540
2541       return target;
2542     }
2543
2544   /* It can't be done in this mode.  Can we do it in a wider mode?  */
2545
2546   if (class == MODE_INT || class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT)
2547     {
2548       for (wider_mode = GET_MODE_WIDER_MODE (mode); wider_mode != VOIDmode;
2549            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2550         {
2551           if ((unoptab->handlers[(int) wider_mode].insn_code
2552                != CODE_FOR_nothing)
2553               || unoptab->handlers[(int) wider_mode].libfunc)
2554             {
2555               rtx xop0 = op0;
2556
2557               /* For certain operations, we need not actually extend
2558                  the narrow operand, as long as we will truncate the
2559                  results to the same narrowness.  */
2560
2561               xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
2562                                     (unoptab == neg_optab
2563                                      || unoptab == one_cmpl_optab)
2564                                     && class == MODE_INT);
2565
2566               temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
2567                                   unsignedp);
2568
2569               /* If we are generating clz using wider mode, adjust the
2570                  result.  */
2571               if (unoptab == clz_optab && temp != 0)
2572                 temp = expand_binop (wider_mode, sub_optab, temp,
2573                                      GEN_INT (GET_MODE_BITSIZE (wider_mode)
2574                                               - GET_MODE_BITSIZE (mode)),
2575                                      target, true, OPTAB_DIRECT);
2576
2577               if (temp)
2578                 {
2579                   if (class != MODE_INT)
2580                     {
2581                       if (target == 0)
2582                         target = gen_reg_rtx (mode);
2583                       convert_move (target, temp, 0);
2584                       return target;
2585                     }
2586                   else
2587                     return gen_lowpart (mode, temp);
2588                 }
2589               else
2590                 delete_insns_since (last);
2591             }
2592         }
2593     }
2594
2595   /* One final attempt at implementing negation via subtraction,
2596      this time allowing widening of the operand.  */
2597   if (unoptab->code == NEG && !HONOR_SIGNED_ZEROS (mode))
2598     {
2599       rtx temp;
2600       temp = expand_binop (mode,
2601                            unoptab == negv_optab ? subv_optab : sub_optab,
2602                            CONST0_RTX (mode), op0,
2603                            target, unsignedp, OPTAB_LIB_WIDEN);
2604       if (temp)
2605         return temp;
2606     }
2607
2608   return 0;
2609 }
2610 \f
2611 /* Emit code to compute the absolute value of OP0, with result to
2612    TARGET if convenient.  (TARGET may be 0.)  The return value says
2613    where the result actually is to be found.
2614
2615    MODE is the mode of the operand; the mode of the result is
2616    different but can be deduced from MODE.
2617
2618  */
2619
2620 rtx
2621 expand_abs_nojump (enum machine_mode mode, rtx op0, rtx target,
2622                    int result_unsignedp)
2623 {
2624   rtx temp;
2625
2626   if (! flag_trapv)
2627     result_unsignedp = 1;
2628
2629   /* First try to do it with a special abs instruction.  */
2630   temp = expand_unop (mode, result_unsignedp ? abs_optab : absv_optab,
2631                       op0, target, 0);
2632   if (temp != 0)
2633     return temp;
2634
2635   /* For floating point modes, try clearing the sign bit.  */
2636   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2637     {
2638       temp = expand_absneg_bit (ABS, mode, op0, target);
2639       if (temp)
2640         return temp;
2641     }
2642
2643   /* If we have a MAX insn, we can do this as MAX (x, -x).  */
2644   if (smax_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
2645       && !HONOR_SIGNED_ZEROS (mode))
2646     {
2647       rtx last = get_last_insn ();
2648
2649       temp = expand_unop (mode, neg_optab, op0, NULL_RTX, 0);
2650       if (temp != 0)
2651         temp = expand_binop (mode, smax_optab, op0, temp, target, 0,
2652                              OPTAB_WIDEN);
2653
2654       if (temp != 0)
2655         return temp;
2656
2657       delete_insns_since (last);
2658     }
2659
2660   /* If this machine has expensive jumps, we can do integer absolute
2661      value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
2662      where W is the width of MODE.  */
2663
2664   if (GET_MODE_CLASS (mode) == MODE_INT && BRANCH_COST >= 2)
2665     {
2666       rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
2667                                    size_int (GET_MODE_BITSIZE (mode) - 1),
2668                                    NULL_RTX, 0);
2669
2670       temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
2671                            OPTAB_LIB_WIDEN);
2672       if (temp != 0)
2673         temp = expand_binop (mode, result_unsignedp ? sub_optab : subv_optab,
2674                              temp, extended, target, 0, OPTAB_LIB_WIDEN);
2675
2676       if (temp != 0)
2677         return temp;
2678     }
2679
2680   return NULL_RTX;
2681 }
2682
2683 rtx
2684 expand_abs (enum machine_mode mode, rtx op0, rtx target,
2685             int result_unsignedp, int safe)
2686 {
2687   rtx temp, op1;
2688
2689   if (! flag_trapv)
2690     result_unsignedp = 1;
2691
2692   temp = expand_abs_nojump (mode, op0, target, result_unsignedp);
2693   if (temp != 0)
2694     return temp;
2695
2696   /* If that does not win, use conditional jump and negate.  */
2697
2698   /* It is safe to use the target if it is the same
2699      as the source if this is also a pseudo register */
2700   if (op0 == target && REG_P (op0)
2701       && REGNO (op0) >= FIRST_PSEUDO_REGISTER)
2702     safe = 1;
2703
2704   op1 = gen_label_rtx ();
2705   if (target == 0 || ! safe
2706       || GET_MODE (target) != mode
2707       || (MEM_P (target) && MEM_VOLATILE_P (target))
2708       || (REG_P (target)
2709           && REGNO (target) < FIRST_PSEUDO_REGISTER))
2710     target = gen_reg_rtx (mode);
2711
2712   emit_move_insn (target, op0);
2713   NO_DEFER_POP;
2714
2715   /* If this mode is an integer too wide to compare properly,
2716      compare word by word.  Rely on CSE to optimize constant cases.  */
2717   if (GET_MODE_CLASS (mode) == MODE_INT
2718       && ! can_compare_p (GE, mode, ccp_jump))
2719     do_jump_by_parts_greater_rtx (mode, 0, target, const0_rtx,
2720                                   NULL_RTX, op1);
2721   else
2722     do_compare_rtx_and_jump (target, CONST0_RTX (mode), GE, 0, mode,
2723                              NULL_RTX, NULL_RTX, op1);
2724
2725   op0 = expand_unop (mode, result_unsignedp ? neg_optab : negv_optab,
2726                      target, target, 0);
2727   if (op0 != target)
2728     emit_move_insn (target, op0);
2729   emit_label (op1);
2730   OK_DEFER_POP;
2731   return target;
2732 }
2733
2734 /* A subroutine of expand_copysign, perform the copysign operation using the
2735    abs and neg primitives advertised to exist on the target.  The assumption
2736    is that we have a split register file, and leaving op0 in fp registers,
2737    and not playing with subregs so much, will help the register allocator.  */
2738
2739 static rtx
2740 expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target,
2741                         int bitpos, bool op0_is_abs)
2742 {
2743   enum machine_mode imode;
2744   HOST_WIDE_INT hi, lo;
2745   int word;
2746   rtx label;
2747
2748   if (target == op1)
2749     target = NULL_RTX;
2750
2751   if (!op0_is_abs)
2752     {
2753       op0 = expand_unop (mode, abs_optab, op0, target, 0);
2754       if (op0 == NULL)
2755         return NULL_RTX;
2756       target = op0;
2757     }
2758   else
2759     {
2760       if (target == NULL_RTX)
2761         target = copy_to_reg (op0);
2762       else
2763         emit_move_insn (target, op0);
2764     }
2765
2766   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
2767     {
2768       imode = int_mode_for_mode (mode);
2769       if (imode == BLKmode)
2770         return NULL_RTX;
2771       op1 = gen_lowpart (imode, op1);
2772     }
2773   else
2774     {
2775       imode = word_mode;
2776       if (FLOAT_WORDS_BIG_ENDIAN)
2777         word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2778       else
2779         word = bitpos / BITS_PER_WORD;
2780       bitpos = bitpos % BITS_PER_WORD;
2781       op1 = operand_subword_force (op1, word, mode);
2782     }
2783
2784   if (bitpos < HOST_BITS_PER_WIDE_INT)
2785     {
2786       hi = 0;
2787       lo = (HOST_WIDE_INT) 1 << bitpos;
2788     }
2789   else
2790     {
2791       hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
2792       lo = 0;
2793     }
2794
2795   op1 = expand_binop (imode, and_optab, op1,
2796                       immed_double_const (lo, hi, imode),
2797                       NULL_RTX, 1, OPTAB_LIB_WIDEN);
2798
2799   label = gen_label_rtx ();
2800   emit_cmp_and_jump_insns (op1, const0_rtx, EQ, NULL_RTX, imode, 1, label);
2801
2802   if (GET_CODE (op0) == CONST_DOUBLE)
2803     op0 = simplify_unary_operation (NEG, mode, op0, mode);
2804   else
2805     op0 = expand_unop (mode, neg_optab, op0, target, 0);
2806   if (op0 != target)
2807     emit_move_insn (target, op0);
2808
2809   emit_label (label);
2810
2811   return target;
2812 }
2813
2814
2815 /* A subroutine of expand_copysign, perform the entire copysign operation
2816    with integer bitmasks.  BITPOS is the position of the sign bit; OP0_IS_ABS
2817    is true if op0 is known to have its sign bit clear.  */
2818
2819 static rtx
2820 expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target,
2821                      int bitpos, bool op0_is_abs)
2822 {
2823   enum machine_mode imode;
2824   HOST_WIDE_INT hi, lo;
2825   int word, nwords, i;
2826   rtx temp, insns;
2827
2828   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
2829     {
2830       imode = int_mode_for_mode (mode);
2831       if (imode == BLKmode)
2832         return NULL_RTX;
2833       word = 0;
2834       nwords = 1;
2835     }
2836   else
2837     {
2838       imode = word_mode;
2839
2840       if (FLOAT_WORDS_BIG_ENDIAN)
2841         word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2842       else
2843         word = bitpos / BITS_PER_WORD;
2844       bitpos = bitpos % BITS_PER_WORD;
2845       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
2846     }
2847
2848   if (bitpos < HOST_BITS_PER_WIDE_INT)
2849     {
2850       hi = 0;
2851       lo = (HOST_WIDE_INT) 1 << bitpos;
2852     }
2853   else
2854     {
2855       hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
2856       lo = 0;
2857     }
2858
2859   if (target == 0 || target == op0 || target == op1)
2860     target = gen_reg_rtx (mode);
2861
2862   if (nwords > 1)
2863     {
2864       start_sequence ();
2865
2866       for (i = 0; i < nwords; ++i)
2867         {
2868           rtx targ_piece = operand_subword (target, i, 1, mode);
2869           rtx op0_piece = operand_subword_force (op0, i, mode);
2870
2871           if (i == word)
2872             {
2873               if (!op0_is_abs)
2874                 op0_piece = expand_binop (imode, and_optab, op0_piece,
2875                                           immed_double_const (~lo, ~hi, imode),
2876                                           NULL_RTX, 1, OPTAB_LIB_WIDEN);
2877
2878               op1 = expand_binop (imode, and_optab,
2879                                   operand_subword_force (op1, i, mode),
2880                                   immed_double_const (lo, hi, imode),
2881                                   NULL_RTX, 1, OPTAB_LIB_WIDEN);
2882
2883               temp = expand_binop (imode, ior_optab, op0_piece, op1,
2884                                    targ_piece, 1, OPTAB_LIB_WIDEN);
2885               if (temp != targ_piece)
2886                 emit_move_insn (targ_piece, temp);
2887             }
2888           else
2889             emit_move_insn (targ_piece, op0_piece);
2890         }
2891
2892       insns = get_insns ();
2893       end_sequence ();
2894
2895       emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
2896     }
2897   else
2898     {
2899       op1 = expand_binop (imode, and_optab, gen_lowpart (imode, op1),
2900                           immed_double_const (lo, hi, imode),
2901                           NULL_RTX, 1, OPTAB_LIB_WIDEN);
2902
2903       op0 = gen_lowpart (imode, op0);
2904       if (!op0_is_abs)
2905         op0 = expand_binop (imode, and_optab, op0,
2906                             immed_double_const (~lo, ~hi, imode),
2907                             NULL_RTX, 1, OPTAB_LIB_WIDEN);
2908
2909       temp = expand_binop (imode, ior_optab, op0, op1,
2910                            gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
2911       target = lowpart_subreg_maybe_copy (mode, temp, imode);
2912     }
2913
2914   return target;
2915 }
2916
2917 /* Expand the C99 copysign operation.  OP0 and OP1 must be the same
2918    scalar floating point mode.  Return NULL if we do not know how to
2919    expand the operation inline.  */
2920
2921 rtx
2922 expand_copysign (rtx op0, rtx op1, rtx target)
2923 {
2924   enum machine_mode mode = GET_MODE (op0);
2925   const struct real_format *fmt;
2926   bool op0_is_abs;
2927   rtx temp;
2928
2929   gcc_assert (SCALAR_FLOAT_MODE_P (mode));
2930   gcc_assert (GET_MODE (op1) == mode);
2931
2932   /* First try to do it with a special instruction.  */
2933   temp = expand_binop (mode, copysign_optab, op0, op1,
2934                        target, 0, OPTAB_DIRECT);
2935   if (temp)
2936     return temp;
2937
2938   fmt = REAL_MODE_FORMAT (mode);
2939   if (fmt == NULL || !fmt->has_signed_zero)
2940     return NULL_RTX;
2941
2942   op0_is_abs = false;
2943   if (GET_CODE (op0) == CONST_DOUBLE)
2944     {
2945       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
2946         op0 = simplify_unary_operation (ABS, mode, op0, mode);
2947       op0_is_abs = true;
2948     }
2949
2950   if (fmt->signbit_ro >= 0
2951       && (GET_CODE (op0) == CONST_DOUBLE
2952           || (neg_optab->handlers[mode].insn_code != CODE_FOR_nothing
2953               && abs_optab->handlers[mode].insn_code != CODE_FOR_nothing)))
2954     {
2955       temp = expand_copysign_absneg (mode, op0, op1, target,
2956                                      fmt->signbit_ro, op0_is_abs);
2957       if (temp)
2958         return temp;
2959     }
2960
2961   if (fmt->signbit_rw < 0)
2962     return NULL_RTX;
2963   return expand_copysign_bit (mode, op0, op1, target,
2964                               fmt->signbit_rw, op0_is_abs);
2965 }
2966 \f
2967 /* Generate an instruction whose insn-code is INSN_CODE,
2968    with two operands: an output TARGET and an input OP0.
2969    TARGET *must* be nonzero, and the output is always stored there.
2970    CODE is an rtx code such that (CODE OP0) is an rtx that describes
2971    the value that is stored into TARGET.  */
2972
2973 void
2974 emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code)
2975 {
2976   rtx temp;
2977   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
2978   rtx pat;
2979
2980   temp = target;
2981
2982   /* Now, if insn does not accept our operands, put them into pseudos.  */
2983
2984   if (!insn_data[icode].operand[1].predicate (op0, mode0))
2985     op0 = copy_to_mode_reg (mode0, op0);
2986
2987   if (!insn_data[icode].operand[0].predicate (temp, GET_MODE (temp)))
2988     temp = gen_reg_rtx (GET_MODE (temp));
2989
2990   pat = GEN_FCN (icode) (temp, op0);
2991
2992   if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX && code != UNKNOWN)
2993     add_equal_note (pat, temp, code, op0, NULL_RTX);
2994
2995   emit_insn (pat);
2996
2997   if (temp != target)
2998     emit_move_insn (target, temp);
2999 }
3000 \f
3001 struct no_conflict_data
3002 {
3003   rtx target, first, insn;
3004   bool must_stay;
3005 };
3006
3007 /* Called via note_stores by emit_no_conflict_block and emit_libcall_block.
3008    Set P->must_stay if the currently examined clobber / store has to stay
3009    in the list of insns that constitute the actual no_conflict block /
3010    libcall block.  */
3011 static void
3012 no_conflict_move_test (rtx dest, rtx set, void *p0)
3013 {
3014   struct no_conflict_data *p= p0;
3015
3016   /* If this inns directly contributes to setting the target, it must stay.  */
3017   if (reg_overlap_mentioned_p (p->target, dest))
3018     p->must_stay = true;
3019   /* If we haven't committed to keeping any other insns in the list yet,
3020      there is nothing more to check.  */
3021   else if (p->insn == p->first)
3022     return;
3023   /* If this insn sets / clobbers a register that feeds one of the insns
3024      already in the list, this insn has to stay too.  */
3025   else if (reg_overlap_mentioned_p (dest, PATTERN (p->first))
3026            || (CALL_P (p->first) && (find_reg_fusage (p->first, USE, dest)))
3027            || reg_used_between_p (dest, p->first, p->insn)
3028            /* Likewise if this insn depends on a register set by a previous
3029               insn in the list, or if it sets a result (presumably a hard
3030               register) that is set or clobbered by a previous insn.
3031               N.B. the modified_*_p (SET_DEST...) tests applied to a MEM
3032               SET_DEST perform the former check on the address, and the latter
3033               check on the MEM.  */
3034            || (GET_CODE (set) == SET
3035                && (modified_in_p (SET_SRC (set), p->first)
3036                    || modified_in_p (SET_DEST (set), p->first)
3037                    || modified_between_p (SET_SRC (set), p->first, p->insn)
3038                    || modified_between_p (SET_DEST (set), p->first, p->insn))))
3039     p->must_stay = true;
3040 }
3041
3042 /* Emit code to perform a series of operations on a multi-word quantity, one
3043    word at a time.
3044
3045    Such a block is preceded by a CLOBBER of the output, consists of multiple
3046    insns, each setting one word of the output, and followed by a SET copying
3047    the output to itself.
3048
3049    Each of the insns setting words of the output receives a REG_NO_CONFLICT
3050    note indicating that it doesn't conflict with the (also multi-word)
3051    inputs.  The entire block is surrounded by REG_LIBCALL and REG_RETVAL
3052    notes.
3053
3054    INSNS is a block of code generated to perform the operation, not including
3055    the CLOBBER and final copy.  All insns that compute intermediate values
3056    are first emitted, followed by the block as described above.
3057
3058    TARGET, OP0, and OP1 are the output and inputs of the operations,
3059    respectively.  OP1 may be zero for a unary operation.
3060
3061    EQUIV, if nonzero, is an expression to be placed into a REG_EQUAL note
3062    on the last insn.
3063
3064    If TARGET is not a register, INSNS is simply emitted with no special
3065    processing.  Likewise if anything in INSNS is not an INSN or if
3066    there is a libcall block inside INSNS.
3067
3068    The final insn emitted is returned.  */
3069
3070 rtx
3071 emit_no_conflict_block (rtx insns, rtx target, rtx op0, rtx op1, rtx equiv)
3072 {
3073   rtx prev, next, first, last, insn;
3074
3075   if (!REG_P (target) || reload_in_progress)
3076     return emit_insn (insns);
3077   else
3078     for (insn = insns; insn; insn = NEXT_INSN (insn))
3079       if (!NONJUMP_INSN_P (insn)
3080           || find_reg_note (insn, REG_LIBCALL, NULL_RTX))
3081         return emit_insn (insns);
3082
3083   /* First emit all insns that do not store into words of the output and remove
3084      these from the list.  */
3085   for (insn = insns; insn; insn = next)
3086     {
3087       rtx note;
3088       struct no_conflict_data data;
3089
3090       next = NEXT_INSN (insn);
3091
3092       /* Some ports (cris) create a libcall regions at their own.  We must
3093          avoid any potential nesting of LIBCALLs.  */
3094       if ((note = find_reg_note (insn, REG_LIBCALL, NULL)) != NULL)
3095         remove_note (insn, note);
3096       if ((note = find_reg_note (insn, REG_RETVAL, NULL)) != NULL)
3097         remove_note (insn, note);
3098
3099       data.target = target;
3100       data.first = insns;
3101       data.insn = insn;
3102       data.must_stay = 0;
3103       note_stores (PATTERN (insn), no_conflict_move_test, &data);
3104       if (! data.must_stay)
3105         {
3106           if (PREV_INSN (insn))
3107             NEXT_INSN (PREV_INSN (insn)) = next;
3108           else
3109             insns = next;
3110
3111           if (next)
3112             PREV_INSN (next) = PREV_INSN (insn);
3113
3114           add_insn (insn);
3115         }
3116     }
3117
3118   prev = get_last_insn ();
3119
3120   /* Now write the CLOBBER of the output, followed by the setting of each
3121      of the words, followed by the final copy.  */
3122   if (target != op0 && target != op1)
3123     emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
3124
3125   for (insn = insns; insn; insn = next)
3126     {
3127       next = NEXT_INSN (insn);
3128       add_insn (insn);
3129
3130       if (op1 && REG_P (op1))
3131         REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op1,
3132                                               REG_NOTES (insn));
3133
3134       if (op0 && REG_P (op0))
3135         REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op0,
3136                                               REG_NOTES (insn));
3137     }
3138
3139   if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
3140       != CODE_FOR_nothing)
3141     {
3142       last = emit_move_insn (target, target);
3143       if (equiv)
3144         set_unique_reg_note (last, REG_EQUAL, equiv);
3145     }
3146   else
3147     {
3148       last = get_last_insn ();
3149
3150       /* Remove any existing REG_EQUAL note from "last", or else it will
3151          be mistaken for a note referring to the full contents of the
3152          alleged libcall value when found together with the REG_RETVAL
3153          note added below.  An existing note can come from an insn
3154          expansion at "last".  */
3155       remove_note (last, find_reg_note (last, REG_EQUAL, NULL_RTX));
3156     }
3157
3158   if (prev == 0)
3159     first = get_insns ();
3160   else
3161     first = NEXT_INSN (prev);
3162
3163   /* Encapsulate the block so it gets manipulated as a unit.  */
3164   REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
3165                                          REG_NOTES (first));
3166   REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
3167
3168   return last;
3169 }
3170 \f
3171 /* Emit code to make a call to a constant function or a library call.
3172
3173    INSNS is a list containing all insns emitted in the call.
3174    These insns leave the result in RESULT.  Our block is to copy RESULT
3175    to TARGET, which is logically equivalent to EQUIV.
3176
3177    We first emit any insns that set a pseudo on the assumption that these are
3178    loading constants into registers; doing so allows them to be safely cse'ed
3179    between blocks.  Then we emit all the other insns in the block, followed by
3180    an insn to move RESULT to TARGET.  This last insn will have a REQ_EQUAL
3181    note with an operand of EQUIV.
3182
3183    Moving assignments to pseudos outside of the block is done to improve
3184    the generated code, but is not required to generate correct code,
3185    hence being unable to move an assignment is not grounds for not making
3186    a libcall block.  There are two reasons why it is safe to leave these
3187    insns inside the block: First, we know that these pseudos cannot be
3188    used in generated RTL outside the block since they are created for
3189    temporary purposes within the block.  Second, CSE will not record the
3190    values of anything set inside a libcall block, so we know they must
3191    be dead at the end of the block.
3192
3193    Except for the first group of insns (the ones setting pseudos), the
3194    block is delimited by REG_RETVAL and REG_LIBCALL notes.  */
3195
3196 void
3197 emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
3198 {
3199   rtx final_dest = target;
3200   rtx prev, next, first, last, insn;
3201
3202   /* If this is a reg with REG_USERVAR_P set, then it could possibly turn
3203      into a MEM later.  Protect the libcall block from this change.  */
3204   if (! REG_P (target) || REG_USERVAR_P (target))
3205     target = gen_reg_rtx (GET_MODE (target));
3206
3207   /* If we're using non-call exceptions, a libcall corresponding to an
3208      operation that may trap may also trap.  */
3209   if (flag_non_call_exceptions && may_trap_p (equiv))
3210     {
3211       for (insn = insns; insn; insn = NEXT_INSN (insn))
3212         if (CALL_P (insn))
3213           {
3214             rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3215
3216             if (note != 0 && INTVAL (XEXP (note, 0)) <= 0)
3217               remove_note (insn, note);
3218           }
3219     }
3220   else
3221   /* look for any CALL_INSNs in this sequence, and attach a REG_EH_REGION
3222      reg note to indicate that this call cannot throw or execute a nonlocal
3223      goto (unless there is already a REG_EH_REGION note, in which case
3224      we update it).  */
3225     for (insn = insns; insn; insn = NEXT_INSN (insn))
3226       if (CALL_P (insn))
3227         {
3228           rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3229
3230           if (note != 0)
3231             XEXP (note, 0) = constm1_rtx;
3232           else
3233             REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, constm1_rtx,
3234                                                   REG_NOTES (insn));
3235         }
3236
3237   /* First emit all insns that set pseudos.  Remove them from the list as
3238      we go.  Avoid insns that set pseudos which were referenced in previous
3239      insns.  These can be generated by move_by_pieces, for example,
3240      to update an address.  Similarly, avoid insns that reference things
3241      set in previous insns.  */
3242
3243   for (insn = insns; insn; insn = next)
3244     {
3245       rtx set = single_set (insn);
3246       rtx note;
3247
3248       /* Some ports (cris) create a libcall regions at their own.  We must
3249          avoid any potential nesting of LIBCALLs.  */
3250       if ((note = find_reg_note (insn, REG_LIBCALL, NULL)) != NULL)
3251         remove_note (insn, note);
3252       if ((note = find_reg_note (insn, REG_RETVAL, NULL)) != NULL)
3253         remove_note (insn, note);
3254
3255       next = NEXT_INSN (insn);
3256
3257       if (set != 0 && REG_P (SET_DEST (set))
3258           && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
3259         {
3260           struct no_conflict_data data;
3261
3262           data.target = const0_rtx;
3263           data.first = insns;
3264           data.insn = insn;
3265           data.must_stay = 0;
3266           note_stores (PATTERN (insn), no_conflict_move_test, &data);
3267           if (! data.must_stay)
3268             {
3269               if (PREV_INSN (insn))
3270                 NEXT_INSN (PREV_INSN (insn)) = next;
3271               else
3272                 insns = next;
3273
3274               if (next)
3275                 PREV_INSN (next) = PREV_INSN (insn);
3276
3277               add_insn (insn);
3278             }
3279         }
3280
3281       /* Some ports use a loop to copy large arguments onto the stack.
3282          Don't move anything outside such a loop.  */
3283       if (LABEL_P (insn))
3284         break;
3285     }
3286
3287   prev = get_last_insn ();
3288
3289   /* Write the remaining insns followed by the final copy.  */
3290
3291   for (insn = insns; insn; insn = next)
3292     {
3293       next = NEXT_INSN (insn);
3294
3295       add_insn (insn);
3296     }
3297
3298   last = emit_move_insn (target, result);
3299   if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
3300       != CODE_FOR_nothing)
3301     set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
3302   else
3303     {
3304       /* Remove any existing REG_EQUAL note from "last", or else it will
3305          be mistaken for a note referring to the full contents of the
3306          libcall value when found together with the REG_RETVAL note added
3307          below.  An existing note can come from an insn expansion at
3308          "last".  */
3309       remove_note (last, find_reg_note (last, REG_EQUAL, NULL_RTX));
3310     }
3311
3312   if (final_dest != target)
3313     emit_move_insn (final_dest, target);
3314
3315   if (prev == 0)
3316     first = get_insns ();
3317   else
3318     first = NEXT_INSN (prev);
3319
3320   /* Encapsulate the block so it gets manipulated as a unit.  */
3321   if (!flag_non_call_exceptions || !may_trap_p (equiv))
3322     {
3323       /* We can't attach the REG_LIBCALL and REG_RETVAL notes
3324          when the encapsulated region would not be in one basic block,
3325          i.e. when there is a control_flow_insn_p insn between FIRST and LAST.
3326        */
3327       bool attach_libcall_retval_notes = true;
3328       next = NEXT_INSN (last);
3329       for (insn = first; insn != next; insn = NEXT_INSN (insn))
3330         if (control_flow_insn_p (insn))
3331           {
3332             attach_libcall_retval_notes = false;
3333             break;
3334           }
3335
3336       if (attach_libcall_retval_notes)
3337         {
3338           REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
3339                                                  REG_NOTES (first));
3340           REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first,
3341                                                 REG_NOTES (last));
3342         }
3343     }
3344 }
3345 \f
3346 /* Nonzero if we can perform a comparison of mode MODE straightforwardly.
3347    PURPOSE describes how this comparison will be used.  CODE is the rtx
3348    comparison code we will be using.
3349
3350    ??? Actually, CODE is slightly weaker than that.  A target is still
3351    required to implement all of the normal bcc operations, but not
3352    required to implement all (or any) of the unordered bcc operations.  */
3353
3354 int
3355 can_compare_p (enum rtx_code code, enum machine_mode mode,
3356                enum can_compare_purpose purpose)
3357 {
3358   do
3359     {
3360       if (cmp_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
3361         {
3362           if (purpose == ccp_jump)
3363             return bcc_gen_fctn[(int) code] != NULL;
3364           else if (purpose == ccp_store_flag)
3365             return setcc_gen_code[(int) code] != CODE_FOR_nothing;
3366           else
3367             /* There's only one cmov entry point, and it's allowed to fail.  */
3368             return 1;
3369         }
3370       if (purpose == ccp_jump
3371           && cbranch_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
3372         return 1;
3373       if (purpose == ccp_cmov
3374           && cmov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
3375         return 1;
3376       if (purpose == ccp_store_flag
3377           && cstore_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
3378         return 1;
3379       mode = GET_MODE_WIDER_MODE (mode);
3380     }
3381   while (mode != VOIDmode);
3382
3383   return 0;
3384 }
3385
3386 /* This function is called when we are going to emit a compare instruction that
3387    compares the values found in *PX and *PY, using the rtl operator COMPARISON.
3388
3389    *PMODE is the mode of the inputs (in case they are const_int).
3390    *PUNSIGNEDP nonzero says that the operands are unsigned;
3391    this matters if they need to be widened.
3392
3393    If they have mode BLKmode, then SIZE specifies the size of both operands.
3394
3395    This function performs all the setup necessary so that the caller only has
3396    to emit a single comparison insn.  This setup can involve doing a BLKmode
3397    comparison or emitting a library call to perform the comparison if no insn
3398    is available to handle it.
3399    The values which are passed in through pointers can be modified; the caller
3400    should perform the comparison on the modified values.  Constant
3401    comparisons must have already been folded.  */
3402
3403 static void
3404 prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
3405                   enum machine_mode *pmode, int *punsignedp,
3406                   enum can_compare_purpose purpose)
3407 {
3408   enum machine_mode mode = *pmode;
3409   rtx x = *px, y = *py;
3410   int unsignedp = *punsignedp;
3411   enum mode_class class;
3412
3413   class = GET_MODE_CLASS (mode);
3414
3415   /* If we are inside an appropriately-short loop and we are optimizing,
3416      force expensive constants into a register.  */
3417   if (CONSTANT_P (x) && optimize
3418       && rtx_cost (x, COMPARE) > COSTS_N_INSNS (1))
3419     x = force_reg (mode, x);
3420
3421   if (CONSTANT_P (y) && optimize
3422       && rtx_cost (y, COMPARE) > COSTS_N_INSNS (1))
3423     y = force_reg (mode, y);
3424
3425 #ifdef HAVE_cc0
3426   /* Make sure if we have a canonical comparison.  The RTL
3427      documentation states that canonical comparisons are required only
3428      for targets which have cc0.  */
3429   gcc_assert (!CONSTANT_P (x) || CONSTANT_P (y));
3430 #endif
3431
3432   /* Don't let both operands fail to indicate the mode.  */
3433   if (GET_MODE (x) == VOIDmode && GET_MODE (y) == VOIDmode)
3434     x = force_reg (mode, x);
3435
3436   /* Handle all BLKmode compares.  */
3437