OSDN Git Service

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