OSDN Git Service

* tree.h (DECIMAL_FLOAT_TYPE_P): New.
[pf3gnuchains/gcc-fork.git] / gcc / convert.c
1 /* Utility routines for data type conversion for GCC.
2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
3    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 /* These routines are somewhat language-independent utility function
24    intended to be called by the language-specific convert () functions.  */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31 #include "flags.h"
32 #include "convert.h"
33 #include "toplev.h"
34 #include "langhooks.h"
35 #include "real.h"
36
37 /* Convert EXPR to some pointer or reference type TYPE.
38    EXPR must be pointer, reference, integer, enumeral, or literal zero;
39    in other cases error is called.  */
40
41 tree
42 convert_to_pointer (tree type, tree expr)
43 {
44   if (TREE_TYPE (expr) == type)
45     return expr;
46
47   if (integer_zerop (expr))
48     {
49       tree t = build_int_cst (type, 0);
50       if (TREE_OVERFLOW (expr) || TREE_CONSTANT_OVERFLOW (expr))
51         t = force_fit_type (t, 0, TREE_OVERFLOW (expr),
52                             TREE_CONSTANT_OVERFLOW (expr));
53       return t;
54     }
55
56   switch (TREE_CODE (TREE_TYPE (expr)))
57     {
58     case POINTER_TYPE:
59     case REFERENCE_TYPE:
60       return fold_build1 (NOP_EXPR, type, expr);
61
62     case INTEGER_TYPE:
63     case ENUMERAL_TYPE:
64     case BOOLEAN_TYPE:
65       if (TYPE_PRECISION (TREE_TYPE (expr)) != POINTER_SIZE)
66         expr = fold_build1 (NOP_EXPR,
67                             lang_hooks.types.type_for_size (POINTER_SIZE, 0),
68                             expr);
69       return fold_build1 (CONVERT_EXPR, type, expr);
70
71
72     default:
73       error ("cannot convert to a pointer type");
74       return convert_to_pointer (type, integer_zero_node);
75     }
76 }
77
78 /* Avoid any floating point extensions from EXP.  */
79 tree
80 strip_float_extensions (tree exp)
81 {
82   tree sub, expt, subt;
83
84   /*  For floating point constant look up the narrowest type that can hold
85       it properly and handle it like (type)(narrowest_type)constant.
86       This way we can optimize for instance a=a*2.0 where "a" is float
87       but 2.0 is double constant.  */
88   if (TREE_CODE (exp) == REAL_CST)
89     {
90       REAL_VALUE_TYPE orig;
91       tree type = NULL;
92
93       orig = TREE_REAL_CST (exp);
94       if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
95           && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
96         type = float_type_node;
97       else if (TYPE_PRECISION (TREE_TYPE (exp))
98                > TYPE_PRECISION (double_type_node)
99                && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
100         type = double_type_node;
101       if (type)
102         return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
103     }
104
105   if (TREE_CODE (exp) != NOP_EXPR
106       && TREE_CODE (exp) != CONVERT_EXPR)
107     return exp;
108
109   sub = TREE_OPERAND (exp, 0);
110   subt = TREE_TYPE (sub);
111   expt = TREE_TYPE (exp);
112
113   if (!FLOAT_TYPE_P (subt))
114     return exp;
115
116   if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
117     return exp;
118
119   return strip_float_extensions (sub);
120 }
121
122
123 /* Convert EXPR to some floating-point type TYPE.
124
125    EXPR must be float, integer, or enumeral;
126    in other cases error is called.  */
127
128 tree
129 convert_to_real (tree type, tree expr)
130 {
131   enum built_in_function fcode = builtin_mathfn_code (expr);
132   tree itype = TREE_TYPE (expr);
133
134   /* Disable until we figure out how to decide whether the functions are
135      present in runtime.  */
136   /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
137   if (optimize
138       && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
139           || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
140     {
141       switch (fcode)
142         {
143 #define CASE_MATHFN(FN) case BUILT_IN_##FN: case BUILT_IN_##FN##L:
144           CASE_MATHFN (ACOS)
145           CASE_MATHFN (ACOSH)
146           CASE_MATHFN (ASIN)
147           CASE_MATHFN (ASINH)
148           CASE_MATHFN (ATAN)
149           CASE_MATHFN (ATANH)
150           CASE_MATHFN (CBRT)
151           CASE_MATHFN (COS)
152           CASE_MATHFN (COSH)
153           CASE_MATHFN (ERF)
154           CASE_MATHFN (ERFC)
155           CASE_MATHFN (EXP)
156           CASE_MATHFN (EXP10)
157           CASE_MATHFN (EXP2)
158           CASE_MATHFN (EXPM1)
159           CASE_MATHFN (FABS)
160           CASE_MATHFN (GAMMA)
161           CASE_MATHFN (J0)
162           CASE_MATHFN (J1)
163           CASE_MATHFN (LGAMMA)
164           CASE_MATHFN (LOG)
165           CASE_MATHFN (LOG10)
166           CASE_MATHFN (LOG1P)
167           CASE_MATHFN (LOG2)
168           CASE_MATHFN (LOGB)
169           CASE_MATHFN (POW10)
170           CASE_MATHFN (SIN)
171           CASE_MATHFN (SINH)
172           CASE_MATHFN (SQRT)
173           CASE_MATHFN (TAN)
174           CASE_MATHFN (TANH)
175           CASE_MATHFN (TGAMMA)
176           CASE_MATHFN (Y0)
177           CASE_MATHFN (Y1)
178 #undef CASE_MATHFN
179             {
180               tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
181               tree newtype = type;
182
183               /* We have (outertype)sqrt((innertype)x).  Choose the wider mode from
184                  the both as the safe type for operation.  */
185               if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
186                 newtype = TREE_TYPE (arg0);
187
188               /* Be careful about integer to fp conversions.
189                  These may overflow still.  */
190               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
191                   && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
192                   && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
193                       || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
194                 {
195                   tree arglist;
196                   tree fn = mathfn_built_in (newtype, fcode);
197
198                   if (fn)
199                   {
200                     arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
201                     expr = build_function_call_expr (fn, arglist);
202                     if (newtype == type)
203                       return expr;
204                   }
205                 }
206             }
207         default:
208           break;
209         }
210     }
211   if (optimize
212       && (((fcode == BUILT_IN_FLOORL
213            || fcode == BUILT_IN_CEILL
214            || fcode == BUILT_IN_ROUNDL
215            || fcode == BUILT_IN_RINTL
216            || fcode == BUILT_IN_TRUNCL
217            || fcode == BUILT_IN_NEARBYINTL)
218           && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
219               || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
220           || ((fcode == BUILT_IN_FLOOR
221                || fcode == BUILT_IN_CEIL
222                || fcode == BUILT_IN_ROUND
223                || fcode == BUILT_IN_RINT
224                || fcode == BUILT_IN_TRUNC
225                || fcode == BUILT_IN_NEARBYINT)
226               && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
227     {
228       tree fn = mathfn_built_in (type, fcode);
229
230       if (fn)
231         {
232           tree arg
233             = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
234
235           /* Make sure (type)arg0 is an extension, otherwise we could end up
236              changing (float)floor(double d) into floorf((float)d), which is
237              incorrect because (float)d uses round-to-nearest and can round
238              up to the next integer.  */
239           if (TYPE_PRECISION (type) >= TYPE_PRECISION (TREE_TYPE (arg)))
240             return
241               build_function_call_expr (fn,
242                                         build_tree_list (NULL_TREE,
243                                           fold (convert_to_real (type, arg))));
244         }
245     }
246
247   /* Propagate the cast into the operation.  */
248   if (itype != type && FLOAT_TYPE_P (type))
249     switch (TREE_CODE (expr))
250       {
251         /* Convert (float)-x into -(float)x.  This is always safe.  */
252         case ABS_EXPR:
253         case NEGATE_EXPR:
254           if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
255             return build1 (TREE_CODE (expr), type,
256                            fold (convert_to_real (type,
257                                                   TREE_OPERAND (expr, 0))));
258           break;
259         /* Convert (outertype)((innertype0)a+(innertype1)b)
260            into ((newtype)a+(newtype)b) where newtype
261            is the widest mode from all of these.  */
262         case PLUS_EXPR:
263         case MINUS_EXPR:
264         case MULT_EXPR:
265         case RDIV_EXPR:
266            {
267              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
268              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
269
270              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
271                  && FLOAT_TYPE_P (TREE_TYPE (arg1)))
272                {
273                   tree newtype = type;
274
275                   if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode
276                       || TYPE_MODE (TREE_TYPE (arg1)) == SDmode)
277                     newtype = dfloat32_type_node;
278                   if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode
279                       || TYPE_MODE (TREE_TYPE (arg1)) == DDmode)
280                     newtype = dfloat64_type_node;
281                   if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode
282                       || TYPE_MODE (TREE_TYPE (arg1)) == TDmode)
283                     newtype = dfloat128_type_node;
284                   if (newtype == dfloat32_type_node
285                       || newtype == dfloat64_type_node
286                       || newtype == dfloat128_type_node)
287                     {
288                       expr = build2 (TREE_CODE (expr), newtype,
289                                      fold (convert_to_real (newtype, arg0)),
290                                      fold (convert_to_real (newtype, arg1)));
291                       if (newtype == type)
292                         return expr;
293                       break;
294                     }
295
296                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
297                     newtype = TREE_TYPE (arg0);
298                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
299                     newtype = TREE_TYPE (arg1);
300                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
301                     {
302                       expr = build2 (TREE_CODE (expr), newtype,
303                                      fold (convert_to_real (newtype, arg0)),
304                                      fold (convert_to_real (newtype, arg1)));
305                       if (newtype == type)
306                         return expr;
307                     }
308                }
309            }
310           break;
311         default:
312           break;
313       }
314
315   switch (TREE_CODE (TREE_TYPE (expr)))
316     {
317     case REAL_TYPE:
318       /* Ignore the conversion if we don't need to store intermediate
319          results and neither type is a decimal float.  */
320       return build1 ((flag_float_store
321                      || DECIMAL_FLOAT_TYPE_P (type)
322                      || DECIMAL_FLOAT_TYPE_P (itype))
323                      ? CONVERT_EXPR : NOP_EXPR, type, expr);
324
325     case INTEGER_TYPE:
326     case ENUMERAL_TYPE:
327     case BOOLEAN_TYPE:
328       return build1 (FLOAT_EXPR, type, expr);
329
330     case COMPLEX_TYPE:
331       return convert (type,
332                       fold_build1 (REALPART_EXPR,
333                                    TREE_TYPE (TREE_TYPE (expr)), expr));
334
335     case POINTER_TYPE:
336     case REFERENCE_TYPE:
337       error ("pointer value used where a floating point value was expected");
338       return convert_to_real (type, integer_zero_node);
339
340     default:
341       error ("aggregate value used where a float was expected");
342       return convert_to_real (type, integer_zero_node);
343     }
344 }
345
346 /* Convert EXPR to some integer (or enum) type TYPE.
347
348    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
349    vector; in other cases error is called.
350
351    The result of this is always supposed to be a newly created tree node
352    not in use in any existing structure.  */
353
354 tree
355 convert_to_integer (tree type, tree expr)
356 {
357   enum tree_code ex_form = TREE_CODE (expr);
358   tree intype = TREE_TYPE (expr);
359   unsigned int inprec = TYPE_PRECISION (intype);
360   unsigned int outprec = TYPE_PRECISION (type);
361
362   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
363      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
364   if (!COMPLETE_TYPE_P (type))
365     {
366       error ("conversion to incomplete type");
367       return error_mark_node;
368     }
369
370   /* Convert e.g. (long)round(d) -> lround(d).  */
371   /* If we're converting to char, we may encounter differing behavior
372      between converting from double->char vs double->long->char.
373      We're in "undefined" territory but we prefer to be conservative,
374      so only proceed in "unsafe" math mode.  */
375   if (optimize
376       && (flag_unsafe_math_optimizations
377           || (long_integer_type_node
378               && outprec >= TYPE_PRECISION (long_integer_type_node))))
379     {
380       tree s_expr = strip_float_extensions (expr);
381       tree s_intype = TREE_TYPE (s_expr);
382       const enum built_in_function fcode = builtin_mathfn_code (s_expr);
383       tree fn = 0;
384       
385       switch (fcode)
386         {
387         CASE_FLT_FN (BUILT_IN_CEIL):
388           /* Only convert in ISO C99 mode.  */
389           if (!TARGET_C99_FUNCTIONS)
390             break;
391           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
392             fn = mathfn_built_in (s_intype, BUILT_IN_LLCEIL);
393           else
394             fn = mathfn_built_in (s_intype, BUILT_IN_LCEIL);
395           break;
396
397         CASE_FLT_FN (BUILT_IN_FLOOR):
398           /* Only convert in ISO C99 mode.  */
399           if (!TARGET_C99_FUNCTIONS)
400             break;
401           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
402             fn = mathfn_built_in (s_intype, BUILT_IN_LLFLOOR);
403           else
404             fn = mathfn_built_in (s_intype, BUILT_IN_LFLOOR);
405           break;
406
407         CASE_FLT_FN (BUILT_IN_ROUND):
408           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
409             fn = mathfn_built_in (s_intype, BUILT_IN_LLROUND);
410           else
411             fn = mathfn_built_in (s_intype, BUILT_IN_LROUND);
412           break;
413
414         CASE_FLT_FN (BUILT_IN_RINT):
415           /* Only convert rint* if we can ignore math exceptions.  */
416           if (flag_trapping_math)
417             break;
418           /* ... Fall through ...  */
419         CASE_FLT_FN (BUILT_IN_NEARBYINT):
420           if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (long_long_integer_type_node))
421             fn = mathfn_built_in (s_intype, BUILT_IN_LLRINT);
422           else
423             fn = mathfn_built_in (s_intype, BUILT_IN_LRINT);
424           break;
425
426         CASE_FLT_FN (BUILT_IN_TRUNC):
427           {
428             tree arglist = TREE_OPERAND (s_expr, 1);
429             return convert_to_integer (type, TREE_VALUE (arglist));
430           }
431
432         default:
433           break;
434         }
435       
436       if (fn)
437         {
438           tree arglist = TREE_OPERAND (s_expr, 1);
439           tree newexpr = build_function_call_expr (fn, arglist);
440           return convert_to_integer (type, newexpr);
441         }
442     }
443
444   switch (TREE_CODE (intype))
445     {
446     case POINTER_TYPE:
447     case REFERENCE_TYPE:
448       if (integer_zerop (expr))
449         return build_int_cst (type, 0);
450
451       /* Convert to an unsigned integer of the correct width first,
452          and from there widen/truncate to the required type.  */
453       expr = fold_build1 (CONVERT_EXPR,
454                           lang_hooks.types.type_for_size (POINTER_SIZE, 0),
455                           expr);
456       return fold_convert (type, expr);
457
458     case INTEGER_TYPE:
459     case ENUMERAL_TYPE:
460     case BOOLEAN_TYPE:
461       /* If this is a logical operation, which just returns 0 or 1, we can
462          change the type of the expression.  */
463
464       if (TREE_CODE_CLASS (ex_form) == tcc_comparison)
465         {
466           expr = copy_node (expr);
467           TREE_TYPE (expr) = type;
468           return expr;
469         }
470
471       /* If we are widening the type, put in an explicit conversion.
472          Similarly if we are not changing the width.  After this, we know
473          we are truncating EXPR.  */
474
475       else if (outprec >= inprec)
476         {
477           enum tree_code code;
478
479           /* If the precision of the EXPR's type is K bits and the
480              destination mode has more bits, and the sign is changing,
481              it is not safe to use a NOP_EXPR.  For example, suppose
482              that EXPR's type is a 3-bit unsigned integer type, the
483              TYPE is a 3-bit signed integer type, and the machine mode
484              for the types is 8-bit QImode.  In that case, the
485              conversion necessitates an explicit sign-extension.  In
486              the signed-to-unsigned case the high-order bits have to
487              be cleared.  */
488           if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr))
489               && (TYPE_PRECISION (TREE_TYPE (expr))
490                   != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
491             code = CONVERT_EXPR;
492           else
493             code = NOP_EXPR;
494
495           return fold_build1 (code, type, expr);
496         }
497
498       /* If TYPE is an enumeral type or a type with a precision less
499          than the number of bits in its mode, do the conversion to the
500          type corresponding to its mode, then do a nop conversion
501          to TYPE.  */
502       else if (TREE_CODE (type) == ENUMERAL_TYPE
503                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
504         return build1 (NOP_EXPR, type,
505                        convert (lang_hooks.types.type_for_mode
506                                 (TYPE_MODE (type), TYPE_UNSIGNED (type)),
507                                 expr));
508
509       /* Here detect when we can distribute the truncation down past some
510          arithmetic.  For example, if adding two longs and converting to an
511          int, we can equally well convert both to ints and then add.
512          For the operations handled here, such truncation distribution
513          is always safe.
514          It is desirable in these cases:
515          1) when truncating down to full-word from a larger size
516          2) when truncating takes no work.
517          3) when at least one operand of the arithmetic has been extended
518          (as by C's default conversions).  In this case we need two conversions
519          if we do the arithmetic as already requested, so we might as well
520          truncate both and then combine.  Perhaps that way we need only one.
521
522          Note that in general we cannot do the arithmetic in a type
523          shorter than the desired result of conversion, even if the operands
524          are both extended from a shorter type, because they might overflow
525          if combined in that type.  The exceptions to this--the times when
526          two narrow values can be combined in their narrow type even to
527          make a wider result--are handled by "shorten" in build_binary_op.  */
528
529       switch (ex_form)
530         {
531         case RSHIFT_EXPR:
532           /* We can pass truncation down through right shifting
533              when the shift count is a nonpositive constant.  */
534           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
535               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) <= 0)
536             goto trunc1;
537           break;
538
539         case LSHIFT_EXPR:
540           /* We can pass truncation down through left shifting
541              when the shift count is a nonnegative constant and
542              the target type is unsigned.  */
543           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
544               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
545               && TYPE_UNSIGNED (type)
546               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
547             {
548               /* If shift count is less than the width of the truncated type,
549                  really shift.  */
550               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
551                 /* In this case, shifting is like multiplication.  */
552                 goto trunc1;
553               else
554                 {
555                   /* If it is >= that width, result is zero.
556                      Handling this with trunc1 would give the wrong result:
557                      (int) ((long long) a << 32) is well defined (as 0)
558                      but (int) a << 32 is undefined and would get a
559                      warning.  */
560
561                   tree t = build_int_cst (type, 0);
562
563                   /* If the original expression had side-effects, we must
564                      preserve it.  */
565                   if (TREE_SIDE_EFFECTS (expr))
566                     return build2 (COMPOUND_EXPR, type, expr, t);
567                   else
568                     return t;
569                 }
570             }
571           break;
572
573         case MAX_EXPR:
574         case MIN_EXPR:
575         case MULT_EXPR:
576           {
577             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
578             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
579
580             /* Don't distribute unless the output precision is at least as big
581                as the actual inputs.  Otherwise, the comparison of the
582                truncated values will be wrong.  */
583             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
584                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
585                 /* If signedness of arg0 and arg1 don't match,
586                    we can't necessarily find a type to compare them in.  */
587                 && (TYPE_UNSIGNED (TREE_TYPE (arg0))
588                     == TYPE_UNSIGNED (TREE_TYPE (arg1))))
589               goto trunc1;
590             break;
591           }
592
593         case PLUS_EXPR:
594         case MINUS_EXPR:
595         case BIT_AND_EXPR:
596         case BIT_IOR_EXPR:
597         case BIT_XOR_EXPR:
598         trunc1:
599           {
600             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
601             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
602
603             if (outprec >= BITS_PER_WORD
604                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
605                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
606                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
607               {
608                 /* Do the arithmetic in type TYPEX,
609                    then convert result to TYPE.  */
610                 tree typex = type;
611
612                 /* Can't do arithmetic in enumeral types
613                    so use an integer type that will hold the values.  */
614                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
615                   typex = lang_hooks.types.type_for_size
616                     (TYPE_PRECISION (typex), TYPE_UNSIGNED (typex));
617
618                 /* But now perhaps TYPEX is as wide as INPREC.
619                    In that case, do nothing special here.
620                    (Otherwise would recurse infinitely in convert.  */
621                 if (TYPE_PRECISION (typex) != inprec)
622                   {
623                     /* Don't do unsigned arithmetic where signed was wanted,
624                        or vice versa.
625                        Exception: if both of the original operands were
626                        unsigned then we can safely do the work as unsigned.
627                        Exception: shift operations take their type solely
628                        from the first argument.
629                        Exception: the LSHIFT_EXPR case above requires that
630                        we perform this operation unsigned lest we produce
631                        signed-overflow undefinedness.
632                        And we may need to do it as unsigned
633                        if we truncate to the original size.  */
634                     if (TYPE_UNSIGNED (TREE_TYPE (expr))
635                         || (TYPE_UNSIGNED (TREE_TYPE (arg0))
636                             && (TYPE_UNSIGNED (TREE_TYPE (arg1))
637                                 || ex_form == LSHIFT_EXPR
638                                 || ex_form == RSHIFT_EXPR
639                                 || ex_form == LROTATE_EXPR
640                                 || ex_form == RROTATE_EXPR))
641                         || ex_form == LSHIFT_EXPR
642                         /* If we have !flag_wrapv, and either ARG0 or
643                            ARG1 is of a signed type, we have to do
644                            PLUS_EXPR or MINUS_EXPR in an unsigned
645                            type.  Otherwise, we would introduce
646                            signed-overflow undefinedness.  */
647                         || (!flag_wrapv
648                             && (ex_form == PLUS_EXPR
649                                 || ex_form == MINUS_EXPR)
650                             && (!TYPE_UNSIGNED (TREE_TYPE (arg0))
651                                 || !TYPE_UNSIGNED (TREE_TYPE (arg1)))))
652                       typex = lang_hooks.types.unsigned_type (typex);
653                     else
654                       typex = lang_hooks.types.signed_type (typex);
655                     return convert (type,
656                                     fold_build2 (ex_form, typex,
657                                                  convert (typex, arg0),
658                                                  convert (typex, arg1)));
659                   }
660               }
661           }
662           break;
663
664         case NEGATE_EXPR:
665         case BIT_NOT_EXPR:
666           /* This is not correct for ABS_EXPR,
667              since we must test the sign before truncation.  */
668           {
669             tree typex;
670
671             /* Don't do unsigned arithmetic where signed was wanted,
672                or vice versa.  */
673             if (TYPE_UNSIGNED (TREE_TYPE (expr)))
674               typex = lang_hooks.types.unsigned_type (type);
675             else
676               typex = lang_hooks.types.signed_type (type);
677             return convert (type,
678                             fold_build1 (ex_form, typex,
679                                          convert (typex,
680                                                   TREE_OPERAND (expr, 0))));
681           }
682
683         case NOP_EXPR:
684           /* Don't introduce a
685              "can't convert between vector values of different size" error.  */
686           if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
687               && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
688                   != GET_MODE_SIZE (TYPE_MODE (type))))
689             break;
690           /* If truncating after truncating, might as well do all at once.
691              If truncating after extending, we may get rid of wasted work.  */
692           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
693
694         case COND_EXPR:
695           /* It is sometimes worthwhile to push the narrowing down through
696              the conditional and never loses.  */
697           return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
698                               convert (type, TREE_OPERAND (expr, 1)),
699                               convert (type, TREE_OPERAND (expr, 2)));
700
701         default:
702           break;
703         }
704
705       return build1 (CONVERT_EXPR, type, expr);
706
707     case REAL_TYPE:
708       return build1 (FIX_TRUNC_EXPR, type, expr);
709
710     case COMPLEX_TYPE:
711       return convert (type,
712                       fold_build1 (REALPART_EXPR,
713                                    TREE_TYPE (TREE_TYPE (expr)), expr));
714
715     case VECTOR_TYPE:
716       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
717         {
718           error ("can't convert between vector values of different size");
719           return error_mark_node;
720         }
721       return build1 (VIEW_CONVERT_EXPR, type, expr);
722
723     default:
724       error ("aggregate value used where an integer was expected");
725       return convert (type, integer_zero_node);
726     }
727 }
728
729 /* Convert EXPR to the complex type TYPE in the usual ways.  */
730
731 tree
732 convert_to_complex (tree type, tree expr)
733 {
734   tree subtype = TREE_TYPE (type);
735
736   switch (TREE_CODE (TREE_TYPE (expr)))
737     {
738     case REAL_TYPE:
739     case INTEGER_TYPE:
740     case ENUMERAL_TYPE:
741     case BOOLEAN_TYPE:
742       return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
743                      convert (subtype, integer_zero_node));
744
745     case COMPLEX_TYPE:
746       {
747         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
748
749         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
750           return expr;
751         else if (TREE_CODE (expr) == COMPLEX_EXPR)
752           return fold_build2 (COMPLEX_EXPR, type,
753                               convert (subtype, TREE_OPERAND (expr, 0)),
754                               convert (subtype, TREE_OPERAND (expr, 1)));
755         else
756           {
757             expr = save_expr (expr);
758             return
759               fold_build2 (COMPLEX_EXPR, type,
760                            convert (subtype,
761                                     fold_build1 (REALPART_EXPR,
762                                                  TREE_TYPE (TREE_TYPE (expr)),
763                                                  expr)),
764                            convert (subtype,
765                                     fold_build1 (IMAGPART_EXPR,
766                                                  TREE_TYPE (TREE_TYPE (expr)),
767                                                  expr)));
768           }
769       }
770
771     case POINTER_TYPE:
772     case REFERENCE_TYPE:
773       error ("pointer value used where a complex was expected");
774       return convert_to_complex (type, integer_zero_node);
775
776     default:
777       error ("aggregate value used where a complex was expected");
778       return convert_to_complex (type, integer_zero_node);
779     }
780 }
781
782 /* Convert EXPR to the vector type TYPE in the usual ways.  */
783
784 tree
785 convert_to_vector (tree type, tree expr)
786 {
787   switch (TREE_CODE (TREE_TYPE (expr)))
788     {
789     case INTEGER_TYPE:
790     case VECTOR_TYPE:
791       if (!tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (expr))))
792         {
793           error ("can't convert between vector values of different size");
794           return error_mark_node;
795         }
796       return build1 (VIEW_CONVERT_EXPR, type, expr);
797
798     default:
799       error ("can't convert value to a vector");
800       return error_mark_node;
801     }
802 }