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 "tree.h"
  29 #include "flags.h"
  30 #include "convert.h"
  31 #include "toplev.h"
  32 #include "langhooks.h"
  33
  34 /* Convert EXPR to some pointer or reference type TYPE.
  35
  36    EXPR must be pointer, reference, integer, enumeral, or literal zero;
  37    in other cases error is called.  */
  38
  39 tree
  40 convert_to_pointer (type, expr)
  41      tree type, expr;
  42 {
  43   if (integer_zerop (expr))
  44     {
  45       expr = build_int_2 (0, 0);
  46       TREE_TYPE (expr) = type;
  47       return expr;
  48     }
  49
  50   switch (TREE_CODE (TREE_TYPE (expr)))
  51     {
  52     case POINTER_TYPE:
  53     case REFERENCE_TYPE:
  54       return build1 (NOP_EXPR, type, expr);
  55
  56     case INTEGER_TYPE:
  57     case ENUMERAL_TYPE:
  58     case BOOLEAN_TYPE:
  59     case CHAR_TYPE:
  60       if (TYPE_PRECISION (TREE_TYPE (expr)) == POINTER_SIZE)
  61         return build1 (CONVERT_EXPR, type, expr);
  62
  63       return
  64         convert_to_pointer (type,
  65                             convert ((*lang_hooks.types.type_for_size)
  66                                      (POINTER_SIZE, 0), expr));
  67
  68     default:
  69       error ("cannot convert to a pointer type");
  70       return convert_to_pointer (type, integer_zero_node);
  71     }
  72 }
  73
  74 /* Convert EXPR to some floating-point type TYPE.
  75
  76    EXPR must be float, integer, or enumeral;
  77    in other cases error is called.  */
  78
  79 tree
  80 convert_to_real (type, expr)
  81      tree type, expr;
  82 {
  83   switch (TREE_CODE (TREE_TYPE (expr)))
  84     {
  85     case REAL_TYPE:
  86       return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
  87                      type, expr);
  88
  89     case INTEGER_TYPE:
  90     case ENUMERAL_TYPE:
  91     case BOOLEAN_TYPE:
  92     case CHAR_TYPE:
  93       return build1 (FLOAT_EXPR, type, expr);
  94
  95     case COMPLEX_TYPE:
  96       return convert (type,
  97                       fold (build1 (REALPART_EXPR,
  98                                     TREE_TYPE (TREE_TYPE (expr)), expr)));
  99
 100     case POINTER_TYPE:
 101     case REFERENCE_TYPE:
 102       error ("pointer value used where a floating point value was expected");
 103       return convert_to_real (type, integer_zero_node);
 104
 105     default:
 106       error ("aggregate value used where a float was expected");
 107       return convert_to_real (type, integer_zero_node);
 108     }
 109 }
 110
 111 /* Convert EXPR to some integer (or enum) type TYPE.
 112
 113    EXPR must be pointer, integer, discrete (enum, char, or bool), float, or
 114    vector; in other cases error is called.
 115
 116    The result of this is always supposed to be a newly created tree node
 117    not in use in any existing structure.  */
 118
 119 tree
 120 convert_to_integer (type, expr)
 121      tree type, expr;
 122 {
 123   enum tree_code ex_form = TREE_CODE (expr);
 124   tree intype = TREE_TYPE (expr);
 125   unsigned int inprec = TYPE_PRECISION (intype);
 126   unsigned int outprec = TYPE_PRECISION (type);
 127
 128   /* An INTEGER_TYPE cannot be incomplete, but an ENUMERAL_TYPE can
 129      be.  Consider `enum E = { a, b = (enum E) 3 };'.  */
 130   if (!COMPLETE_TYPE_P (type))
 131     {
 132       error ("conversion to incomplete type");
 133       return error_mark_node;
 134     }
 135
 136   switch (TREE_CODE (intype))
 137     {
 138     case POINTER_TYPE:
 139     case REFERENCE_TYPE:
 140       if (integer_zerop (expr))
 141         expr = integer_zero_node;
 142       else
 143         expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size)
 144                              (POINTER_SIZE, 0), expr));
 145
 146       return convert_to_integer (type, expr);
 147
 148     case INTEGER_TYPE:
 149     case ENUMERAL_TYPE:
 150     case BOOLEAN_TYPE:
 151     case CHAR_TYPE:
 152       /* If this is a logical operation, which just returns 0 or 1, we can
 153          change the type of the expression.  For some logical operations,
 154          we must also change the types of the operands to maintain type
 155          correctness.  */
 156
 157       if (TREE_CODE_CLASS (ex_form) == '<')
 158         {
 159           TREE_TYPE (expr) = type;
 160           return expr;
 161         }
 162
 163       else if (ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
 164                || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
 165                || ex_form == TRUTH_XOR_EXPR)
 166         {
 167           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 168           TREE_OPERAND (expr, 1) = convert (type, TREE_OPERAND (expr, 1));
 169           TREE_TYPE (expr) = type;
 170           return expr;
 171         }
 172
 173       else if (ex_form == TRUTH_NOT_EXPR)
 174         {
 175           TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0));
 176           TREE_TYPE (expr) = type;
 177           return expr;
 178         }
 179
 180       /* If we are widening the type, put in an explicit conversion.
 181          Similarly if we are not changing the width.  After this, we know
 182          we are truncating EXPR.  */
 183
 184       else if (outprec >= inprec)
 185         return build1 (NOP_EXPR, type, expr);
 186
 187       /* If TYPE is an enumeral type or a type with a precision less
 188          than the number of bits in its mode, do the conversion to the
 189          type corresponding to its mode, then do a nop conversion
 190          to TYPE.  */
 191       else if (TREE_CODE (type) == ENUMERAL_TYPE
 192                || outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
 193         return build1 (NOP_EXPR, type,
 194                        convert ((*lang_hooks.types.type_for_mode)
 195                                 (TYPE_MODE (type), TREE_UNSIGNED (type)),
 196                                 expr));
 197
 198       /* Here detect when we can distribute the truncation down past some
 199          arithmetic.  For example, if adding two longs and converting to an
 200          int, we can equally well convert both to ints and then add.
 201          For the operations handled here, such truncation distribution
 202          is always safe.
 203          It is desirable in these cases:
 204          1) when truncating down to full-word from a larger size
 205          2) when truncating takes no work.
 206          3) when at least one operand of the arithmetic has been extended
 207          (as by C's default conversions).  In this case we need two conversions
 208          if we do the arithmetic as already requested, so we might as well
 209          truncate both and then combine.  Perhaps that way we need only one.
 210
 211          Note that in general we cannot do the arithmetic in a type
 212          shorter than the desired result of conversion, even if the operands
 213          are both extended from a shorter type, because they might overflow
 214          if combined in that type.  The exceptions to this--the times when
 215          two narrow values can be combined in their narrow type even to
 216          make a wider result--are handled by "shorten" in build_binary_op.  */
 217
 218       switch (ex_form)
 219         {
 220         case RSHIFT_EXPR:
 221           /* We can pass truncation down through right shifting
 222              when the shift count is a nonpositive constant.  */
 223           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 224               && tree_int_cst_lt (TREE_OPERAND (expr, 1),
 225                                   convert (TREE_TYPE (TREE_OPERAND (expr, 1)),
 226                                            integer_one_node)))
 227             goto trunc1;
 228           break;
 229
 230         case LSHIFT_EXPR:
 231           /* We can pass truncation down through left shifting
 232              when the shift count is a nonnegative constant.  */
 233           if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
 234               && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0
 235               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 236             {
 237               /* If shift count is less than the width of the truncated type,
 238                  really shift.  */
 239               if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
 240                 /* In this case, shifting is like multiplication.  */
 241                 goto trunc1;
 242               else
 243                 {
 244                   /* If it is >= that width, result is zero.
 245                      Handling this with trunc1 would give the wrong result:
 246                      (int) ((long long) a << 32) is well defined (as 0)
 247                      but (int) a << 32 is undefined and would get a
 248                      warning.  */
 249
 250                   tree t = convert_to_integer (type, integer_zero_node);
 251
 252                   /* If the original expression had side-effects, we must
 253                      preserve it.  */
 254                   if (TREE_SIDE_EFFECTS (expr))
 255                     return build (COMPOUND_EXPR, type, expr, t);
 256                   else
 257                     return t;
 258                 }
 259             }
 260           break;
 261
 262         case MAX_EXPR:
 263         case MIN_EXPR:
 264         case MULT_EXPR:
 265           {
 266             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 267             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 268
 269             /* Don't distribute unless the output precision is at least as big
 270                as the actual inputs.  Otherwise, the comparison of the
 271                truncated values will be wrong.  */
 272             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 273                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 274                 /* If signedness of arg0 and arg1 don't match,
 275                    we can't necessarily find a type to compare them in.  */
 276                 && (TREE_UNSIGNED (TREE_TYPE (arg0))
 277                     == TREE_UNSIGNED (TREE_TYPE (arg1))))
 278               goto trunc1;
 279             break;
 280           }
 281
 282         case PLUS_EXPR:
 283         case MINUS_EXPR:
 284         case BIT_AND_EXPR:
 285         case BIT_IOR_EXPR:
 286         case BIT_XOR_EXPR:
 287         case BIT_ANDTC_EXPR:
 288         trunc1:
 289           {
 290             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 291             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 292
 293             if (outprec >= BITS_PER_WORD
 294                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 295                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 296                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 297               {
 298                 /* Do the arithmetic in type TYPEX,
 299                    then convert result to TYPE.  */
 300                 tree typex = type;
 301
 302                 /* Can't do arithmetic in enumeral types
 303                    so use an integer type that will hold the values.  */
 304                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 305                   typex = (*lang_hooks.types.type_for_size)
 306                     (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
 307
 308                 /* But now perhaps TYPEX is as wide as INPREC.
 309                    In that case, do nothing special here.
 310                    (Otherwise would recurse infinitely in convert.  */
 311                 if (TYPE_PRECISION (typex) != inprec)
 312                   {
 313                     /* Don't do unsigned arithmetic where signed was wanted,
 314                        or vice versa.
 315                        Exception: if both of the original operands were
 316                        unsigned then can safely do the work as unsigned.
 317                        And we may need to do it as unsigned
 318                        if we truncate to the original size.  */
 319                     typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
 320                               || (TREE_UNSIGNED (TREE_TYPE (arg0))
 321                                   && TREE_UNSIGNED (TREE_TYPE (arg1))))
 322                              ? unsigned_type (typex) : signed_type (typex));
 323                     return convert (type,
 324                                     fold (build (ex_form, typex,
 325                                                  convert (typex, arg0),
 326                                                  convert (typex, arg1),
 327                                                  0)));
 328                   }
 329               }
 330           }
 331           break;
 332
 333         case NEGATE_EXPR:
 334         case BIT_NOT_EXPR:
 335           /* This is not correct for ABS_EXPR,
 336              since we must test the sign before truncation.  */
 337           {
 338             tree typex = type;
 339
 340             /* Can't do arithmetic in enumeral types
 341                so use an integer type that will hold the values.  */
 342             if (TREE_CODE (typex) == ENUMERAL_TYPE)
 343               typex = (*lang_hooks.types.type_for_size)
 344                 (TYPE_PRECISION (typex), TREE_UNSIGNED (typex));
 345
 346             /* But now perhaps TYPEX is as wide as INPREC.
 347                In that case, do nothing special here.
 348                (Otherwise would recurse infinitely in convert.  */
 349             if (TYPE_PRECISION (typex) != inprec)
 350               {
 351                 /* Don't do unsigned arithmetic where signed was wanted,
 352                    or vice versa.  */
 353                 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
 354                          ? unsigned_type (typex) : signed_type (typex));
 355                 return convert (type,
 356                                 fold (build1 (ex_form, typex,
 357                                               convert (typex,
 358                                                        TREE_OPERAND (expr, 0)))));
 359               }
 360           }
 361
 362         case NOP_EXPR:
 363           /* If truncating after truncating, might as well do all at once.
 364              If truncating after extending, we may get rid of wasted work.  */
 365           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 366
 367         case COND_EXPR:
 368           /* It is sometimes worthwhile to push the narrowing down through
 369              the conditional and never loses.  */
 370           return fold (build (COND_EXPR, type, TREE_OPERAND (expr, 0),
 371                               convert (type, TREE_OPERAND (expr, 1)),
 372                               convert (type, TREE_OPERAND (expr, 2))));
 373
 374         default:
 375           break;
 376         }
 377
 378       return build1 (NOP_EXPR, type, expr);
 379
 380     case REAL_TYPE:
 381       return build1 (FIX_TRUNC_EXPR, type, expr);
 382
 383     case COMPLEX_TYPE:
 384       return convert (type,
 385                       fold (build1 (REALPART_EXPR,
 386                                     TREE_TYPE (TREE_TYPE (expr)), expr)));
 387
 388     case VECTOR_TYPE:
 389       if (GET_MODE_SIZE (TYPE_MODE (type))
 390           != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
 391         {
 392           error ("can't convert between vector values of different size");
 393           return error_mark_node;
 394         }
 395       return build1 (NOP_EXPR, type, expr);
 396
 397     default:
 398       error ("aggregate value used where an integer was expected");
 399       return convert (type, integer_zero_node);
 400     }
 401 }
 402
 403 /* Convert EXPR to the complex type TYPE in the usual ways.  */
 404
 405 tree
 406 convert_to_complex (type, expr)
 407      tree type, expr;
 408 {
 409   tree subtype = TREE_TYPE (type);
 410
 411   switch (TREE_CODE (TREE_TYPE (expr)))
 412     {
 413     case REAL_TYPE:
 414     case INTEGER_TYPE:
 415     case ENUMERAL_TYPE:
 416     case BOOLEAN_TYPE:
 417     case CHAR_TYPE:
 418       return build (COMPLEX_EXPR, type, convert (subtype, expr),
 419                     convert (subtype, integer_zero_node));
 420
 421     case COMPLEX_TYPE:
 422       {
 423         tree elt_type = TREE_TYPE (TREE_TYPE (expr));
 424
 425         if (TYPE_MAIN_VARIANT (elt_type) == TYPE_MAIN_VARIANT (subtype))
 426           return expr;
 427         else if (TREE_CODE (expr) == COMPLEX_EXPR)
 428           return fold (build (COMPLEX_EXPR,
 429                               type,
 430                               convert (subtype, TREE_OPERAND (expr, 0)),
 431                               convert (subtype, TREE_OPERAND (expr, 1))));
 432         else
 433           {
 434             expr = save_expr (expr);
 435             return
 436               fold (build (COMPLEX_EXPR,
 437                            type, convert (subtype,
 438                                           fold (build1 (REALPART_EXPR,
 439                                                         TREE_TYPE (TREE_TYPE (expr)),
 440                                                         expr))),
 441                            convert (subtype,
 442                                     fold (build1 (IMAGPART_EXPR,
 443                                                   TREE_TYPE (TREE_TYPE (expr)),
 444                                                   expr)))));
 445           }
 446       }
 447
 448     case POINTER_TYPE:
 449     case REFERENCE_TYPE:
 450       error ("pointer value used where a complex was expected");
 451       return convert_to_complex (type, integer_zero_node);
 452
 453     default:
 454       error ("aggregate value used where a complex was expected");
 455       return convert_to_complex (type, integer_zero_node);
 456     }
 457 }
 458
 459 /* Convert EXPR to the vector type TYPE in the usual ways.  */
 460
 461 tree
 462 convert_to_vector (type, expr)
 463      tree type, expr;
 464 {
 465   switch (TREE_CODE (TREE_TYPE (expr)))
 466     {
 467     case INTEGER_TYPE:
 468     case VECTOR_TYPE:
 469       if (GET_MODE_SIZE (TYPE_MODE (type))
 470           != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))))
 471         {
 472           error ("can't convert between vector values of different size");
 473           return error_mark_node;
 474         }
 475       return build1 (NOP_EXPR, type, expr);
 476
 477     default:
 478       error ("can't convert value to a vector");
 479       return convert_to_vector (type, integer_zero_node);
 480     }
 481 }