![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to convert.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to convert.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Utility routines for data type conversion for GNU C. 1.1.1.3 ! root 2: Copyright (C) 1987, 1988, 1991, 1992, 1994 Free Software Foundation, Inc. 1.1 root 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: 1.1.1.3 ! root 88: if (INTEGRAL_TYPE_P (TREE_TYPE (expr))) 1.1 root 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 1.1.1.3 ! root 146: type of the expression. For logical operations, we must ! 147: also change the types of the operands to maintain type ! 148: correctness. */ 1.1 root 149: 1.1.1.3 ! root 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) 1.1 root 165: { 1.1.1.3 ! root 166: TREE_OPERAND (expr, 0) = convert (type, TREE_OPERAND (expr, 0)); 1.1 root 167: TREE_TYPE (expr) = type; 168: return expr; 169: } 170: else if (outprec >= inprec) 171: return build1 (NOP_EXPR, type, expr); 172: 1.1.1.3 ! root 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. */ 1.1 root 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 1.1.1.3 ! root 199: && tree_int_cst_lt (TREE_OPERAND (expr, 1), ! 200: convert (TREE_TYPE (TREE_OPERAND (expr, 1)), ! 201: integer_one_node))) 1.1 root 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 1.1.1.3 ! root 209: && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) >= 0 1.1 root 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: 1.1.1.2 root 310: /* This is not correct for ABS_EXPR, 311: since we must test the sign before truncation. */ 1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.