gcc/convert.c

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