gcc/convert.c

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