gcc/convert.c

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