gcc/c-convert.c

   1 /* Language-level data type conversion for GNU C.
   2    Copyright (C) 1987, 1988, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   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 /* This file contains the functions for converting C expressions
  22    to different data types.  The only entry point is `convert'.
  23    Every language front end must have a `convert' function
  24    but what kind of conversions it does will depend on the language.  */
  25
  26 #include "config.h"
  27 #include "tree.h"
  28 #include "flags.h"
  29
  30 /* Change of width--truncation and extension of integers or reals--
  31    is represented with NOP_EXPR.  Proper functioning of many things
  32    assumes that no other conversions can be NOP_EXPRs.
  33
  34    Conversion between integer and pointer is represented with CONVERT_EXPR.
  35    Converting integer to real uses FLOAT_EXPR
  36    and real to integer uses FIX_TRUNC_EXPR.
  37
  38    Here is a list of all the functions that assume that widening and
  39    narrowing is always done with a NOP_EXPR:
  40      In c-convert.c, convert_to_integer.
  41      In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
  42      In expr.c: expand_expr, for operands of a MULT_EXPR.
  43      In fold-const.c: fold.
  44      In tree.c: get_narrower and get_unwidened.  */
  45 \f
  46 /* Subroutines of `convert'.  */
  47
  48 static tree
  49 convert_to_pointer (type, expr)
  50      tree type, expr;
  51 {
  52   register tree intype = TREE_TYPE (expr);
  53   register enum tree_code form = TREE_CODE (intype);
  54
  55   if (integer_zerop (expr))
  56     {
  57       if (type == TREE_TYPE (null_pointer_node))
  58         return null_pointer_node;
  59       expr = build_int_2 (0, 0);
  60       TREE_TYPE (expr) = type;
  61       return expr;
  62     }
  63
  64   if (form == POINTER_TYPE)
  65     return build1 (NOP_EXPR, type, expr);
  66
  67
  68   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
  69     {
  70       if (type_precision (intype) == POINTER_SIZE)
  71         return build1 (CONVERT_EXPR, type, expr);
  72       expr = convert (type_for_size (POINTER_SIZE, 0), expr);
  73       if (TYPE_MODE (TREE_TYPE (expr)) != TYPE_MODE (type))
  74         /* There is supposed to be some integral type
  75            that is the same width as a pointer.  */
  76         abort ();
  77       return convert_to_pointer (type, expr);
  78     }
  79
  80   error ("cannot convert to a pointer type");
  81
  82   return null_pointer_node;
  83 }
  84
  85 static tree
  86 convert_to_real (type, expr)
  87      tree type, expr;
  88 {
  89   register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
  90
  91   if (form == REAL_TYPE)
  92     return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
  93                    type, expr);
  94
  95   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
  96     return build1 (FLOAT_EXPR, type, expr);
  97
  98   if (form == POINTER_TYPE)
  99     error ("pointer value used where a float was expected");
 100   else
 101     error ("aggregate value used where a float was expected");
 102
 103   {
 104     register tree tem = make_node (REAL_CST);
 105     TREE_TYPE (tem) = type;
 106     TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0");
 107     return tem;
 108   }
 109 }
 110 \f
 111 /* The result of this is always supposed to be a newly created tree node
 112    not in use in any existing structure.  */
 113
 114 static tree
 115 convert_to_integer (type, expr)
 116      tree type, expr;
 117 {
 118   register tree intype = TREE_TYPE (expr);
 119   register enum tree_code form = TREE_CODE (intype);
 120
 121   if (form == POINTER_TYPE)
 122     {
 123       if (integer_zerop (expr))
 124         expr = integer_zero_node;
 125       else
 126         expr = fold (build1 (CONVERT_EXPR,
 127                              type_for_size (POINTER_SIZE, 0), expr));
 128       intype = TREE_TYPE (expr);
 129       form = TREE_CODE (intype);
 130       if (intype == type)
 131         return expr;
 132     }
 133
 134   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
 135     {
 136       register unsigned outprec = TYPE_PRECISION (type);
 137       register unsigned inprec = TYPE_PRECISION (intype);
 138       register enum tree_code ex_form = TREE_CODE (expr);
 139
 140       /* If we are widening the type, put in an explicit conversion.
 141          Similarly if we are not changing the width.  However, if this is
 142          a logical operation that just returns 0 or 1, we can change the
 143          type of the expression (see below).  */
 144
 145       if (TREE_CODE_CLASS (ex_form) == '<'
 146           || ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
 147           || ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
 148           || ex_form == TRUTH_NOT_EXPR)
 149         {
 150           TREE_TYPE (expr) = type;
 151           return expr;
 152         }
 153       else if (outprec >= inprec)
 154         return build1 (NOP_EXPR, type, expr);
 155
 156 /* Here detect when we can distribute the truncation down past some arithmetic.
 157    For example, if adding two longs and converting to an int,
 158    we can equally well convert both to ints and then add.
 159    For the operations handled here, such truncation distribution
 160    is always safe.
 161    It is desirable in these cases:
 162    1) when truncating down to full-word from a larger size
 163    2) when truncating takes no work.
 164    3) when at least one operand of the arithmetic has been extended
 165    (as by C's default conversions).  In this case we need two conversions
 166    if we do the arithmetic as already requested, so we might as well
 167    truncate both and then combine.  Perhaps that way we need only one.
 168
 169    Note that in general we cannot do the arithmetic in a type
 170    shorter than the desired result of conversion, even if the operands
 171    are both extended from a shorter type, because they might overflow
 172    if combined in that type.  The exceptions to this--the times when
 173    two narrow values can be combined in their narrow type even to
 174    make a wider result--are handled by "shorten" in build_binary_op.  */
 175
 176       switch (ex_form)
 177         {
 178         case RSHIFT_EXPR:
 179           /* We can pass truncation down through right shifting
 180              when the shift count is a negative constant.  */
 181           if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
 182               || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
 183             break;
 184           goto trunc1;
 185
 186         case LSHIFT_EXPR:
 187           /* We can pass truncation down through left shifting
 188              when the shift count is a positive constant.  */
 189           if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
 190               || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
 191             break;
 192           /* In this case, shifting is like multiplication.  */
 193           goto trunc1;
 194
 195         case MAX_EXPR:
 196         case MIN_EXPR:
 197         case MULT_EXPR:
 198           {
 199             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 200             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 201
 202             /* Don't distribute unless the output precision is at least as big
 203                as the actual inputs.  Otherwise, the comparison of the
 204                truncated values will be wrong.  */
 205             if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
 206                 && outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
 207                 /* If signedness of arg0 and arg1 don't match,
 208                    we can't necessarily find a type to compare them in.  */
 209                 && (TREE_UNSIGNED (TREE_TYPE (arg0))
 210                     == TREE_UNSIGNED (TREE_TYPE (arg1))))
 211               goto trunc1;
 212             break;
 213           }
 214
 215         case PLUS_EXPR:
 216         case MINUS_EXPR:
 217         case BIT_AND_EXPR:
 218         case BIT_IOR_EXPR:
 219         case BIT_XOR_EXPR:
 220         case BIT_ANDTC_EXPR:
 221         trunc1:
 222           {
 223             tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
 224             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 225
 226             if (outprec >= BITS_PER_WORD
 227                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 228                 || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
 229                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
 230               {
 231                 /* Do the arithmetic in type TYPEX,
 232                    then convert result to TYPE.  */
 233                 register tree typex = type;
 234
 235                 /* Can't do arithmetic in enumeral types
 236                    so use an integer type that will hold the values.  */
 237                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 238                   typex = type_for_size (TYPE_PRECISION (typex),
 239                                          TREE_UNSIGNED (typex));
 240
 241                 /* But now perhaps TYPEX is as wide as INPREC.
 242                    In that case, do nothing special here.
 243                    (Otherwise would recurse infinitely in convert.  */
 244                 if (TYPE_PRECISION (typex) != inprec)
 245                   {
 246                     /* Don't do unsigned arithmetic where signed was wanted,
 247                        or vice versa.
 248                        Exception: if either of the original operands were
 249                        unsigned then can safely do the work as unsigned.
 250                        And we may need to do it as unsigned
 251                        if we truncate to the original size.  */
 252                     typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
 253                               || TREE_UNSIGNED (TREE_TYPE (arg0))
 254                               || TREE_UNSIGNED (TREE_TYPE (arg1)))
 255                              ? unsigned_type (typex) : signed_type (typex));
 256                     return convert (type,
 257                                     build_binary_op (ex_form,
 258                                                      convert (typex, arg0),
 259                                                      convert (typex, arg1),
 260                                                      0));
 261                   }
 262               }
 263           }
 264           break;
 265
 266         case NEGATE_EXPR:
 267         case BIT_NOT_EXPR:
 268           {
 269             register tree typex = type;
 270
 271             /* Can't do arithmetic in enumeral types
 272                so use an integer type that will hold the values.  */
 273             if (TREE_CODE (typex) == ENUMERAL_TYPE)
 274               typex = type_for_size (TYPE_PRECISION (typex),
 275                                      TREE_UNSIGNED (typex));
 276
 277             /* But now perhaps TYPEX is as wide as INPREC.
 278                In that case, do nothing special here.
 279                (Otherwise would recurse infinitely in convert.  */
 280             if (TYPE_PRECISION (typex) != inprec)
 281               {
 282                 /* Don't do unsigned arithmetic where signed was wanted,
 283                    or vice versa.  */
 284                 typex = (TREE_UNSIGNED (TREE_TYPE (expr))
 285                          ? unsigned_type (typex) : signed_type (typex));
 286                 return convert (type,
 287                                 build_unary_op (ex_form,
 288                                                 convert (typex, TREE_OPERAND (expr, 0)),
 289                                                 1));
 290               }
 291           }
 292
 293         case NOP_EXPR:
 294           /* If truncating after truncating, might as well do all at once.
 295              If truncating after extending, we may get rid of wasted work.  */
 296           return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
 297
 298         case COND_EXPR:
 299           /* Can treat the two alternative values like the operands
 300              of an arithmetic expression.  */
 301           {
 302             tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
 303             tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
 304
 305             if (outprec >= BITS_PER_WORD
 306                 || TRULY_NOOP_TRUNCATION (outprec, inprec)
 307                 || inprec > TYPE_PRECISION (TREE_TYPE (arg1))
 308                 || inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
 309               {
 310                 /* Do the arithmetic in type TYPEX,
 311                    then convert result to TYPE.  */
 312                 register tree typex = type;
 313
 314                 /* Can't do arithmetic in enumeral types
 315                    so use an integer type that will hold the values.  */
 316                 if (TREE_CODE (typex) == ENUMERAL_TYPE)
 317                   typex = type_for_size (TYPE_PRECISION (typex),
 318                                          TREE_UNSIGNED (typex));
 319
 320                 /* But now perhaps TYPEX is as wide as INPREC.
 321                    In that case, do nothing special here.
 322                    (Otherwise would recurse infinitely in convert.  */
 323                 if (TYPE_PRECISION (typex) != inprec)
 324                   {
 325                     /* Don't do unsigned arithmetic where signed was wanted,
 326                        or vice versa.  */
 327                     typex = (TREE_UNSIGNED (TREE_TYPE (expr))
 328                              ? unsigned_type (typex) : signed_type (typex));
 329                     return convert (type,
 330                                     fold (build (COND_EXPR, typex,
 331                                                  TREE_OPERAND (expr, 0),
 332                                                  convert (typex, arg1),
 333                                                  convert (typex, arg2))));
 334                   }
 335                 else
 336                   /* It is sometimes worthwhile
 337                      to push the narrowing down through the conditional.  */
 338                   return fold (build (COND_EXPR, type,
 339                                       TREE_OPERAND (expr, 0),
 340                                       convert (type, TREE_OPERAND (expr, 1)),
 341                                       convert (type, TREE_OPERAND (expr, 2))));
 342               }
 343           }
 344         }
 345
 346       return build1 (NOP_EXPR, type, expr);
 347     }
 348
 349   if (form == REAL_TYPE)
 350     return build1 (FIX_TRUNC_EXPR, type, expr);
 351
 352   error ("aggregate value used where an integer was expected");
 353
 354   {
 355     register tree tem = build_int_2 (0, 0);
 356     TREE_TYPE (tem) = type;
 357     return tem;
 358   }
 359 }
 360 \f
 361 /* Create an expression whose value is that of EXPR,
 362    converted to type TYPE.  The TREE_TYPE of the value
 363    is always TYPE.  This function implements all reasonable
 364    conversions; callers should filter out those that are
 365    not permitted by the language being compiled.  */
 366
 367 tree
 368 convert (type, expr)
 369      tree type, expr;
 370 {
 371   register tree e = expr;
 372   register enum tree_code code = TREE_CODE (type);
 373
 374   if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
 375     return expr;
 376   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
 377     return error_mark_node;
 378   if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
 379     {
 380       error ("void value not ignored as it ought to be");
 381       return error_mark_node;
 382     }
 383   if (code == VOID_TYPE)
 384     return build1 (CONVERT_EXPR, type, e);
 385 #if 0
 386   /* This is incorrect.  A truncation can't be stripped this way.
 387      Extensions will be stripped by the use of get_unwidened.  */
 388   if (TREE_CODE (expr) == NOP_EXPR)
 389     return convert (type, TREE_OPERAND (expr, 0));
 390 #endif
 391   if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
 392     return fold (convert_to_integer (type, e));
 393   if (code == POINTER_TYPE)
 394     return fold (convert_to_pointer (type, e));
 395   if (code == REAL_TYPE)
 396     return fold (convert_to_real (type, e));
 397
 398   error ("conversion to non-scalar type requested");
 399   return error_mark_node;
 400 }