gcc/convert.c

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