![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-common.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 c-common.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Subroutines shared by all languages that are variants of C. ! 2: Copyright (C) 1992 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: #include "config.h" ! 21: #include "tree.h" ! 22: #include "c-lex.h" ! 23: #include "c-tree.h" ! 24: #include "flags.h" ! 25: #include <stdio.h> ! 26: ! 27: #undef NULL ! 28: #define NULL 0 ! 29: ! 30: /* Given a chain of STRING_CST nodes, ! 31: concatenate them into one STRING_CST ! 32: and give it a suitable array-of-chars data type. */ ! 33: ! 34: tree ! 35: combine_strings (strings) ! 36: tree strings; ! 37: { ! 38: register tree value, t; ! 39: register int length = 1; ! 40: int wide_length = 0; ! 41: int wide_flag = 0; ! 42: int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; ! 43: int nchars; ! 44: ! 45: if (TREE_CHAIN (strings)) ! 46: { ! 47: /* More than one in the chain, so concatenate. */ ! 48: register char *p, *q; ! 49: ! 50: /* Don't include the \0 at the end of each substring, ! 51: except for the last one. ! 52: Count wide strings and ordinary strings separately. */ ! 53: for (t = strings; t; t = TREE_CHAIN (t)) ! 54: { ! 55: if (TREE_TYPE (t) == wchar_array_type_node) ! 56: { ! 57: wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes); ! 58: wide_flag = 1; ! 59: } ! 60: else ! 61: length += (TREE_STRING_LENGTH (t) - 1); ! 62: } ! 63: ! 64: /* If anything is wide, the non-wides will be converted, ! 65: which makes them take more space. */ ! 66: if (wide_flag) ! 67: length = length * wchar_bytes + wide_length; ! 68: ! 69: p = savealloc (length); ! 70: ! 71: /* Copy the individual strings into the new combined string. ! 72: If the combined string is wide, convert the chars to ints ! 73: for any individual strings that are not wide. */ ! 74: ! 75: q = p; ! 76: for (t = strings; t; t = TREE_CHAIN (t)) ! 77: { ! 78: int len = (TREE_STRING_LENGTH (t) ! 79: - ((TREE_TYPE (t) == wchar_array_type_node) ! 80: ? wchar_bytes : 1)); ! 81: if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag) ! 82: { ! 83: bcopy (TREE_STRING_POINTER (t), q, len); ! 84: q += len; ! 85: } ! 86: else ! 87: { ! 88: int i; ! 89: for (i = 0; i < len; i++) ! 90: ((int *) q)[i] = TREE_STRING_POINTER (t)[i]; ! 91: q += len * wchar_bytes; ! 92: } ! 93: } ! 94: if (wide_flag) ! 95: { ! 96: int i; ! 97: for (i = 0; i < wchar_bytes; i++) ! 98: *q++ = 0; ! 99: } ! 100: else ! 101: *q = 0; ! 102: ! 103: value = make_node (STRING_CST); ! 104: TREE_STRING_POINTER (value) = p; ! 105: TREE_STRING_LENGTH (value) = length; ! 106: TREE_CONSTANT (value) = 1; ! 107: } ! 108: else ! 109: { ! 110: value = strings; ! 111: length = TREE_STRING_LENGTH (value); ! 112: if (TREE_TYPE (value) == wchar_array_type_node) ! 113: wide_flag = 1; ! 114: } ! 115: ! 116: /* Compute the number of elements, for the array type. */ ! 117: nchars = wide_flag ? length / wchar_bytes : length; ! 118: ! 119: /* Create the array type for the string constant. ! 120: -Wwrite-strings says make the string constant an array of const char ! 121: so that copying it to a non-const pointer will get a warning. */ ! 122: if (warn_write_strings ! 123: && (! flag_traditional && ! flag_writable_strings)) ! 124: { ! 125: tree elements ! 126: = build_type_variant (wide_flag ? wchar_type_node : char_type_node, ! 127: 1, 0); ! 128: TREE_TYPE (value) ! 129: = build_array_type (elements, ! 130: build_index_type (build_int_2 (nchars - 1, 0))); ! 131: } ! 132: else ! 133: TREE_TYPE (value) ! 134: = build_array_type (wide_flag ? wchar_type_node : char_type_node, ! 135: build_index_type (build_int_2 (nchars - 1, 0))); ! 136: TREE_CONSTANT (value) = 1; ! 137: TREE_STATIC (value) = 1; ! 138: return value; ! 139: } ! 140: ! 141: /* Process the attributes listed in ATTRIBUTES ! 142: and install them in DECL. */ ! 143: ! 144: void ! 145: decl_attributes (decl, attributes) ! 146: tree decl, attributes; ! 147: { ! 148: tree a; ! 149: for (a = attributes; a; a = TREE_CHAIN (a)) ! 150: if (TREE_VALUE (a) != 0 ! 151: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST ! 152: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned")) ! 153: { ! 154: int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a))) ! 155: * BITS_PER_UNIT; ! 156: ! 157: if (exact_log2 (align) == -1) ! 158: warning_with_decl (decl, ! 159: "requested alignment of `%s' is not a power of 2"); ! 160: else if (TREE_CODE (decl) != VAR_DECL ! 161: && TREE_CODE (decl) != FIELD_DECL) ! 162: warning_with_decl (decl, ! 163: "alignment specified for `%s' which is not a variable"); ! 164: ! 165: /* ??? The maximum alignment gcc can currently handle is 16 bytes! ! 166: We should change the representation to be the log of the ! 167: actual alignment since we only handle powers of 2 anyway. */ ! 168: else if (align > 255) ! 169: warning_with_decl (decl, ! 170: "requested alignment of `%s' exceeds compiler limits"); ! 171: else ! 172: DECL_ALIGN (decl) = align; ! 173: } ! 174: else if (TREE_VALUE (a) != 0 ! 175: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST ! 176: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("packed")) ! 177: { ! 178: if (TREE_CODE (decl) == FIELD_DECL) ! 179: DECL_PACKED (decl) = 1; ! 180: } ! 181: else if (TREE_VALUE (a) != 0 ! 182: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST ! 183: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format")) ! 184: { ! 185: tree list = TREE_VALUE (TREE_VALUE (a)); ! 186: tree format_type = TREE_PURPOSE (list); ! 187: int format_num = TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list))); ! 188: int first_arg_num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list))); ! 189: int is_scan; ! 190: ! 191: if (TREE_CODE (decl) != FUNCTION_DECL) ! 192: { ! 193: warning_with_decl (decl, ! 194: "argument format specified for non-function `%s'"); ! 195: return; ! 196: } ! 197: ! 198: if (format_type == get_identifier ("printf")) ! 199: is_scan = 0; ! 200: else if (format_type == get_identifier ("scanf")) ! 201: is_scan = 1; ! 202: else ! 203: { ! 204: warning_with_decl (decl,"unrecognized format specifier for `%s'"); ! 205: return; ! 206: } ! 207: ! 208: if (first_arg_num != 0 && first_arg_num <= format_num) ! 209: { ! 210: warning_with_decl (decl, ! 211: "format string arg follows the args to be formatted, for `%s'"); ! 212: return; ! 213: } ! 214: ! 215: record_format_info (DECL_NAME (decl), is_scan, format_num, ! 216: first_arg_num); ! 217: } ! 218: } ! 219: ! 220: void ! 221: c_expand_expr_stmt (expr) ! 222: tree expr; ! 223: { ! 224: /* Do default conversion if safe and possibly important, ! 225: in case within ({...}). */ ! 226: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr)) ! 227: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE) ! 228: expr = default_conversion (expr); ! 229: ! 230: if (TREE_TYPE (expr) != error_mark_node ! 231: && TYPE_SIZE (TREE_TYPE (expr)) == 0 ! 232: && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) ! 233: error ("expression statement has incomplete type"); ! 234: ! 235: expand_expr_stmt (expr); ! 236: } ! 237: ! 238: /* Validate the expression after `case' and apply default promotions. */ ! 239: ! 240: tree ! 241: check_case_value (value) ! 242: tree value; ! 243: { ! 244: if (value == NULL_TREE) ! 245: return value; ! 246: ! 247: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ ! 248: if (TREE_CODE (value) == NON_LVALUE_EXPR) ! 249: value = TREE_OPERAND (value, 0); ! 250: ! 251: if (TREE_CODE (value) != INTEGER_CST ! 252: && value != error_mark_node) ! 253: { ! 254: error ("case label does not reduce to an integer constant"); ! 255: value = error_mark_node; ! 256: } ! 257: else ! 258: /* Promote char or short to int. */ ! 259: value = default_conversion (value); ! 260: ! 261: return value; ! 262: } ! 263: ! 264: /* Return an integer type with BITS bits of precision, ! 265: that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ ! 266: ! 267: tree ! 268: type_for_size (bits, unsignedp) ! 269: unsigned bits; ! 270: int unsignedp; ! 271: { ! 272: if (bits <= TYPE_PRECISION (signed_char_type_node)) ! 273: return unsignedp ? unsigned_char_type_node : signed_char_type_node; ! 274: ! 275: if (bits <= TYPE_PRECISION (short_integer_type_node)) ! 276: return unsignedp ? short_unsigned_type_node : short_integer_type_node; ! 277: ! 278: if (bits <= TYPE_PRECISION (integer_type_node)) ! 279: return unsignedp ? unsigned_type_node : integer_type_node; ! 280: ! 281: if (bits <= TYPE_PRECISION (long_integer_type_node)) ! 282: return unsignedp ? long_unsigned_type_node : long_integer_type_node; ! 283: ! 284: if (bits <= TYPE_PRECISION (long_long_integer_type_node)) ! 285: return (unsignedp ? long_long_unsigned_type_node ! 286: : long_long_integer_type_node); ! 287: ! 288: return 0; ! 289: } ! 290: ! 291: /* Return a data type that has machine mode MODE. ! 292: If the mode is an integer, ! 293: then UNSIGNEDP selects between signed and unsigned types. */ ! 294: ! 295: tree ! 296: type_for_mode (mode, unsignedp) ! 297: enum machine_mode mode; ! 298: int unsignedp; ! 299: { ! 300: if (mode == TYPE_MODE (signed_char_type_node)) ! 301: return unsignedp ? unsigned_char_type_node : signed_char_type_node; ! 302: ! 303: if (mode == TYPE_MODE (short_integer_type_node)) ! 304: return unsignedp ? short_unsigned_type_node : short_integer_type_node; ! 305: ! 306: if (mode == TYPE_MODE (integer_type_node)) ! 307: return unsignedp ? unsigned_type_node : integer_type_node; ! 308: ! 309: if (mode == TYPE_MODE (long_integer_type_node)) ! 310: return unsignedp ? long_unsigned_type_node : long_integer_type_node; ! 311: ! 312: if (mode == TYPE_MODE (long_long_integer_type_node)) ! 313: return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; ! 314: ! 315: if (mode == TYPE_MODE (float_type_node)) ! 316: return float_type_node; ! 317: ! 318: if (mode == TYPE_MODE (double_type_node)) ! 319: return double_type_node; ! 320: ! 321: if (mode == TYPE_MODE (long_double_type_node)) ! 322: return long_double_type_node; ! 323: ! 324: if (mode == TYPE_MODE (build_pointer_type (char_type_node))) ! 325: return build_pointer_type (char_type_node); ! 326: ! 327: if (mode == TYPE_MODE (build_pointer_type (integer_type_node))) ! 328: return build_pointer_type (integer_type_node); ! 329: ! 330: return 0; ! 331: } ! 332: ! 333: /* Print an error message for invalid operands to arith operation CODE. ! 334: NOP_EXPR is used as a special case (see truthvalue_conversion). */ ! 335: ! 336: void ! 337: binary_op_error (code) ! 338: enum tree_code code; ! 339: { ! 340: register char *opname; ! 341: switch (code) ! 342: { ! 343: case NOP_EXPR: ! 344: error ("invalid truth-value expression"); ! 345: return; ! 346: ! 347: case PLUS_EXPR: ! 348: opname = "+"; break; ! 349: case MINUS_EXPR: ! 350: opname = "-"; break; ! 351: case MULT_EXPR: ! 352: opname = "*"; break; ! 353: case MAX_EXPR: ! 354: opname = "max"; break; ! 355: case MIN_EXPR: ! 356: opname = "min"; break; ! 357: case EQ_EXPR: ! 358: opname = "=="; break; ! 359: case NE_EXPR: ! 360: opname = "!="; break; ! 361: case LE_EXPR: ! 362: opname = "<="; break; ! 363: case GE_EXPR: ! 364: opname = ">="; break; ! 365: case LT_EXPR: ! 366: opname = "<"; break; ! 367: case GT_EXPR: ! 368: opname = ">"; break; ! 369: case LSHIFT_EXPR: ! 370: opname = "<<"; break; ! 371: case RSHIFT_EXPR: ! 372: opname = ">>"; break; ! 373: case TRUNC_MOD_EXPR: ! 374: opname = "%"; break; ! 375: case TRUNC_DIV_EXPR: ! 376: opname = "/"; break; ! 377: case BIT_AND_EXPR: ! 378: opname = "&"; break; ! 379: case BIT_IOR_EXPR: ! 380: opname = "|"; break; ! 381: case TRUTH_ANDIF_EXPR: ! 382: opname = "&&"; break; ! 383: case TRUTH_ORIF_EXPR: ! 384: opname = "||"; break; ! 385: case BIT_XOR_EXPR: ! 386: opname = "^"; break; ! 387: } ! 388: error ("invalid operands to binary %s", opname); ! 389: } ! 390: ! 391: /* Subroutine of build_binary_op, used for comparison operations. ! 392: See if the operands have both been converted from subword integer types ! 393: and, if so, perhaps change them both back to their original type. ! 394: ! 395: The arguments of this function are all pointers to local variables ! 396: of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, ! 397: RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. ! 398: ! 399: If this function returns nonzero, it means that the comparison has ! 400: a constant value. What this function returns is an expression for ! 401: that value. */ ! 402: ! 403: tree ! 404: shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr) ! 405: tree *op0_ptr, *op1_ptr; ! 406: tree *restype_ptr; ! 407: enum tree_code *rescode_ptr; ! 408: { ! 409: register tree type; ! 410: tree op0 = *op0_ptr; ! 411: tree op1 = *op1_ptr; ! 412: int unsignedp0, unsignedp1; ! 413: int real1, real2; ! 414: tree primop0, primop1; ! 415: enum tree_code code = *rescode_ptr; ! 416: ! 417: /* Throw away any conversions to wider types ! 418: already present in the operands. */ ! 419: ! 420: primop0 = get_narrower (op0, &unsignedp0); ! 421: primop1 = get_narrower (op1, &unsignedp1); ! 422: ! 423: /* Handle the case that OP0 does not *contain* a conversion ! 424: but it *requires* conversion to FINAL_TYPE. */ ! 425: ! 426: if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) ! 427: unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0)); ! 428: if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) ! 429: unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1)); ! 430: ! 431: /* If one of the operands must be floated, we cannot optimize. */ ! 432: real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; ! 433: real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; ! 434: ! 435: /* If first arg is constant, swap the args (changing operation ! 436: so value is preserved), for canonicalization. */ ! 437: ! 438: if (TREE_CONSTANT (primop0)) ! 439: { ! 440: register tree tem = primop0; ! 441: register int temi = unsignedp0; ! 442: primop0 = primop1; ! 443: primop1 = tem; ! 444: tem = op0; ! 445: op0 = op1; ! 446: op1 = tem; ! 447: *op0_ptr = op0; ! 448: *op1_ptr = op1; ! 449: unsignedp0 = unsignedp1; ! 450: unsignedp1 = temi; ! 451: temi = real1; ! 452: real1 = real2; ! 453: real2 = temi; ! 454: ! 455: switch (code) ! 456: { ! 457: case LT_EXPR: ! 458: code = GT_EXPR; ! 459: break; ! 460: case GT_EXPR: ! 461: code = LT_EXPR; ! 462: break; ! 463: case LE_EXPR: ! 464: code = GE_EXPR; ! 465: break; ! 466: case GE_EXPR: ! 467: code = LE_EXPR; ! 468: break; ! 469: } ! 470: *rescode_ptr = code; ! 471: } ! 472: ! 473: /* If comparing an integer against a constant more bits wide, ! 474: maybe we can deduce a value of 1 or 0 independent of the data. ! 475: Or else truncate the constant now ! 476: rather than extend the variable at run time. ! 477: ! 478: This is only interesting if the constant is the wider arg. ! 479: Also, it is not safe if the constant is unsigned and the ! 480: variable arg is signed, since in this case the variable ! 481: would be sign-extended and then regarded as unsigned. ! 482: Our technique fails in this case because the lowest/highest ! 483: possible unsigned results don't follow naturally from the ! 484: lowest/highest possible values of the variable operand. ! 485: For just EQ_EXPR and NE_EXPR there is another technique that ! 486: could be used: see if the constant can be faithfully represented ! 487: in the other operand's type, by truncating it and reextending it ! 488: and see if that preserves the constant's value. */ ! 489: ! 490: if (!real1 && !real2 ! 491: && TREE_CODE (primop1) == INTEGER_CST ! 492: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) ! 493: { ! 494: int min_gt, max_gt, min_lt, max_lt; ! 495: tree maxval, minval; ! 496: /* 1 if comparison is nominally unsigned. */ ! 497: int unsignedp = TREE_UNSIGNED (*restype_ptr); ! 498: tree val; ! 499: ! 500: type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)); ! 501: ! 502: maxval = TYPE_MAX_VALUE (type); ! 503: minval = TYPE_MIN_VALUE (type); ! 504: ! 505: if (unsignedp && !unsignedp0) ! 506: *restype_ptr = signed_type (*restype_ptr); ! 507: ! 508: if (TREE_TYPE (primop1) != *restype_ptr) ! 509: primop1 = convert (*restype_ptr, primop1); ! 510: if (type != *restype_ptr) ! 511: { ! 512: minval = convert (*restype_ptr, minval); ! 513: maxval = convert (*restype_ptr, maxval); ! 514: } ! 515: ! 516: if (unsignedp && unsignedp0) ! 517: { ! 518: min_gt = INT_CST_LT_UNSIGNED (primop1, minval); ! 519: max_gt = INT_CST_LT_UNSIGNED (primop1, maxval); ! 520: min_lt = INT_CST_LT_UNSIGNED (minval, primop1); ! 521: max_lt = INT_CST_LT_UNSIGNED (maxval, primop1); ! 522: } ! 523: else ! 524: { ! 525: min_gt = INT_CST_LT (primop1, minval); ! 526: max_gt = INT_CST_LT (primop1, maxval); ! 527: min_lt = INT_CST_LT (minval, primop1); ! 528: max_lt = INT_CST_LT (maxval, primop1); ! 529: } ! 530: ! 531: val = 0; ! 532: /* This used to be a switch, but Genix compiler can't handle that. */ ! 533: if (code == NE_EXPR) ! 534: { ! 535: if (max_lt || min_gt) ! 536: val = integer_one_node; ! 537: } ! 538: else if (code == EQ_EXPR) ! 539: { ! 540: if (max_lt || min_gt) ! 541: val = integer_zero_node; ! 542: } ! 543: else if (code == LT_EXPR) ! 544: { ! 545: if (max_lt) ! 546: val = integer_one_node; ! 547: if (!min_lt) ! 548: val = integer_zero_node; ! 549: } ! 550: else if (code == GT_EXPR) ! 551: { ! 552: if (min_gt) ! 553: val = integer_one_node; ! 554: if (!max_gt) ! 555: val = integer_zero_node; ! 556: } ! 557: else if (code == LE_EXPR) ! 558: { ! 559: if (!max_gt) ! 560: val = integer_one_node; ! 561: if (min_gt) ! 562: val = integer_zero_node; ! 563: } ! 564: else if (code == GE_EXPR) ! 565: { ! 566: if (!min_lt) ! 567: val = integer_one_node; ! 568: if (max_lt) ! 569: val = integer_zero_node; ! 570: } ! 571: ! 572: /* If primop0 was sign-extended and unsigned comparison specd, ! 573: we did a signed comparison above using the signed type bounds. ! 574: But the comparison we output must be unsigned. ! 575: ! 576: Also, for inequalities, VAL is no good; but if the signed ! 577: comparison had *any* fixed result, it follows that the ! 578: unsigned comparison just tests the sign in reverse ! 579: (positive values are LE, negative ones GE). ! 580: So we can generate an unsigned comparison ! 581: against an extreme value of the signed type. */ ! 582: ! 583: if (unsignedp && !unsignedp0) ! 584: { ! 585: if (val != 0) ! 586: switch (code) ! 587: { ! 588: case LT_EXPR: ! 589: case GE_EXPR: ! 590: primop1 = TYPE_MIN_VALUE (type); ! 591: val = 0; ! 592: break; ! 593: ! 594: case LE_EXPR: ! 595: case GT_EXPR: ! 596: primop1 = TYPE_MAX_VALUE (type); ! 597: val = 0; ! 598: break; ! 599: } ! 600: type = unsigned_type (type); ! 601: } ! 602: ! 603: if (max_lt && !unsignedp0) ! 604: { ! 605: /* This is the case of (char)x >?< 0x80, which people used to use ! 606: expecting old C compilers to change the 0x80 into -0x80. */ ! 607: if (val == integer_zero_node) ! 608: warning ("comparison is always 0 due to limited range of data type"); ! 609: if (val == integer_one_node) ! 610: warning ("comparison is always 1 due to limited range of data type"); ! 611: } ! 612: ! 613: if (min_gt && unsignedp0) ! 614: { ! 615: /* This is the case of (unsigned char)x >?< -1. */ ! 616: if (val == integer_zero_node) ! 617: warning ("comparison is always 0 due to limited range of data type"); ! 618: if (val == integer_one_node) ! 619: warning ("comparison is always 1 due to limited range of data type"); ! 620: } ! 621: ! 622: if (val != 0) ! 623: { ! 624: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ ! 625: if (TREE_SIDE_EFFECTS (primop0)) ! 626: return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); ! 627: return val; ! 628: } ! 629: ! 630: /* Value is not predetermined, but do the comparison ! 631: in the type of the operand that is not constant. ! 632: TYPE is already properly set. */ ! 633: } ! 634: else if (real1 && real2 ! 635: && TYPE_PRECISION (TREE_TYPE (primop0)) == TYPE_PRECISION (TREE_TYPE (primop1))) ! 636: type = TREE_TYPE (primop0); ! 637: ! 638: /* If args' natural types are both narrower than nominal type ! 639: and both extend in the same manner, compare them ! 640: in the type of the wider arg. ! 641: Otherwise must actually extend both to the nominal ! 642: common type lest different ways of extending ! 643: alter the result. ! 644: (eg, (short)-1 == (unsigned short)-1 should be 0.) */ ! 645: ! 646: else if (unsignedp0 == unsignedp1 && real1 == real2 ! 647: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) ! 648: && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) ! 649: { ! 650: type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); ! 651: type = signed_or_unsigned_type (unsignedp0 ! 652: || TREE_UNSIGNED (*restype_ptr), ! 653: type); ! 654: /* Make sure shorter operand is extended the right way ! 655: to match the longer operand. */ ! 656: primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)), ! 657: primop0); ! 658: primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)), ! 659: primop1); ! 660: } ! 661: else ! 662: { ! 663: /* Here we must do the comparison on the nominal type ! 664: using the args exactly as we received them. */ ! 665: type = *restype_ptr; ! 666: primop0 = op0; ! 667: primop1 = op1; ! 668: ! 669: if (!real1 && !real2 && integer_zerop (primop1) ! 670: && TREE_UNSIGNED (TREE_TYPE (primop0))) ! 671: { ! 672: tree value = 0; ! 673: switch (code) ! 674: { ! 675: case GE_EXPR: ! 676: if (extra_warnings) ! 677: warning ("unsigned value >= 0 is always 1"); ! 678: value = integer_one_node; ! 679: break; ! 680: ! 681: case LT_EXPR: ! 682: if (extra_warnings) ! 683: warning ("unsigned value < 0 is always 0"); ! 684: value = integer_zero_node; ! 685: } ! 686: ! 687: if (value != 0) ! 688: { ! 689: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ ! 690: if (TREE_SIDE_EFFECTS (primop0)) ! 691: return build (COMPOUND_EXPR, TREE_TYPE (value), ! 692: primop0, value); ! 693: return value; ! 694: } ! 695: } ! 696: } ! 697: ! 698: *op0_ptr = convert (type, primop0); ! 699: *op1_ptr = convert (type, primop1); ! 700: ! 701: *restype_ptr = integer_type_node; ! 702: ! 703: return 0; ! 704: } ! 705: ! 706: /* Prepare expr to be an argument of a TRUTH_NOT_EXPR, ! 707: or validate its data type for an `if' or `while' statement or ?..: exp. ! 708: ! 709: This preparation consists of taking the ordinary ! 710: representation of an expression expr and producing a valid tree ! 711: boolean expression describing whether expr is nonzero. We could ! 712: simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1), ! 713: but we optimize comparisons, &&, ||, and !. ! 714: ! 715: The resulting type should always be `integer_type_node'. */ ! 716: ! 717: tree ! 718: truthvalue_conversion (expr) ! 719: tree expr; ! 720: { ! 721: register enum tree_code code; ! 722: ! 723: switch (TREE_CODE (expr)) ! 724: { ! 725: /* It is simpler and generates better code to have only TRUTH_*_EXPR ! 726: or comparison expressions as truth values at this level. */ ! 727: #if 0 ! 728: case COMPONENT_REF: ! 729: /* A one-bit unsigned bit-field is already acceptable. */ ! 730: if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1))) ! 731: && TREE_UNSIGNED (TREE_OPERAND (expr, 1))) ! 732: return expr; ! 733: break; ! 734: #endif ! 735: ! 736: case EQ_EXPR: ! 737: /* It is simpler and generates better code to have only TRUTH_*_EXPR ! 738: or comparison expressions as truth values at this level. */ ! 739: #if 0 ! 740: if (integer_zerop (TREE_OPERAND (expr, 1))) ! 741: return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0); ! 742: #endif ! 743: case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: ! 744: case TRUTH_ANDIF_EXPR: ! 745: case TRUTH_ORIF_EXPR: ! 746: case TRUTH_AND_EXPR: ! 747: case TRUTH_OR_EXPR: ! 748: case ERROR_MARK: ! 749: return expr; ! 750: ! 751: case INTEGER_CST: ! 752: return integer_zerop (expr) ? integer_zero_node : integer_one_node; ! 753: ! 754: case REAL_CST: ! 755: return real_zerop (expr) ? integer_zero_node : integer_one_node; ! 756: ! 757: case ADDR_EXPR: ! 758: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0))) ! 759: return build (COMPOUND_EXPR, integer_type_node, ! 760: TREE_OPERAND (expr, 0), integer_one_node); ! 761: else ! 762: return integer_one_node; ! 763: ! 764: case NEGATE_EXPR: ! 765: case ABS_EXPR: ! 766: case FLOAT_EXPR: ! 767: case FFS_EXPR: ! 768: /* These don't change whether an object is non-zero or zero. */ ! 769: return truthvalue_conversion (TREE_OPERAND (expr, 0)); ! 770: ! 771: case LROTATE_EXPR: ! 772: case RROTATE_EXPR: ! 773: /* These don't change whether an object is zero or non-zero, but ! 774: we can't ignore them if their second arg has side-effects. */ ! 775: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) ! 776: return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1), ! 777: truthvalue_conversion (TREE_OPERAND (expr, 0))); ! 778: else ! 779: return truthvalue_conversion (TREE_OPERAND (expr, 0)); ! 780: ! 781: case COND_EXPR: ! 782: /* Distribute the conversion into the arms of a COND_EXPR. */ ! 783: return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0), ! 784: truthvalue_conversion (TREE_OPERAND (expr, 1)), ! 785: truthvalue_conversion (TREE_OPERAND (expr, 2)))); ! 786: ! 787: case CONVERT_EXPR: ! 788: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, ! 789: since that affects how `default_conversion' will behave. */ ! 790: if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE ! 791: || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) ! 792: break; ! 793: /* fall through... */ ! 794: case NOP_EXPR: ! 795: /* If this is widening the argument, we can ignore it. */ ! 796: if (TYPE_PRECISION (TREE_TYPE (expr)) ! 797: >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) ! 798: return truthvalue_conversion (TREE_OPERAND (expr, 0)); ! 799: break; ! 800: ! 801: case BIT_XOR_EXPR: ! 802: case MINUS_EXPR: ! 803: /* These can be changed into a comparison of the two objects. */ ! 804: if (TREE_TYPE (TREE_OPERAND (expr, 0)) ! 805: == TREE_TYPE (TREE_OPERAND (expr, 1))) ! 806: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), ! 807: TREE_OPERAND (expr, 1), 1); ! 808: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), ! 809: fold (build1 (NOP_EXPR, ! 810: TREE_TYPE (TREE_OPERAND (expr, 0)), ! 811: TREE_OPERAND (expr, 1))), 1); ! 812: } ! 813: ! 814: return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); ! 815: } ! 816: ! 817: /* Read the rest of a #-directive from input stream FINPUT. ! 818: In normal use, the directive name and the white space after it ! 819: have already been read, so they won't be included in the result. ! 820: We allow for the fact that the directive line may contain ! 821: a newline embedded within a character or string literal which forms ! 822: a part of the directive. ! 823: ! 824: The value is a string in a reusable buffer. It remains valid ! 825: only until the next time this function is called. */ ! 826: ! 827: char * ! 828: get_directive_line (finput) ! 829: register FILE *finput; ! 830: { ! 831: static char *directive_buffer = NULL; ! 832: static unsigned buffer_length = 0; ! 833: register char *p; ! 834: register char *buffer_limit; ! 835: register int looking_for = 0; ! 836: register int char_escaped = 0; ! 837: ! 838: if (buffer_length == 0) ! 839: { ! 840: directive_buffer = (char *)xmalloc (128); ! 841: buffer_length = 128; ! 842: } ! 843: ! 844: buffer_limit = &directive_buffer[buffer_length]; ! 845: ! 846: for (p = directive_buffer; ; ) ! 847: { ! 848: int c; ! 849: ! 850: /* Make buffer bigger if it is full. */ ! 851: if (p >= buffer_limit) ! 852: { ! 853: register unsigned bytes_used = (p - directive_buffer); ! 854: ! 855: buffer_length *= 2; ! 856: directive_buffer ! 857: = (char *)xrealloc (directive_buffer, buffer_length); ! 858: p = &directive_buffer[bytes_used]; ! 859: buffer_limit = &directive_buffer[buffer_length]; ! 860: } ! 861: ! 862: c = getc (finput); ! 863: ! 864: /* Discard initial whitespace. */ ! 865: if ((c == ' ' || c == '\t') && p == directive_buffer) ! 866: continue; ! 867: ! 868: /* Detect the end of the directive. */ ! 869: if (c == '\n' && looking_for == 0) ! 870: { ! 871: ungetc (c, finput); ! 872: c = '\0'; ! 873: } ! 874: ! 875: *p++ = c; ! 876: ! 877: if (c == 0) ! 878: return directive_buffer; ! 879: ! 880: /* Handle string and character constant syntax. */ ! 881: if (looking_for) ! 882: { ! 883: if (looking_for == c && !char_escaped) ! 884: looking_for = 0; /* Found terminator... stop looking. */ ! 885: } ! 886: else ! 887: if (c == '\'' || c == '"') ! 888: looking_for = c; /* Don't stop buffering until we see another ! 889: another one of these (or an EOF). */ ! 890: ! 891: /* Handle backslash. */ ! 892: char_escaped = (c == '\\' && ! char_escaped); ! 893: } ! 894: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.