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