OSDN Git Service

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