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 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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, 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 /* Convert EXPR to some pointer or reference type TYPE.
  37
  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 (integer_zerop (expr))
  45     {
  46       expr = build_int_2 (0, 0);
  47       TREE_TYPE (expr) = type;
  48       return expr;
  49     }
  50
  51   switch (TREE_CODE (TREE_TYPE (expr)))
  52     {
  53     case POINTER_TYPE:
  54     case REFERENCE_TYPE:
  55       return build1 (NOP_EXPR, type, expr);
  56
  57     case INTEGER_TYPE:
  58     case ENUMERAL_TYPE:
  59     case BOOLEAN_TYPE:
  60     case CHAR_TYPE:
  61       if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE)
  62         return build1 (CONVERT_EXPR, type, expr);
  63
  64       return
  65         convert_to_pointer (type,
  66                             convert ((*lang_hooks.types.type_for_size)
  67                                      (POINTER_SIZE, 0), expr));
  68
  69     default:
  70       error ("cannot convert to a pointer type");
  71       return convert_to_pointer (type, integer_zero_node);
  72     }
  73 }
  74
  75 /* Avoid any floating point extensions from EXP.  */
  76 tree
  77 strip_float_extensions (tree exp)
  78 {
  79   tree sub, expt, subt;
  80
  81   /*  For floating point constant look up the narrowest type that can hold
  82       it properly and handle it like (type)(narrowest_type)constant.
  83       This way we can optimize for instance a=a*2.0 where "a" is float
  84       but 2.0 is double constant.  */
  85   if (TREE_CODE (exp) == REAL_CST)
  86     {
  87       REAL_VALUE_TYPE orig;
  88       tree type = NULL;
  89
  90       orig = TREE_REAL_CST (exp);
  91       if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node)
  92           && exact_real_truncate (TYPE_MODE (float_type_node), &orig))
  93         type = float_type_node;
  94       else if (TYPE_PRECISION (TREE_TYPE (exp))
  95                > TYPE_PRECISION (double_type_node)
  96                && exact_real_truncate (TYPE_MODE (double_type_node), &orig))
  97         type = double_type_node;
  98       if (type)
  99         return build_real (type, real_value_truncate (TYPE_MODE (type), orig));
 100     }
 101
 102   if (TREE_CODE (exp) != NOP_EXPR)
 103     return exp;
 104
 105   sub = TREE_OPERAND (exp, 0);
 106   subt = TREE_TYPE (sub);
 107   expt = TREE_TYPE (exp);
 108
 109   if (!FLOAT_TYPE_P (subt))
 110     return exp;
 111
 112   if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt))
 113     return exp;
 114
 115   return strip_float_extensions (sub);
 116 }
 117
 118
 119 /* Convert EXPR to some floating-point type TYPE.
 120
 121    EXPR must be float, integer, or enumeral;
 122    in other cases error is called.  */
 123
 124 tree
 125 convert_to_real (tree type, tree expr)
 126 {
 127   enum built_in_function fcode = builtin_mathfn_code (expr);
 128   tree itype = TREE_TYPE (expr);
 129
 130   /* Disable until we figure out how to decide whether the functions are
 131      present in runtime.  */
 132   /* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
 133   if (optimize
 134       && (fcode == BUILT_IN_SQRT
 135           || fcode == BUILT_IN_SQRTL
 136           || fcode == BUILT_IN_SIN
 137           || fcode == BUILT_IN_SINL
 138           || fcode == BUILT_IN_COS
 139           || fcode == BUILT_IN_COSL
 140           || fcode == BUILT_IN_EXP
 141           || fcode == BUILT_IN_EXPL
 142           || fcode == BUILT_IN_LOG
 143           || fcode == BUILT_IN_LOGL)
 144       && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
 145           || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
 146     {
 147       tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
 148       tree newtype = type;
 149
 150       /* We have (outertype)sqrt((innertype)x).  Choose the wider mode from
 151          the both as the safe type for operation.  */
 152       if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
 153         newtype = TREE_TYPE (arg0);
 154
 155       /* Be careful about integer to fp conversions.
 156          These may overflow still.  */
 157       if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 158           && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
 159           && (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
 160               || TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
 161         {
 162           tree arglist;
 163           tree fn = mathfn_built_in (newtype, fcode);
 164
 165           if (fn)
 166             {
 167               arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
 168               expr = build_function_call_expr (fn, arglist);
 169               if (newtype == type)
 170                 return expr;
 171             }
 172         }
 173     }
 174   if (optimize
 175       && (((fcode == BUILT_IN_FLOORL
 176            || fcode == BUILT_IN_CEILL
 177            || fcode == BUILT_IN_ROUND
 178            || fcode == BUILT_IN_TRUNC
 179            || fcode == BUILT_IN_NEARBYINT)
 180           && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
 181               || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
 182           || ((fcode == BUILT_IN_FLOOR
 183                || fcode == BUILT_IN_CEIL
 184                || fcode == BUILT_IN_ROUND
 185                || fcode == BUILT_IN_TRUNC
 186                || fcode == BUILT_IN_NEARBYINT)
 187               && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
 188     {
 189       tree fn = mathfn_built_in (type, fcode);
 190
 191       if (fn)
 192         {
 193           tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr,
 194                                                                         1)));
 195           tree arglist = build_tree_list (NULL_TREE,
 196                                           fold (convert_to_real (type, arg0)));
 197
 198           return build_function_call_expr (fn, arglist);
 199         }
 200     }
 201
 202   /* Propagate the cast into the operation.  */
 203   if (itype != type && FLOAT_TYPE_P (type))
 204     switch (TREE_CODE (expr))
 205       {
 206         /* Convert (float)-x into -(float)x.  This is always safe.  */
 207         case ABS_EXPR:
 208         case NEGATE_EXPR:
 209           if (TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (expr)))
 210             return build1 (TREE_CODE (expr), type,
 211                            fold (convert_to_real (type,
 212                                                   TREE_OPERAND (expr, 0))));
 213           break;
 214         /* Convert (outertype)((innertype0)a+(innertype1)b)
 215            into ((newtype)a+(newtype)b) where newtype
 216            is the widest mode from all of these.  */
 217         case PLUS_EXPR:
 218         case MINUS_EXPR:
 219         case MULT_EXPR:
 220         case RDIV_EXPR:
 221            {
 222              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
 223              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
 224
 225              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 226                  && FLOAT_TYPE_P (TREE_TYPE (arg1)))
 227                {
 228                   tree newtype = type;
 229                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
 230                     newtype = TREE_TYPE (arg0);
 231                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
 232                     newtype = TREE_TYPE (arg1);
 233                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
 234                     {
 235                       expr = build (TREE_CODE (expr), newtype,
 236                                     fold (convert_to_real (newtype, arg0)),
 237                                     fold (convert_to_real (newtype, arg1)));
 238                       if (newtype == type)
 239                         return expr;
 240                     }
 241                }
 242            }
 243           break;
 244         default:
 245           break;
 246       }
 247
 248   switch (TREE_CODE (TREE_TYPE (expr)))
 249     {
 250     case REAL_TYPE:
 251       return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
 252                      type, expr);
 253
 254     case INTEGER_TYPE:
 255     case ENUMERAL_TYPE:
 256     case BOOLEAN_TYPE:
 257     case CHAR_TYPE:
 258       return build1 (FLOAT_EXPR, type, expr);
 259
 260     case COMPLEX_TYPE:
 261       return convert (type,
 262                       fold (build1 (REALPART_EXPR,
 263                                     TREE_TYPE (TREE_TYPE (expr)), expr)));
 264
 265     case POINTER_TYPE:
 266     case REFERENCE_TYPE:
 267       error ("pointer value used where a floating point value was expected");
 268       return convert_to_real (type, integer_zero_node);
 269
 270     default:
 271       error ("aggregate value used where a float was expected");
 272       return convert_to_real (type, integer_zero_node);
 273     }
 274 }
 275
 276 /* Convert EXPR to some integer (or enum) type TYPE.
 277
 278    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
 279    vector; in other cases error is called.
 280
 281    The result of this is always supposed to be a newly created tree node
 282    not in use in any existing structure.  */
 283
 284 tree
 285 convert_to_integer (tree type, tree expr)
 286 {
 287   enum tree_code ex_form = TREE_CODE (expr);
 288   tree intype = TREE_TYPE (expr);
 289   unsigned int inprec = TYPE_PRECISION (intype);
 290   unsigned int outprec = TYPE_PRECISION (type);
 291
 292   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 293      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 294   if (!COMPLETE_TYPE_P (type))
 295     {
 296       error ("conversion to incomplete type");
 297       return error_mark_node;
 298     }
 299
 300   switch (TREE_CODE (intype))
 301     {
 302     case POINTER_TYPE:
 303     case REFERENCE_TYPE:
 304       if (integer_zerop (expr))
 305         expr = integer_zero_node;
 306       else
 307         expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
 308                              (POINTER_SIZE, 0), expr));
 309
 310       return convert_to_integer (type, expr);
 311
 312     case INTEGER_TYPE:
 313     case ENUMERAL_TYPE:
 314     case BOOLEAN_TYPE:
 315     case CHAR_TYPE:
 316       /* If this is a logical operation, which just returns 0 or 1, we can
 317          change the type of the expression.  For some logical operations,
 318          we must also change the types of the operands to maintain type
 319          correctness.  */
 320
 321       if (TREE_CODE_CLASS (ex_form) == '<')
 322         {
 323           expr = copy_node (expr);
 324           TREE_TYPE (expr) = type;
 325           return expr;
 326         }
 327
 328       else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
 329                || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
 330                || ex_form == TRUTH_XOR_EXPR)
 331         {
 332           expr = copy_node (expr);
 333           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 334           TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
 335           TREE_TYPE (expr) = type;
 336           return expr;
 337         }
 338
 339       else if (ex_form == TRUTH_NOT_EXPR)
 340         {
 341           expr = copy_node (expr);
 342           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 343           TREE_TYPE (expr) = type;
 344           return expr;
 345         }
 346
 347       /* If we are widening the type, put in an explicit conversion.
 348          Similarly if we are not changing the width.  After this, we know
 349          we are truncating EXPR.  */
 350
 351       else if (outprec >= inprec)
 352         {
 353           enum tree_code code;
 354
 355           /* If the precision of the EXPR's type is K bits and the
 356              destination mode has more bits, and the sign is changing,
 357              it is not safe to use a NOP_EXPR.  For example, suppose
 358              that EXPR's type is a 3-bit unsigned integer type, the
 359              TYPE is a 3-bit signed integer type, and the machine mode
 360              for the types is 8-bit QImode.  In that case, the
 361              conversion necessitates an explicit sign-extension.  In
 362              the signed-to-unsigned case the high-order bits have to
 363              be cleared.  */
 364           if (TREE_UNSIGNED (type) != TREE_UNSIGNED (TREE_TYPE (expr))
 365               && (TYPE_PRECISION (TREE_TYPE (expr))
 366                   != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)))))
 367             code = CONVERT_EXPR;
 368           else
 369             code = NOP_EXPR;
 370
 371           return build1 (code, type, expr);
 372         }
 373
 374       /* If TYPE is an enumeral type or a type with a precision less
 375          than the number of bits in its mode, do the conversion to the
 376          type corresponding to its mode, then do a nop conversion
 377          to TYPE.  */
 378       else if (TREE_CODE (type) == ENUMERAL_TYPE
 379                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
 380         return build1 (NOP_EXPR, type,
 381                        convert ((*lang_hooks.types.type_for_mode)
 382                                 (TYPE_MODE (type), TREE_UNSIGNED (type)),
 383                                 expr));
 384
 385       /* Here detect when we can distribute the truncation down past some
 386          arithmetic.  For example, if adding two longs and converting to an
 387          int, we can equally well convert both to ints and then add.
 388          For the operations handled here, such truncation distribution
 389          is always safe.
 390          It is desirable in these cases:
 391          1) when truncating down to full-word from a larger size
 392          2) when truncating takes no work.
 393          3) when at least one operand of the arithmetic has been extended
 394          (as by C's default conversions).  In this case we need two conversions
 395          if we do the arithmetic as already requested, so we might as well
 396          truncate both and then combine.  Perhaps that way we need only one.
 397
 398          Note that in general we cannot do the arithmetic in a type
 399          shorter than the desired result of conversion, even if the operands
 400          are both extended from a shorter type, because they might overflow
 401          if combined in that type.  The exceptions to this--the times when
 402          two narrow values can be combined in their narrow type even to
 403          make a wider result--are handled by "shorten" in build_binary_op.  */
 404
 405       switch (ex_form)
 406         {
 407         case RSHIFT_EXPR:
 408           /* We can pass truncation down through right shifting
 409              when the shift count is a nonpositive constant.  */
 410           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 411               && tree_int_cst_lt (TREE_OPERAND (expr, 1),
 412                                   convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
 413                                            integer_one_node)))
 414             goto trunc1;
 415           break;
 416
 417         case LSHIFT_EXPR:
 418           /* We can pass truncation down through left shifting
 419              when the shift count is a nonnegative constant and
 420              the target type is unsigned.  */
 421           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 422               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 423               && TREE_UNSIGNED (type)
 424               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 425             {
 426               /* If shift count is less than the width of the truncated type,
 427                  really shift.  */
 428               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 429                 /* In this case, shifting is like multiplication.  */
 430                 goto trunc1;
 431               else
 432                 {
 433                   /* If it is >= that width, result is zero.
 434                      Handling this with trunc1 would give the wrong result:
 435                      (int) ((long long) a << 32) is well defined (as 0)
 436                      but (int) a << 32 is undefined and would get a
 437                      warning.  */
 438
 439                   tree t = convert_to_integer (type, integer_zero_node);
 440
 441                   /* If the original expression had side-effects, we must
 442                      preserve it.  */
 443                   if (TREE_SIDE_EFFECTS (expr))
 444                     return build (COMPOUND_EXPR, type, expr, t);
 445                   else
 446                     return t;
 447                 }
 448             }
 449           break;
 450
 451         case MAX_EXPR:
 452         case MIN_EXPR:
 453         case MULT_EXPR:
 454           {
 455             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 456             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 457
 458             /* Don't distribute unless the output precision is at least as big
 459                as the actual inputs.  Otherwise, the comparison of the
 460                truncated values will be wrong.  */
 461             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 462                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 463                 /* If signedness of arg0 and arg1 don't match,
 464                    we can't necessarily find a type to compare them in.  */
 465                 && (TREE_UNSIGNED (TREE_TYPE (arg0))
 466                     == TREE_UNSIGNED (TREE_TYPE (arg1))))
 467               goto trunc1;
 468             break;
 469           }
 470
 471         case PLUS_EXPR:
 472         case MINUS_EXPR:
 473         case BIT_AND_EXPR:
 474         case BIT_IOR_EXPR:
 475         case BIT_XOR_EXPR:
 476         trunc1:
 477           {
 478             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 479             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 480
 481             if (outprec >= BITS_PER_WORD
 482                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 483                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 484                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 485               {
 486                 /* Do the arithmetic in type TYPEX,
 487                    then convert result to TYPE.  */
 488                 tree typex = type;
 489
 490                 /* Can't do arithmetic in enumeral types
 491                    so use an integer type that will hold the values.  */
 492                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 493                   typex = (*lang_hooks.types.type_for_size)
 494                     (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
 495
 496                 /* But now perhaps TYPEX is as wide as INPREC.
 497                    In that case, do nothing special here.
 498                    (Otherwise would recurse infinitely in convert.  */
 499                 if (TYPE_PRECISION (typex) != inprec)
 500                   {
 501                     /* Don't do unsigned arithmetic where signed was wanted,
 502                        or vice versa.
 503                        Exception: if both of the original operands were
 504                        unsigned then we can safely do the work as unsigned.
 505                        Exception: shift operations take their type solely
 506                        from the first argument.
 507                        Exception: the LSHIFT_EXPR case above requires that
 508                        we perform this operation unsigned lest we produce
 509                        signed-overflow undefinedness.
 510                        And we may need to do it as unsigned
 511                        if we truncate to the original size.  */
 512                     if (TREE_UNSIGNED (TREE_TYPE (expr))
 513                         || (TREE_UNSIGNED (TREE_TYPE (arg0))
 514                             && (TREE_UNSIGNED (TREE_TYPE (arg1))
 515                                 || ex_form == LSHIFT_EXPR
 516                                 || ex_form == RSHIFT_EXPR
 517                                 || ex_form == LROTATE_EXPR
 518                                 || ex_form == RROTATE_EXPR))
 519                         || ex_form == LSHIFT_EXPR)
 520                       typex = (*lang_hooks.types.unsigned_type) (typex);
 521                     else
 522                       typex = (*lang_hooks.types.signed_type) (typex);
 523                     return convert (type,
 524                                     fold (build (ex_form, typex,
 525                                                  convert (typex, arg0),
 526                                                  convert (typex, arg1),
 527                                                  0)));
 528                   }
 529               }
 530           }
 531           break;
 532
 533         case NEGATE_EXPR:
 534         case BIT_NOT_EXPR:
 535           /* This is not correct for ABS_EXPR,
 536              since we must test the sign before truncation.  */
 537           {
 538             tree typex = type;
 539
 540             /* Can't do arithmetic in enumeral types
 541                so use an integer type that will hold the values.  */
 542             if (TREE_CODE (typex) == ENUMERAL_TYPE)
 543               typex = (*lang_hooks.types.type_for_size)
 544                 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
 545
 546             /* But now perhaps TYPEX is as wide as INPREC.
 547                In that case, do nothing special here.
 548                (Otherwise would recurse infinitely in convert.  */
 549             if (TYPE_PRECISION (typex) != inprec)
 550               {
 551                 /* Don't do unsigned arithmetic where signed was wanted,
 552                    or vice versa.  */
 553                 if (TREE_UNSIGNED (TREE_TYPE (expr)))
 554                   typex = (*lang_hooks.types.unsigned_type) (typex);
 555                 else
 556                   typex = (*lang_hooks.types.signed_type) (typex);
 557                 return convert (type,
 558                                 fold (build1 (ex_form, typex,
 559                                               convert (typex,
 560                                                        TREE_OPERAND (expr, 0)))));
 561               }
 562           }
 563
 564         case NOP_EXPR:
 565           /* Don't introduce a
 566              "can't convert between vector values of different size" error.  */
 567           if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
 568               && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0))))
 569                   != GET_MODE_SIZE (TYPE_MODE (type))))
 570             break;
 571           /* If truncating after truncating, might as well do all at once.
 572              If truncating after extending, we may get rid of wasted work.  */
 573           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 574
 575         case COND_EXPR:
 576           /* It is sometimes worthwhile to push the narrowing down through
 577              the conditional and never loses.  */
 578           return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
 579                               convert (type, TREE_OPERAND (expr, 1)),
 580                               convert (type, TREE_OPERAND (expr, 2))));
 581
 582         default:
 583           break;
 584         }
 585
 586       return build1 (NOP_EXPR, type, expr);
 587
 588     case REAL_TYPE:
 589       return build1 (FIX_TRUNC_EXPR, type, expr);
 590
 591     case COMPLEX_TYPE:
 592       return convert (type,
 593                       fold (build1 (REALPART_EXPR,
 594                                     TREE_TYPE (TREE_TYPE (expr)), expr)));
 595
 596     case VECTOR_TYPE:
 597       if (GET_MODE_SIZE (TYPE_MODE (type))
 598           != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
 599         {
 600           error ("can't convert between vector values of different size");
 601           return error_mark_node;
 602         }
 603       return build1 (NOP_EXPR, type, expr);
 604
 605     default:
 606       error ("aggregate value used where an integer was expected");
 607       return convert (type, integer_zero_node);
 608     }
 609 }
 610
 611 /* Convert EXPR to the complex type TYPE in the usual ways.  */
 612
 613 tree
 614 convert_to_complex (tree type, tree expr)
 615 {
 616   tree subtype = TREE_TYPE (type);
 617
 618   switch (TREE_CODE (TREE_TYPE (expr)))
 619     {
 620     case REAL_TYPE:
 621     case INTEGER_TYPE:
 622     case ENUMERAL_TYPE:
 623     case BOOLEAN_TYPE:
 624     case CHAR_TYPE:
 625       return build (COMPLEX_EXPR, type, convert (subtype, expr),
 626                     convert (subtype, integer_zero_node));
 627
 628     case COMPLEX_TYPE:
 629       {
 630         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
 631
 632         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
 633           return expr;
 634         else if (TREE_CODE (expr) == COMPLEX_EXPR)
 635           return fold (build (COMPLEX_EXPR,
 636                               type,
 637                               convert (subtype, TREE_OPERAND (expr, 0)),
 638                               convert (subtype, TREE_OPERAND (expr, 1))));
 639         else
 640           {
 641             expr = save_expr (expr);
 642             return
 643               fold (build (COMPLEX_EXPR,
 644                            type, convert (subtype,
 645                                           fold (build1 (REALPART_EXPR,
 646                                                         TREE_TYPE (TREE_TYPE (expr)),
 647                                                         expr))),
 648                            convert (subtype,
 649                                     fold (build1 (IMAGPART_EXPR,
 650                                                   TREE_TYPE (TREE_TYPE (expr)),
 651                                                   expr)))));
 652           }
 653       }
 654
 655     case POINTER_TYPE:
 656     case REFERENCE_TYPE:
 657       error ("pointer value used where a complex was expected");
 658       return convert_to_complex (type, integer_zero_node);
 659
 660     default:
 661       error ("aggregate value used where a complex was expected");
 662       return convert_to_complex (type, integer_zero_node);
 663     }
 664 }
 665
 666 /* Convert EXPR to the vector type TYPE in the usual ways.  */
 667
 668 tree
 669 convert_to_vector (tree type, tree expr)
 670 {
 671   switch (TREE_CODE (TREE_TYPE (expr)))
 672     {
 673     case INTEGER_TYPE:
 674     case VECTOR_TYPE:
 675       if (GET_MODE_SIZE (TYPE_MODE (type))
 676           != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
 677         {
 678           error ("can't convert between vector values of different size");
 679           return error_mark_node;
 680         }
 681       return build1 (NOP_EXPR, type, expr);
 682
 683     default:
 684       error ("can't convert value to a vector");
 685       return convert_to_vector (type, integer_zero_node);
 686     }
 687 }