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           return build1 (TREE_CODE (expr), type,
 233                          fold (convert_to_real (type,
 234                                                 TREE_OPERAND (expr, 0))));
 235         /* convert (outertype)((innertype0)a+(innertype1)b)
 236            into ((newtype)a+(newtype)b) where newtype
 237            is the widest mode from all of these.  */
 238         case PLUS_EXPR:
 239         case MINUS_EXPR:
 240         case MULT_EXPR:
 241         case RDIV_EXPR:
 242            {
 243              tree arg0 = strip_float_extensions (TREE_OPERAND (expr, 0));
 244              tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1));
 245
 246              if (FLOAT_TYPE_P (TREE_TYPE (arg0))
 247                  && FLOAT_TYPE_P (TREE_TYPE (arg1)))
 248                {
 249                   tree newtype = type;
 250                   if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (newtype))
 251                     newtype = TREE_TYPE (arg0);
 252                   if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype))
 253                     newtype = TREE_TYPE (arg1);
 254                   if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype))
 255                     {
 256                       expr = build (TREE_CODE (expr), newtype,
 257                                     fold (convert_to_real (newtype, arg0)),
 258                                     fold (convert_to_real (newtype, arg1)));
 259                       if (newtype == type)
 260                         return expr;
 261                     }
 262                }
 263            }
 264           break;
 265         default:
 266           break;
 267       }
 268
 269   switch (TREE_CODE (TREE_TYPE (expr)))
 270     {
 271     case REAL_TYPE:
 272       return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
 273                      type, expr);
 274
 275     case INTEGER_TYPE:
 276     case ENUMERAL_TYPE:
 277     case BOOLEAN_TYPE:
 278     case CHAR_TYPE:
 279       return build1 (FLOAT_EXPR, type, expr);
 280
 281     case COMPLEX_TYPE:
 282       return convert (type,
 283                       fold (build1 (REALPART_EXPR,
 284                                     TREE_TYPE (TREE_TYPE (expr)), expr)));
 285
 286     case POINTER_TYPE:
 287     case REFERENCE_TYPE:
 288       error ("pointer value used where a floating point value was expected");
 289       return convert_to_real (type, integer_zero_node);
 290
 291     default:
 292       error ("aggregate value used where a float was expected");
 293       return convert_to_real (type, integer_zero_node);
 294     }
 295 }
 296
 297 /* Convert EXPR to some integer (or enum) type TYPE.
 298
 299    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
 300    vector; in other cases error is called.
 301
 302    The result of this is always supposed to be a newly created tree node
 303    not in use in any existing structure.  */
 304
 305 tree
 306 convert_to_integer (type, expr)
 307      tree type, expr;
 308 {
 309   enum tree_code ex_form = TREE_CODE (expr);
 310   tree intype = TREE_TYPE (expr);
 311   unsigned int inprec = TYPE_PRECISION (intype);
 312   unsigned int outprec = TYPE_PRECISION (type);
 313
 314   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 315      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 316   if (!COMPLETE_TYPE_P (type))
 317     {
 318       error ("conversion to incomplete type");
 319       return error_mark_node;
 320     }
 321
 322   switch (TREE_CODE (intype))
 323     {
 324     case POINTER_TYPE:
 325     case REFERENCE_TYPE:
 326       if (integer_zerop (expr))
 327         expr = integer_zero_node;
 328       else
 329         expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
 330                              (POINTER_SIZE, 0), expr));
 331
 332       return convert_to_integer (type, expr);
 333
 334     case INTEGER_TYPE:
 335     case ENUMERAL_TYPE:
 336     case BOOLEAN_TYPE:
 337     case CHAR_TYPE:
 338       /* If this is a logical operation, which just returns 0 or 1, we can
 339          change the type of the expression.  For some logical operations,
 340          we must also change the types of the operands to maintain type
 341          correctness.  */
 342
 343       if (TREE_CODE_CLASS (ex_form) == '<')
 344         {
 345           TREE_TYPE (expr) = type;
 346           return expr;
 347         }
 348
 349       else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
 350                || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
 351                || ex_form == TRUTH_XOR_EXPR)
 352         {
 353           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 354           TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
 355           TREE_TYPE (expr) = type;
 356           return expr;
 357         }
 358
 359       else if (ex_form == TRUTH_NOT_EXPR)
 360         {
 361           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 362           TREE_TYPE (expr) = type;
 363           return expr;
 364         }
 365
 366       /* If we are widening the type, put in an explicit conversion.
 367          Similarly if we are not changing the width.  After this, we know
 368          we are truncating EXPR.  */
 369
 370       else if (outprec >= inprec)
 371         return build1 (NOP_EXPR, type, expr);
 372
 373       /* If TYPE is an enumeral type or a type with a precision less
 374          than the number of bits in its mode, do the conversion to the
 375          type corresponding to its mode, then do a nop conversion
 376          to TYPE.  */
 377       else if (TREE_CODE (type) == ENUMERAL_TYPE
 378                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
 379         return build1 (NOP_EXPR, type,
 380                        convert ((*lang_hooks.types.type_for_mode)
 381                                 (TYPE_MODE (type), TREE_UNSIGNED (type)),
 382                                 expr));
 383
 384       /* Here detect when we can distribute the truncation down past some
 385          arithmetic.  For example, if adding two longs and converting to an
 386          int, we can equally well convert both to ints and then add.
 387          For the operations handled here, such truncation distribution
 388          is always safe.
 389          It is desirable in these cases:
 390          1) when truncating down to full-word from a larger size
 391          2) when truncating takes no work.
 392          3) when at least one operand of the arithmetic has been extended
 393          (as by C's default conversions).  In this case we need two conversions
 394          if we do the arithmetic as already requested, so we might as well
 395          truncate both and then combine.  Perhaps that way we need only one.
 396
 397          Note that in general we cannot do the arithmetic in a type
 398          shorter than the desired result of conversion, even if the operands
 399          are both extended from a shorter type, because they might overflow
 400          if combined in that type.  The exceptions to this--the times when
 401          two narrow values can be combined in their narrow type even to
 402          make a wider result--are handled by "shorten" in build_binary_op.  */
 403
 404       switch (ex_form)
 405         {
 406         case RSHIFT_EXPR:
 407           /* We can pass truncation down through right shifting
 408              when the shift count is a nonpositive constant.  */
 409           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 410               && tree_int_cst_lt (TREE_OPERAND (expr, 1),
 411                                   convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
 412                                            integer_one_node)))
 413             goto trunc1;
 414           break;
 415
 416         case LSHIFT_EXPR:
 417           /* We can pass truncation down through left shifting
 418              when the shift count is a nonnegative constant and
 419              the target type is unsigned.  */
 420           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 421               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 422               && TREE_UNSIGNED (type)
 423               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 424             {
 425               /* If shift count is less than the width of the truncated type,
 426                  really shift.  */
 427               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 428                 /* In this case, shifting is like multiplication.  */
 429                 goto trunc1;
 430               else
 431                 {
 432                   /* If it is >= that width, result is zero.
 433                      Handling this with trunc1 would give the wrong result:
 434                      (int) ((long long) a << 32) is well defined (as 0)
 435                      but (int) a << 32 is undefined and would get a
 436                      warning.  */
 437
 438                   tree t = convert_to_integer (type, integer_zero_node);
 439
 440                   /* If the original expression had side-effects, we must
 441                      preserve it.  */
 442                   if (TREE_SIDE_EFFECTS (expr))
 443                     return build (COMPOUND_EXPR, type, expr, t);
 444                   else
 445                     return t;
 446                 }
 447             }
 448           break;
 449
 450         case MAX_EXPR:
 451         case MIN_EXPR:
 452         case MULT_EXPR:
 453           {
 454             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 455             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 456
 457             /* Don't distribute unless the output precision is at least as big
 458                as the actual inputs.  Otherwise, the comparison of the
 459                truncated values will be wrong.  */
 460             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 461                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 462                 /* If signedness of arg0 and arg1 don't match,
 463                    we can't necessarily find a type to compare them in.  */
 464                 && (TREE_UNSIGNED (TREE_TYPE (arg0))
 465                     == TREE_UNSIGNED (TREE_TYPE (arg1))))
 466               goto trunc1;
 467             break;
 468           }
 469
 470         case PLUS_EXPR:
 471         case MINUS_EXPR:
 472         case BIT_AND_EXPR:
 473         case BIT_IOR_EXPR:
 474         case BIT_XOR_EXPR:
 475         case BIT_ANDTC_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 (type, expr)
 615      tree type, expr;
 616 {
 617   tree subtype = TREE_TYPE (type);
 618
 619   switch (TREE_CODE (TREE_TYPE (expr)))
 620     {
 621     case REAL_TYPE:
 622     case INTEGER_TYPE:
 623     case ENUMERAL_TYPE:
 624     case BOOLEAN_TYPE:
 625     case CHAR_TYPE:
 626       return build (COMPLEX_EXPR, type, convert (subtype, expr),
 627                     convert (subtype, integer_zero_node));
 628
 629     case COMPLEX_TYPE:
 630       {
 631         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
 632
 633         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
 634           return expr;
 635         else if (TREE_CODE (expr) == COMPLEX_EXPR)
 636           return fold (build (COMPLEX_EXPR,
 637                               type,
 638                               convert (subtype, TREE_OPERAND (expr, 0)),
 639                               convert (subtype, TREE_OPERAND (expr, 1))));
 640         else
 641           {
 642             expr = save_expr (expr);
 643             return
 644               fold (build (COMPLEX_EXPR,
 645                            type, convert (subtype,
 646                                           fold (build1 (REALPART_EXPR,
 647                                                         TREE_TYPE (TREE_TYPE (expr)),
 648                                                         expr))),
 649                            convert (subtype,
 650                                     fold (build1 (IMAGPART_EXPR,
 651                                                   TREE_TYPE (TREE_TYPE (expr)),
 652                                                   expr)))));
 653           }
 654       }
 655
 656     case POINTER_TYPE:
 657     case REFERENCE_TYPE:
 658       error ("pointer value used where a complex was expected");
 659       return convert_to_complex (type, integer_zero_node);
 660
 661     default:
 662       error ("aggregate value used where a complex was expected");
 663       return convert_to_complex (type, integer_zero_node);
 664     }
 665 }
 666
 667 /* Convert EXPR to the vector type TYPE in the usual ways.  */
 668
 669 tree
 670 convert_to_vector (type, expr)
 671      tree type, expr;
 672 {
 673   switch (TREE_CODE (TREE_TYPE (expr)))
 674     {
 675     case INTEGER_TYPE:
 676     case VECTOR_TYPE:
 677       if (GET_MODE_SIZE (TYPE_MODE (type))
 678           != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
 679         {
 680           error ("can't convert between vector values of different size");
 681           return error_mark_node;
 682         }
 683       return build1 (NOP_EXPR, type, expr);
 684
 685     default:
 686       error ("can't convert value to a vector");
 687       return convert_to_vector (type, integer_zero_node);
 688     }
 689 }