![[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. 1.1.1.7 ! root 2: Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc. 1.1 root 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 1.1.1.7 ! root 18: the Free Software Foundation, 59 Temple Place - Suite 330, ! 19: Boston, MA 02111-1307, USA. */ 1.1 root 20: 21: #include "config.h" 22: #include "tree.h" 23: #include "c-lex.h" 24: #include "c-tree.h" 25: #include "flags.h" 1.1.1.4 root 26: #include "obstack.h" 1.1 root 27: #include <stdio.h> 1.1.1.5 root 28: #include <ctype.h> 1.1 root 29: 1.1.1.4 root 30: extern struct obstack permanent_obstack; 31: 1.1.1.7 ! root 32: enum attrs {A_PACKED, A_NOCOMMON, A_NORETURN, A_CONST, A_T_UNION, ! 33: A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED, ! 34: A_UNUSED, A_FORMAT, A_WEAK, A_ALIAS}; ! 35: ! 36: static void declare_hidden_char_array PROTO((char *, char *)); ! 37: static void add_attribute PROTO((enum attrs, char *, ! 38: int, int, int)); ! 39: static void init_attributes PROTO((void)); 1.1.1.5 root 40: 1.1.1.2 root 41: /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */ 42: 43: void 44: declare_function_name () 45: { 46: char *name, *printable_name; 47: 48: if (current_function_decl == NULL) 49: { 50: name = ""; 51: printable_name = "top level"; 52: } 53: else 54: { 55: char *kind = "function"; 56: if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) 57: kind = "method"; 1.1.1.3 root 58: /* Allow functions to be nameless (such as artificial ones). */ 59: if (DECL_NAME (current_function_decl)) 60: name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl)); 61: else 62: name = ""; 1.1.1.2 root 63: printable_name = (*decl_printable_name) (current_function_decl, &kind); 64: } 65: 1.1.1.5 root 66: declare_hidden_char_array ("__FUNCTION__", name); 67: declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name); 68: } 1.1.1.4 root 69: 1.1.1.5 root 70: static void 71: declare_hidden_char_array (name, value) 72: char *name, *value; 73: { 74: tree decl, type, init; 75: int vlen; 1.1.1.2 root 76: 1.1.1.5 root 77: /* If the default size of char arrays isn't big enough for the name, 1.1.1.6 root 78: or if we want to give warnings for large objects, make a bigger one. */ 1.1.1.5 root 79: vlen = strlen (value) + 1; 1.1.1.4 root 80: type = char_array_type_node; 1.1.1.6 root 81: if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type))) < vlen 82: || warn_larger_than) 1.1.1.4 root 83: type = build_array_type (char_type_node, 1.1.1.5 root 84: build_index_type (build_int_2 (vlen, 0))); 1.1.1.2 root 85: push_obstacks_nochange (); 1.1.1.5 root 86: decl = build_decl (VAR_DECL, get_identifier (name), type); 1.1.1.2 root 87: TREE_STATIC (decl) = 1; 88: TREE_READONLY (decl) = 1; 1.1.1.5 root 89: TREE_ASM_WRITTEN (decl) = 1; 1.1.1.3 root 90: DECL_SOURCE_LINE (decl) = 0; 1.1.1.7 ! root 91: DECL_ARTIFICIAL (decl) = 1; 1.1.1.3 root 92: DECL_IN_SYSTEM_HEADER (decl) = 1; 1.1.1.2 root 93: DECL_IGNORED_P (decl) = 1; 1.1.1.5 root 94: init = build_string (vlen, value); 1.1.1.4 root 95: TREE_TYPE (init) = type; 1.1.1.2 root 96: DECL_INITIAL (decl) = init; 97: finish_decl (pushdecl (decl), init, NULL_TREE); 98: } 99: 1.1 root 100: /* Given a chain of STRING_CST nodes, 101: concatenate them into one STRING_CST 102: and give it a suitable array-of-chars data type. */ 103: 104: tree 105: combine_strings (strings) 106: tree strings; 107: { 108: register tree value, t; 109: register int length = 1; 110: int wide_length = 0; 111: int wide_flag = 0; 112: int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 113: int nchars; 114: 115: if (TREE_CHAIN (strings)) 116: { 117: /* More than one in the chain, so concatenate. */ 118: register char *p, *q; 119: 120: /* Don't include the \0 at the end of each substring, 121: except for the last one. 122: Count wide strings and ordinary strings separately. */ 123: for (t = strings; t; t = TREE_CHAIN (t)) 124: { 125: if (TREE_TYPE (t) == wchar_array_type_node) 126: { 127: wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes); 128: wide_flag = 1; 129: } 130: else 131: length += (TREE_STRING_LENGTH (t) - 1); 132: } 133: 134: /* If anything is wide, the non-wides will be converted, 135: which makes them take more space. */ 136: if (wide_flag) 137: length = length * wchar_bytes + wide_length; 138: 139: p = savealloc (length); 140: 141: /* Copy the individual strings into the new combined string. 142: If the combined string is wide, convert the chars to ints 143: for any individual strings that are not wide. */ 144: 145: q = p; 146: for (t = strings; t; t = TREE_CHAIN (t)) 147: { 148: int len = (TREE_STRING_LENGTH (t) 149: - ((TREE_TYPE (t) == wchar_array_type_node) 150: ? wchar_bytes : 1)); 151: if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag) 152: { 153: bcopy (TREE_STRING_POINTER (t), q, len); 154: q += len; 155: } 156: else 157: { 158: int i; 159: for (i = 0; i < len; i++) 160: ((int *) q)[i] = TREE_STRING_POINTER (t)[i]; 161: q += len * wchar_bytes; 162: } 163: } 164: if (wide_flag) 165: { 166: int i; 167: for (i = 0; i < wchar_bytes; i++) 168: *q++ = 0; 169: } 170: else 171: *q = 0; 172: 173: value = make_node (STRING_CST); 174: TREE_STRING_POINTER (value) = p; 175: TREE_STRING_LENGTH (value) = length; 176: TREE_CONSTANT (value) = 1; 177: } 178: else 179: { 180: value = strings; 181: length = TREE_STRING_LENGTH (value); 182: if (TREE_TYPE (value) == wchar_array_type_node) 183: wide_flag = 1; 184: } 185: 186: /* Compute the number of elements, for the array type. */ 187: nchars = wide_flag ? length / wchar_bytes : length; 188: 189: /* Create the array type for the string constant. 190: -Wwrite-strings says make the string constant an array of const char 191: so that copying it to a non-const pointer will get a warning. */ 192: if (warn_write_strings 193: && (! flag_traditional && ! flag_writable_strings)) 194: { 195: tree elements 196: = build_type_variant (wide_flag ? wchar_type_node : char_type_node, 197: 1, 0); 198: TREE_TYPE (value) 199: = build_array_type (elements, 200: build_index_type (build_int_2 (nchars - 1, 0))); 201: } 202: else 203: TREE_TYPE (value) 204: = build_array_type (wide_flag ? wchar_type_node : char_type_node, 205: build_index_type (build_int_2 (nchars - 1, 0))); 206: TREE_CONSTANT (value) = 1; 207: TREE_STATIC (value) = 1; 208: return value; 209: } 210: 1.1.1.7 ! root 211: /* To speed up processing of attributes, we maintain an array of ! 212: IDENTIFIER_NODES and the corresponding attribute types. */ ! 213: ! 214: /* Array to hold attribute information. */ ! 215: ! 216: static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50]; ! 217: ! 218: static int attrtab_idx = 0; ! 219: ! 220: /* Add an entry to the attribute table above. */ ! 221: ! 222: static void ! 223: add_attribute (id, string, min_len, max_len, decl_req) ! 224: enum attrs id; ! 225: char *string; ! 226: int min_len, max_len; ! 227: int decl_req; ! 228: { ! 229: char buf[100]; ! 230: ! 231: attrtab[attrtab_idx].id = id; ! 232: attrtab[attrtab_idx].name = get_identifier (string); ! 233: attrtab[attrtab_idx].min = min_len; ! 234: attrtab[attrtab_idx].max = max_len; ! 235: attrtab[attrtab_idx++].decl_req = decl_req; ! 236: ! 237: sprintf (buf, "__%s__", string); ! 238: ! 239: attrtab[attrtab_idx].id = id; ! 240: attrtab[attrtab_idx].name = get_identifier (buf); ! 241: attrtab[attrtab_idx].min = min_len; ! 242: attrtab[attrtab_idx].max = max_len; ! 243: attrtab[attrtab_idx++].decl_req = decl_req; ! 244: } ! 245: ! 246: /* Initialize attribute table. */ ! 247: ! 248: static void ! 249: init_attributes () ! 250: { ! 251: add_attribute (A_PACKED, "packed", 0, 0, 0); ! 252: add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1); ! 253: add_attribute (A_NORETURN, "noreturn", 0, 0, 1); ! 254: add_attribute (A_NORETURN, "volatile", 0, 0, 1); ! 255: add_attribute (A_UNUSED, "unused", 0, 0, 1); ! 256: add_attribute (A_CONST, "const", 0, 0, 1); ! 257: add_attribute (A_T_UNION, "transparent_union", 0, 0, 0); ! 258: add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1); ! 259: add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1); ! 260: add_attribute (A_MODE, "mode", 1, 1, 1); ! 261: add_attribute (A_SECTION, "section", 1, 1, 1); ! 262: add_attribute (A_ALIGNED, "aligned", 0, 1, 0); ! 263: add_attribute (A_FORMAT, "format", 3, 3, 1); ! 264: add_attribute (A_WEAK, "weak", 0, 0, 1); ! 265: add_attribute (A_ALIAS, "alias", 1, 1, 1); ! 266: } ! 267: ! 268: /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES ! 269: and install them in NODE, which is either a DECL (including a TYPE_DECL) ! 270: or a TYPE. PREFIX_ATTRIBUTES can appear after the declaration specifiers ! 271: and declaration modifiers but before the declaration proper. */ 1.1 root 272: 273: void 1.1.1.7 ! root 274: decl_attributes (node, attributes, prefix_attributes) ! 275: tree node, attributes, prefix_attributes; 1.1 root 276: { 1.1.1.7 ! root 277: tree decl = 0, type; ! 278: int is_type; ! 279: tree a; 1.1.1.6 root 280: 1.1.1.7 ! root 281: if (attrtab_idx == 0) ! 282: init_attributes (); ! 283: ! 284: if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd') ! 285: { ! 286: decl = node; ! 287: type = TREE_TYPE (decl); ! 288: is_type = TREE_CODE (node) == TYPE_DECL; ! 289: } ! 290: else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't') ! 291: type = node, is_type = 1; 1.1.1.6 root 292: 1.1.1.7 ! root 293: attributes = chainon (prefix_attributes, attributes); 1.1.1.6 root 294: 1.1 root 295: for (a = attributes; a; a = TREE_CHAIN (a)) 1.1.1.7 ! root 296: { ! 297: tree name = TREE_PURPOSE (a); ! 298: tree args = TREE_VALUE (a); ! 299: int i; ! 300: enum attrs id; ! 301: ! 302: for (i = 0; i < attrtab_idx; i++) ! 303: if (attrtab[i].name == name) ! 304: break; 1.1.1.6 root 305: 1.1.1.7 ! root 306: if (i == attrtab_idx) ! 307: { ! 308: if (! valid_machine_attribute (name, args, decl, type)) ! 309: warning ("`%s' attribute directive ignored", ! 310: IDENTIFIER_POINTER (name)); ! 311: continue; ! 312: } ! 313: else if (attrtab[i].decl_req && decl == 0) ! 314: { ! 315: warning ("`%s' attribute does not apply to types", 1.1.1.6 root 316: IDENTIFIER_POINTER (name)); 1.1.1.7 ! root 317: continue; ! 318: } ! 319: else if (list_length (args) < attrtab[i].min ! 320: || list_length (args) > attrtab[i].max) ! 321: { ! 322: error ("wrong number of arguments specified for `%s' attribute", ! 323: IDENTIFIER_POINTER (name)); ! 324: continue; ! 325: } ! 326: ! 327: id = attrtab[i].id; ! 328: switch (id) ! 329: { ! 330: case A_PACKED: ! 331: if (is_type) ! 332: TYPE_PACKED (type) = 1; ! 333: else if (TREE_CODE (decl) == FIELD_DECL) ! 334: DECL_PACKED (decl) = 1; ! 335: /* We can't set DECL_PACKED for a VAR_DECL, because the bit is ! 336: used for DECL_REGISTER. It wouldn't mean anything anyway. */ ! 337: else ! 338: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 339: break; ! 340: ! 341: case A_NOCOMMON: ! 342: if (TREE_CODE (decl) == VAR_DECL) ! 343: DECL_COMMON (decl) = 0; ! 344: else ! 345: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 346: break; ! 347: ! 348: case A_NORETURN: ! 349: if (TREE_CODE (decl) == FUNCTION_DECL) ! 350: TREE_THIS_VOLATILE (decl) = 1; ! 351: else if (TREE_CODE (type) == POINTER_TYPE ! 352: && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) ! 353: TREE_TYPE (decl) = type ! 354: = build_pointer_type ! 355: (build_type_variant (TREE_TYPE (type), ! 356: TREE_READONLY (TREE_TYPE (type)), 1)); ! 357: else ! 358: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 359: break; ! 360: ! 361: case A_UNUSED: ! 362: if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL ! 363: || TREE_CODE (decl) == FUNCTION_DECL) ! 364: TREE_USED (decl) = 1; ! 365: else ! 366: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 367: break; ! 368: ! 369: case A_CONST: ! 370: if (TREE_CODE (decl) == FUNCTION_DECL) ! 371: TREE_READONLY (decl) = 1; ! 372: else if (TREE_CODE (type) == POINTER_TYPE ! 373: && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) ! 374: TREE_TYPE (decl) = type ! 375: = build_pointer_type ! 376: (build_type_variant (TREE_TYPE (type), 1, ! 377: TREE_THIS_VOLATILE (TREE_TYPE (type)))); ! 378: else ! 379: warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 380: break; ! 381: ! 382: case A_T_UNION: ! 383: if (is_type ! 384: && TREE_CODE (type) == UNION_TYPE ! 385: && (decl == 0 ! 386: || TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))) ! 387: TYPE_TRANSPARENT_UNION (type) = 1; ! 388: else if (decl != 0 && TREE_CODE (decl) == PARM_DECL ! 389: && TREE_CODE (type) == UNION_TYPE ! 390: && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type))) ! 391: DECL_TRANSPARENT_UNION (decl) = 1; ! 392: else ! 393: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 394: break; ! 395: ! 396: case A_CONSTRUCTOR: ! 397: if (TREE_CODE (decl) == FUNCTION_DECL ! 398: && TREE_CODE (type) == FUNCTION_TYPE ! 399: && decl_function_context (decl) == 0) ! 400: { ! 401: DECL_STATIC_CONSTRUCTOR (decl) = 1; ! 402: TREE_USED (decl) = 1; ! 403: } ! 404: else ! 405: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 406: break; ! 407: ! 408: case A_DESTRUCTOR: ! 409: if (TREE_CODE (decl) == FUNCTION_DECL ! 410: && TREE_CODE (type) == FUNCTION_TYPE ! 411: && decl_function_context (decl) == 0) ! 412: { ! 413: DECL_STATIC_DESTRUCTOR (decl) = 1; ! 414: TREE_USED (decl) = 1; ! 415: } ! 416: else ! 417: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 418: break; ! 419: ! 420: case A_MODE: ! 421: if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE) ! 422: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 423: else ! 424: { ! 425: int j; ! 426: char *p = IDENTIFIER_POINTER (TREE_VALUE (args)); ! 427: int len = strlen (p); ! 428: enum machine_mode mode = VOIDmode; ! 429: tree typefm; ! 430: ! 431: if (len > 4 && p[0] == '_' && p[1] == '_' ! 432: && p[len - 1] == '_' && p[len - 2] == '_') ! 433: { ! 434: char *newp = (char *) alloca (len - 1); ! 435: ! 436: strcpy (newp, &p[2]); ! 437: newp[len - 4] = '\0'; ! 438: p = newp; ! 439: } ! 440: ! 441: /* Give this decl a type with the specified mode. ! 442: First check for the special modes. */ ! 443: if (! strcmp (p, "byte")) ! 444: mode = byte_mode; ! 445: else if (!strcmp (p, "word")) ! 446: mode = word_mode; ! 447: else if (! strcmp (p, "pointer")) ! 448: mode = ptr_mode; ! 449: else ! 450: for (j = 0; j < NUM_MACHINE_MODES; j++) ! 451: if (!strcmp (p, GET_MODE_NAME (j))) ! 452: mode = (enum machine_mode) j; ! 453: ! 454: if (mode == VOIDmode) ! 455: error ("unknown machine mode `%s'", p); ! 456: else if (0 == (typefm = type_for_mode (mode, ! 457: TREE_UNSIGNED (type)))) ! 458: error ("no data type for mode `%s'", p); ! 459: else 1.1.1.2 root 460: { 1.1.1.6 root 461: TREE_TYPE (decl) = type = typefm; 1.1.1.2 root 462: DECL_SIZE (decl) = 0; 1.1.1.3 root 463: layout_decl (decl, 0); 1.1.1.2 root 464: } 465: } 1.1.1.7 ! root 466: break; ! 467: ! 468: case A_SECTION: 1.1.1.6 root 469: #ifdef ASM_OUTPUT_SECTION_NAME 1.1.1.7 ! root 470: if ((TREE_CODE (decl) == FUNCTION_DECL ! 471: || TREE_CODE (decl) == VAR_DECL) ! 472: && TREE_CODE (TREE_VALUE (args)) == STRING_CST) ! 473: { ! 474: if (TREE_CODE (decl) == VAR_DECL ! 475: && current_function_decl != NULL_TREE) ! 476: error_with_decl (decl, ! 477: "section attribute cannot be specified for local variables"); ! 478: /* The decl may have already been given a section attribute from ! 479: a previous declaration. Ensure they match. */ ! 480: else if (DECL_SECTION_NAME (decl) != NULL_TREE ! 481: && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), ! 482: TREE_STRING_POINTER (TREE_VALUE (args))) != 0) ! 483: error_with_decl (node, ! 484: "section of `%s' conflicts with previous declaration"); ! 485: else ! 486: DECL_SECTION_NAME (decl) = TREE_VALUE (args); ! 487: } ! 488: else ! 489: error_with_decl (node, 1.1.1.6 root 490: "section attribute not allowed for `%s'"); 491: #else 1.1.1.7 ! root 492: error_with_decl (node, ! 493: "section attributes are not supported for this target"); 1.1.1.6 root 494: #endif 1.1.1.7 ! root 495: break; 1.1.1.6 root 496: 1.1.1.7 ! root 497: case A_ALIGNED: 1.1.1.6 root 498: { 1.1.1.7 ! root 499: tree align_expr ! 500: = args ? TREE_VALUE (args) : size_int (BIGGEST_ALIGNMENT); ! 501: int align; ! 502: ! 503: /* Strip any NOPs of any kind. */ ! 504: while (TREE_CODE (align_expr) == NOP_EXPR ! 505: || TREE_CODE (align_expr) == CONVERT_EXPR ! 506: || TREE_CODE (align_expr) == NON_LVALUE_EXPR) ! 507: align_expr = TREE_OPERAND (align_expr, 0); ! 508: ! 509: if (TREE_CODE (align_expr) != INTEGER_CST) ! 510: { ! 511: error ("requested alignment is not a constant"); ! 512: continue; ! 513: } ! 514: ! 515: align = TREE_INT_CST_LOW (align_expr) * BITS_PER_UNIT; ! 516: ! 517: if (exact_log2 (align) == -1) ! 518: error ("requested alignment is not a power of 2"); ! 519: else if (is_type) ! 520: TYPE_ALIGN (type) = align; ! 521: else if (TREE_CODE (decl) != VAR_DECL ! 522: && TREE_CODE (decl) != FIELD_DECL) ! 523: error_with_decl (decl, ! 524: "alignment may not be specified for `%s'"); ! 525: else ! 526: DECL_ALIGN (decl) = align; 1.1.1.6 root 527: } 1.1.1.7 ! root 528: break; 1.1.1.6 root 529: 1.1.1.7 ! root 530: case A_FORMAT: 1.1 root 531: { 1.1.1.7 ! root 532: tree format_type = TREE_VALUE (args); ! 533: tree format_num_expr = TREE_VALUE (TREE_CHAIN (args)); ! 534: tree first_arg_num_expr ! 535: = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))); ! 536: int format_num; ! 537: int first_arg_num; ! 538: int is_scan; ! 539: tree argument; ! 540: int arg_num; 1.1 root 541: 1.1.1.7 ! root 542: if (TREE_CODE (decl) != FUNCTION_DECL) ! 543: { ! 544: error_with_decl (decl, ! 545: "argument format specified for non-function `%s'"); ! 546: continue; ! 547: } 1.1 root 548: 1.1.1.7 ! root 549: if (TREE_CODE (format_type) == IDENTIFIER_NODE ! 550: && (!strcmp (IDENTIFIER_POINTER (format_type), "printf") ! 551: || !strcmp (IDENTIFIER_POINTER (format_type), ! 552: "__printf__"))) ! 553: is_scan = 0; ! 554: else if (TREE_CODE (format_type) == IDENTIFIER_NODE ! 555: && (!strcmp (IDENTIFIER_POINTER (format_type), "scanf") ! 556: || !strcmp (IDENTIFIER_POINTER (format_type), ! 557: "__scanf__"))) ! 558: is_scan = 1; ! 559: else ! 560: { ! 561: error ("unrecognized format specifier for `%s'"); ! 562: continue; ! 563: } 1.1.1.4 root 564: 1.1.1.7 ! root 565: /* Strip any conversions from the string index and first arg number ! 566: and verify they are constants. */ ! 567: while (TREE_CODE (format_num_expr) == NOP_EXPR ! 568: || TREE_CODE (format_num_expr) == CONVERT_EXPR ! 569: || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR) ! 570: format_num_expr = TREE_OPERAND (format_num_expr, 0); ! 571: ! 572: while (TREE_CODE (first_arg_num_expr) == NOP_EXPR ! 573: || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR ! 574: || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR) ! 575: first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0); 1.1.1.6 root 576: 1.1.1.7 ! root 577: if (TREE_CODE (format_num_expr) != INTEGER_CST ! 578: || TREE_CODE (first_arg_num_expr) != INTEGER_CST) 1.1.1.6 root 579: { 1.1.1.7 ! root 580: error ("format string has non-constant operand number"); ! 581: continue; 1.1.1.6 root 582: } 1.1.1.7 ! root 583: ! 584: format_num = TREE_INT_CST_LOW (format_num_expr); ! 585: first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr); ! 586: if (first_arg_num != 0 && first_arg_num <= format_num) 1.1.1.4 root 587: { 1.1.1.7 ! root 588: error ("format string arg follows the args to be formatted"); 1.1.1.6 root 589: continue; 590: } 1.1.1.7 ! root 591: ! 592: /* If a parameter list is specified, verify that the format_num ! 593: argument is actually a string, in case the format attribute ! 594: is in error. */ ! 595: argument = TYPE_ARG_TYPES (type); ! 596: if (argument) 1.1.1.6 root 597: { 1.1.1.7 ! root 598: for (arg_num = 1; ; ++arg_num) 1.1.1.6 root 599: { 1.1.1.7 ! root 600: if (argument == 0 || arg_num == format_num) ! 601: break; ! 602: argument = TREE_CHAIN (argument); ! 603: } ! 604: if (! argument ! 605: || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE ! 606: || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument))) ! 607: != char_type_node)) ! 608: { ! 609: error ("format string arg not a string type"); 1.1.1.6 root 610: continue; 611: } 1.1.1.7 ! root 612: if (first_arg_num != 0) ! 613: { ! 614: /* Verify that first_arg_num points to the last arg, ! 615: the ... */ ! 616: while (argument) ! 617: arg_num++, argument = TREE_CHAIN (argument); ! 618: if (arg_num != first_arg_num) ! 619: { ! 620: error ("args to be formatted is not ..."); ! 621: continue; ! 622: } ! 623: } 1.1.1.4 root 624: } 1.1.1.7 ! root 625: ! 626: record_function_format (DECL_NAME (decl), ! 627: DECL_ASSEMBLER_NAME (decl), ! 628: is_scan, format_num, first_arg_num); ! 629: break; 1.1.1.4 root 630: } 1.1.1.5 root 631: 1.1.1.7 ! root 632: case A_WEAK: ! 633: declare_weak (decl); ! 634: break; 1.1.1.6 root 635: 1.1.1.7 ! root 636: case A_ALIAS: ! 637: if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl)) ! 638: || TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)) ! 639: error_with_decl (decl, ! 640: "`%s' defined both normally and as an alias"); ! 641: else if (decl_function_context (decl) == 0) ! 642: { ! 643: tree id = get_identifier (TREE_STRING_POINTER ! 644: (TREE_VALUE (args))); ! 645: if (TREE_CODE (decl) == FUNCTION_DECL) ! 646: DECL_INITIAL (decl) = error_mark_node; ! 647: else ! 648: DECL_EXTERNAL (decl) = 0; ! 649: assemble_alias (decl, id); ! 650: } ! 651: else ! 652: warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name)); ! 653: break; ! 654: } ! 655: } 1.1 root 656: } 657: 1.1.1.5 root 658: /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against 659: a parameter list. */ 660: 661: #define T_I &integer_type_node 662: #define T_L &long_integer_type_node 1.1.1.6 root 663: #define T_LL &long_long_integer_type_node 1.1.1.5 root 664: #define T_S &short_integer_type_node 665: #define T_UI &unsigned_type_node 666: #define T_UL &long_unsigned_type_node 1.1.1.6 root 667: #define T_ULL &long_long_unsigned_type_node 1.1.1.5 root 668: #define T_US &short_unsigned_type_node 669: #define T_F &float_type_node 670: #define T_D &double_type_node 671: #define T_LD &long_double_type_node 672: #define T_C &char_type_node 673: #define T_V &void_type_node 674: #define T_W &wchar_type_node 1.1.1.6 root 675: #define T_ST &sizetype 1.1.1.5 root 676: 677: typedef struct { 678: char *format_chars; 679: int pointer_count; 680: /* Type of argument if no length modifier is used. */ 681: tree *nolen; 682: /* Type of argument if length modifier for shortening is used. 683: If NULL, then this modifier is not allowed. */ 684: tree *hlen; 685: /* Type of argument if length modifier `l' is used. 686: If NULL, then this modifier is not allowed. */ 687: tree *llen; 1.1.1.6 root 688: /* Type of argument if length modifier `q' or `ll' is used. 689: If NULL, then this modifier is not allowed. */ 690: tree *qlen; 1.1.1.5 root 691: /* Type of argument if length modifier `L' is used. 692: If NULL, then this modifier is not allowed. */ 693: tree *bigllen; 694: /* List of other modifier characters allowed with these options. */ 695: char *flag_chars; 696: } format_char_info; 697: 698: static format_char_info print_char_table[] = { 1.1.1.6 root 699: { "di", 0, T_I, T_I, T_L, T_LL, T_LL, "-wp0 +" }, 700: { "oxX", 0, T_UI, T_UI, T_UL, T_ULL, T_ULL, "-wp0#" }, 701: { "u", 0, T_UI, T_UI, T_UL, T_ULL, T_ULL, "-wp0" }, 702: /* Two GNU extensions. */ 703: { "Z", 0, T_ST, NULL, NULL, NULL, NULL, "-wp0" }, 1.1.1.7 ! root 704: { "m", 0, T_V, NULL, NULL, NULL, NULL, "-wp" }, 1.1.1.6 root 705: { "feEgG", 0, T_D, NULL, NULL, NULL, T_LD, "-wp0 +#" }, 706: { "c", 0, T_I, NULL, T_W, NULL, NULL, "-w" }, 707: { "C", 0, T_W, NULL, NULL, NULL, NULL, "-w" }, 708: { "s", 1, T_C, NULL, T_W, NULL, NULL, "-wp" }, 709: { "S", 1, T_W, NULL, NULL, NULL, NULL, "-wp" }, 710: { "p", 1, T_V, NULL, NULL, NULL, NULL, "-w" }, 711: { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" }, 1.1.1.5 root 712: { NULL } 713: }; 714: 715: static format_char_info scan_char_table[] = { 1.1.1.6 root 716: { "di", 1, T_I, T_S, T_L, T_LL, T_LL, "*" }, 717: { "ouxX", 1, T_UI, T_US, T_UL, T_ULL, T_ULL, "*" }, 718: { "efgEG", 1, T_F, NULL, T_D, NULL, T_LD, "*" }, 719: { "sc", 1, T_C, NULL, T_W, NULL, NULL, "*a" }, 720: { "[", 1, T_C, NULL, NULL, NULL, NULL, "*a" }, 721: { "C", 1, T_W, NULL, NULL, NULL, NULL, "*" }, 722: { "S", 1, T_W, NULL, NULL, NULL, NULL, "*" }, 723: { "p", 2, T_V, NULL, NULL, NULL, NULL, "*" }, 724: { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" }, 1.1.1.5 root 725: { NULL } 726: }; 727: 728: typedef struct function_format_info { 729: struct function_format_info *next; /* next structure on the list */ 730: tree name; /* identifier such as "printf" */ 731: tree assembler_name; /* optional mangled identifier (for C++) */ 732: int is_scan; /* TRUE if *scanf */ 733: int format_num; /* number of format argument */ 734: int first_arg_num; /* number of first arg (zero for varargs) */ 735: } function_format_info; 736: 737: static function_format_info *function_format_list = NULL; 738: 739: static void check_format_info PROTO((function_format_info *, tree)); 740: 741: /* Initialize the table of functions to perform format checking on. 742: The ANSI functions are always checked (whether <stdio.h> is 743: included or not), since it is common to call printf without 744: including <stdio.h>. There shouldn't be a problem with this, 745: since ANSI reserves these function names whether you include the 746: header file or not. In any case, the checking is harmless. */ 747: 748: void 749: init_function_format_info () 750: { 751: record_function_format (get_identifier ("printf"), NULL_TREE, 0, 1, 2); 752: record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 2, 3); 753: record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 2, 3); 754: record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 1, 2); 755: record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 2, 3); 756: record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 2, 3); 757: record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 1, 0); 758: record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 2, 0); 759: record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 2, 0); 760: } 761: 762: /* Record information for argument format checking. FUNCTION_IDENT is 763: the identifier node for the name of the function to check (its decl 764: need not exist yet). IS_SCAN is true for scanf-type format checking; 765: false indicates printf-style format checking. FORMAT_NUM is the number 766: of the argument which is the format control string (starting from 1). 767: FIRST_ARG_NUM is the number of the first actual argument to check 768: against teh format string, or zero if no checking is not be done 769: (e.g. for varargs such as vfprintf). */ 770: 771: void 772: record_function_format (name, assembler_name, is_scan, 773: format_num, first_arg_num) 774: tree name; 775: tree assembler_name; 776: int is_scan; 777: int format_num; 778: int first_arg_num; 779: { 780: function_format_info *info; 781: 782: /* Re-use existing structure if it's there. */ 783: 784: for (info = function_format_list; info; info = info->next) 785: { 786: if (info->name == name && info->assembler_name == assembler_name) 787: break; 788: } 789: if (! info) 790: { 791: info = (function_format_info *) xmalloc (sizeof (function_format_info)); 792: info->next = function_format_list; 793: function_format_list = info; 794: 795: info->name = name; 796: info->assembler_name = assembler_name; 797: } 798: 799: info->is_scan = is_scan; 800: info->format_num = format_num; 801: info->first_arg_num = first_arg_num; 802: } 803: 804: static char tfaff[] = "too few arguments for format"; 805: 806: /* Check the argument list of a call to printf, scanf, etc. 807: NAME is the function identifier. 808: ASSEMBLER_NAME is the function's assembler identifier. 809: (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.) 810: PARAMS is the list of argument values. */ 811: 812: void 813: check_function_format (name, assembler_name, params) 814: tree name; 815: tree assembler_name; 816: tree params; 817: { 818: function_format_info *info; 819: 820: /* See if this function is a format function. */ 821: for (info = function_format_list; info; info = info->next) 822: { 823: if (info->assembler_name 824: ? (info->assembler_name == assembler_name) 825: : (info->name == name)) 826: { 827: /* Yup; check it. */ 828: check_format_info (info, params); 829: break; 830: } 831: } 832: } 833: 834: /* Check the argument list of a call to printf, scanf, etc. 835: INFO points to the function_format_info structure. 836: PARAMS is the list of argument values. */ 837: 838: static void 839: check_format_info (info, params) 840: function_format_info *info; 841: tree params; 842: { 843: int i; 844: int arg_num; 845: int suppressed, wide, precise; 846: int length_char; 847: int format_char; 848: int format_length; 849: tree format_tree; 850: tree cur_param; 851: tree cur_type; 852: tree wanted_type; 853: tree first_fillin_param; 854: char *format_chars; 855: format_char_info *fci; 856: static char message[132]; 857: char flag_chars[8]; 858: int has_operand_number = 0; 859: 860: /* Skip to format argument. If the argument isn't available, there's 861: no work for us to do; prototype checking will catch the problem. */ 862: for (arg_num = 1; ; ++arg_num) 863: { 864: if (params == 0) 865: return; 866: if (arg_num == info->format_num) 867: break; 868: params = TREE_CHAIN (params); 869: } 870: format_tree = TREE_VALUE (params); 871: params = TREE_CHAIN (params); 872: if (format_tree == 0) 873: return; 874: /* We can only check the format if it's a string constant. */ 875: while (TREE_CODE (format_tree) == NOP_EXPR) 876: format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */ 1.1.1.7 ! root 877: if (integer_zerop (format_tree)) 1.1.1.5 root 878: { 879: warning ("null format string"); 880: return; 881: } 882: if (TREE_CODE (format_tree) != ADDR_EXPR) 883: return; 884: format_tree = TREE_OPERAND (format_tree, 0); 885: if (TREE_CODE (format_tree) != STRING_CST) 886: return; 887: format_chars = TREE_STRING_POINTER (format_tree); 888: format_length = TREE_STRING_LENGTH (format_tree); 889: if (format_length <= 1) 890: warning ("zero-length format string"); 891: if (format_chars[--format_length] != 0) 892: { 893: warning ("unterminated format string"); 894: return; 895: } 896: /* Skip to first argument to check. */ 897: while (arg_num + 1 < info->first_arg_num) 898: { 899: if (params == 0) 900: return; 901: params = TREE_CHAIN (params); 902: ++arg_num; 903: } 904: 905: first_fillin_param = params; 906: while (1) 907: { 1.1.1.6 root 908: int aflag; 1.1.1.5 root 909: if (*format_chars == 0) 910: { 911: if (format_chars - TREE_STRING_POINTER (format_tree) != format_length) 912: warning ("embedded `\\0' in format"); 913: if (info->first_arg_num != 0 && params != 0 && ! has_operand_number) 914: warning ("too many arguments for format"); 915: return; 916: } 917: if (*format_chars++ != '%') 918: continue; 919: if (*format_chars == 0) 920: { 921: warning ("spurious trailing `%%' in format"); 922: continue; 923: } 924: if (*format_chars == '%') 925: { 926: ++format_chars; 927: continue; 928: } 929: flag_chars[0] = 0; 930: suppressed = wide = precise = FALSE; 931: if (info->is_scan) 932: { 933: suppressed = *format_chars == '*'; 934: if (suppressed) 935: ++format_chars; 936: while (isdigit (*format_chars)) 937: ++format_chars; 938: } 939: else 940: { 941: /* See if we have a number followed by a dollar sign. If we do, 942: it is an operand number, so set PARAMS to that operand. */ 943: if (*format_chars >= '0' && *format_chars <= '9') 944: { 945: char *p = format_chars; 946: 947: while (*p >= '0' && *p++ <= '9') 948: ; 949: 950: if (*p == '$') 951: { 952: int opnum = atoi (format_chars); 953: 954: params = first_fillin_param; 955: format_chars = p + 1; 956: has_operand_number = 1; 957: 958: for (i = 1; i < opnum && params != 0; i++) 959: params = TREE_CHAIN (params); 960: 961: if (opnum == 0 || params == 0) 962: { 963: warning ("operand number out of range in format"); 964: return; 965: } 966: } 967: } 968: 969: while (*format_chars != 0 && index (" +#0-", *format_chars) != 0) 970: { 971: if (index (flag_chars, *format_chars) != 0) 972: { 973: sprintf (message, "repeated `%c' flag in format", 974: *format_chars); 975: warning (message); 976: } 977: i = strlen (flag_chars); 978: flag_chars[i++] = *format_chars++; 979: flag_chars[i] = 0; 980: } 981: /* "If the space and + flags both appear, 982: the space flag will be ignored." */ 983: if (index (flag_chars, ' ') != 0 984: && index (flag_chars, '+') != 0) 985: warning ("use of both ` ' and `+' flags in format"); 986: /* "If the 0 and - flags both appear, 987: the 0 flag will be ignored." */ 988: if (index (flag_chars, '0') != 0 989: && index (flag_chars, '-') != 0) 990: warning ("use of both `0' and `-' flags in format"); 991: if (*format_chars == '*') 992: { 993: wide = TRUE; 994: /* "...a field width...may be indicated by an asterisk. 995: In this case, an int argument supplies the field width..." */ 996: ++format_chars; 997: if (params == 0) 998: { 999: warning (tfaff); 1000: return; 1001: } 1002: if (info->first_arg_num != 0) 1003: { 1004: cur_param = TREE_VALUE (params); 1005: params = TREE_CHAIN (params); 1006: ++arg_num; 1007: /* size_t is generally not valid here. 1008: It will work on most machines, because size_t and int 1009: have the same mode. But might as well warn anyway, 1010: since it will fail on other machines. */ 1011: if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) 1012: != integer_type_node) 1013: && 1014: (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) 1015: != unsigned_type_node)) 1016: { 1017: sprintf (message, 1018: "field width is not type int (arg %d)", 1019: arg_num); 1020: warning (message); 1021: } 1022: } 1023: } 1024: else 1025: { 1026: while (isdigit (*format_chars)) 1027: { 1028: wide = TRUE; 1029: ++format_chars; 1030: } 1031: } 1032: if (*format_chars == '.') 1033: { 1034: precise = TRUE; 1035: ++format_chars; 1036: if (*format_chars != '*' && !isdigit (*format_chars)) 1037: warning ("`.' not followed by `*' or digit in format"); 1038: /* "...a...precision...may be indicated by an asterisk. 1039: In this case, an int argument supplies the...precision." */ 1040: if (*format_chars == '*') 1041: { 1042: if (info->first_arg_num != 0) 1043: { 1044: ++format_chars; 1045: if (params == 0) 1046: { 1047: warning (tfaff); 1048: return; 1049: } 1050: cur_param = TREE_VALUE (params); 1051: params = TREE_CHAIN (params); 1052: ++arg_num; 1053: if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) 1054: != integer_type_node) 1055: { 1056: sprintf (message, 1057: "field width is not type int (arg %d)", 1058: arg_num); 1059: warning (message); 1060: } 1061: } 1062: } 1063: else 1064: { 1065: while (isdigit (*format_chars)) 1066: ++format_chars; 1067: } 1068: } 1069: } 1.1.1.6 root 1070: if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'q' || 1071: *format_chars == 'L') 1.1.1.5 root 1072: length_char = *format_chars++; 1073: else 1074: length_char = 0; 1.1.1.6 root 1075: if (length_char == 'l' && *format_chars == 'l') 1076: length_char = 'q', format_chars++; 1077: aflag = 0; 1078: if (*format_chars == 'a') 1079: { 1080: aflag = 1; 1081: format_chars++; 1082: } 1.1.1.5 root 1083: if (suppressed && length_char != 0) 1084: { 1085: sprintf (message, 1086: "use of `*' and `%c' together in format", 1087: length_char); 1088: warning (message); 1089: } 1090: format_char = *format_chars; 1091: if (format_char == 0) 1092: { 1093: warning ("conversion lacks type at end of format"); 1094: continue; 1095: } 1096: format_chars++; 1097: fci = info->is_scan ? scan_char_table : print_char_table; 1098: while (fci->format_chars != 0 1099: && index (fci->format_chars, format_char) == 0) 1100: ++fci; 1101: if (fci->format_chars == 0) 1102: { 1103: if (format_char >= 040 && format_char < 0177) 1104: sprintf (message, 1105: "unknown conversion type character `%c' in format", 1106: format_char); 1107: else 1108: sprintf (message, 1109: "unknown conversion type character 0x%x in format", 1110: format_char); 1111: warning (message); 1112: continue; 1113: } 1114: if (wide && index (fci->flag_chars, 'w') == 0) 1115: { 1116: sprintf (message, "width used with `%c' format", 1117: format_char); 1118: warning (message); 1119: } 1120: if (precise && index (fci->flag_chars, 'p') == 0) 1121: { 1122: sprintf (message, "precision used with `%c' format", 1123: format_char); 1124: warning (message); 1125: } 1.1.1.6 root 1126: if (aflag && index (fci->flag_chars, 'a') == 0) 1127: { 1128: sprintf (message, "`a' flag used with `%c' format", 1129: format_char); 1130: warning (message); 1131: } 1.1.1.5 root 1132: if (info->is_scan && format_char == '[') 1133: { 1134: /* Skip over scan set, in case it happens to have '%' in it. */ 1135: if (*format_chars == '^') 1136: ++format_chars; 1137: /* Find closing bracket; if one is hit immediately, then 1138: it's part of the scan set rather than a terminator. */ 1139: if (*format_chars == ']') 1140: ++format_chars; 1141: while (*format_chars && *format_chars != ']') 1142: ++format_chars; 1143: if (*format_chars != ']') 1144: /* The end of the format string was reached. */ 1145: warning ("no closing `]' for `%%[' format"); 1146: } 1147: if (suppressed) 1148: { 1149: if (index (fci->flag_chars, '*') == 0) 1150: { 1151: sprintf (message, 1152: "suppression of `%c' conversion in format", 1153: format_char); 1154: warning (message); 1155: } 1156: continue; 1157: } 1158: for (i = 0; flag_chars[i] != 0; ++i) 1159: { 1160: if (index (fci->flag_chars, flag_chars[i]) == 0) 1161: { 1162: sprintf (message, "flag `%c' used with type `%c'", 1163: flag_chars[i], format_char); 1164: warning (message); 1165: } 1166: } 1167: if (precise && index (flag_chars, '0') != 0 1168: && (format_char == 'd' || format_char == 'i' 1169: || format_char == 'o' || format_char == 'u' 1170: || format_char == 'x' || format_char == 'x')) 1171: { 1172: sprintf (message, 1173: "precision and `0' flag not both allowed with `%c' format", 1174: format_char); 1175: warning (message); 1176: } 1177: switch (length_char) 1178: { 1179: default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break; 1180: case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break; 1181: case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break; 1.1.1.6 root 1182: case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break; 1.1.1.5 root 1183: case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break; 1184: } 1185: if (wanted_type == 0) 1186: { 1187: sprintf (message, 1188: "use of `%c' length character with `%c' type character", 1189: length_char, format_char); 1190: warning (message); 1191: } 1192: 1193: /* 1194: ** XXX -- should kvetch about stuff such as 1195: ** { 1196: ** const int i; 1197: ** 1198: ** scanf ("%d", &i); 1199: ** } 1200: */ 1201: 1202: /* Finally. . .check type of argument against desired type! */ 1203: if (info->first_arg_num == 0) 1204: continue; 1.1.1.7 ! root 1205: if (fci->pointer_count == 0 && wanted_type == void_type_node) ! 1206: /* This specifier takes no argument. */ ! 1207: continue; 1.1.1.5 root 1208: if (params == 0) 1209: { 1210: warning (tfaff); 1211: return; 1212: } 1213: cur_param = TREE_VALUE (params); 1214: params = TREE_CHAIN (params); 1215: ++arg_num; 1216: cur_type = TREE_TYPE (cur_param); 1217: 1218: /* Check the types of any additional pointer arguments 1219: that precede the "real" argument. */ 1220: for (i = 0; i < fci->pointer_count; ++i) 1221: { 1222: if (TREE_CODE (cur_type) == POINTER_TYPE) 1223: { 1224: cur_type = TREE_TYPE (cur_type); 1225: continue; 1226: } 1.1.1.7 ! root 1227: if (TREE_CODE (cur_type) != ERROR_MARK) ! 1228: { ! 1229: sprintf (message, ! 1230: "format argument is not a %s (arg %d)", ! 1231: ((fci->pointer_count == 1) ? "pointer" : "pointer to a pointer"), ! 1232: arg_num); ! 1233: warning (message); ! 1234: } 1.1.1.5 root 1235: break; 1236: } 1237: 1238: /* Check the type of the "real" argument, if there's a type we want. */ 1239: if (i == fci->pointer_count && wanted_type != 0 1.1.1.7 ! root 1240: && TREE_CODE (cur_type) != ERROR_MARK 1.1.1.5 root 1241: && wanted_type != TYPE_MAIN_VARIANT (cur_type) 1242: /* If we want `void *', allow any pointer type. 1243: (Anything else would already have got a warning.) */ 1244: && ! (wanted_type == void_type_node 1245: && fci->pointer_count > 0) 1246: /* Don't warn about differences merely in signedness. */ 1247: && !(TREE_CODE (wanted_type) == INTEGER_TYPE 1248: && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE 1249: && (TREE_UNSIGNED (wanted_type) 1250: ? wanted_type == (cur_type = unsigned_type (cur_type)) 1251: : wanted_type == (cur_type = signed_type (cur_type)))) 1252: /* Likewise, "signed char", "unsigned char" and "char" are 1253: equivalent but the above test won't consider them equivalent. */ 1254: && ! (wanted_type == char_type_node 1255: && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node 1256: || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node))) 1257: { 1258: register char *this; 1259: register char *that; 1260: 1261: this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type))); 1262: that = 0; 1263: if (TREE_CODE (cur_type) != ERROR_MARK 1264: && TYPE_NAME (cur_type) != 0 1265: && TREE_CODE (cur_type) != INTEGER_TYPE 1266: && !(TREE_CODE (cur_type) == POINTER_TYPE 1267: && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE)) 1268: { 1269: if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL 1270: && DECL_NAME (TYPE_NAME (cur_type)) != 0) 1271: that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type))); 1272: else 1273: that = IDENTIFIER_POINTER (TYPE_NAME (cur_type)); 1274: } 1275: 1276: /* A nameless type can't possibly match what the format wants. 1277: So there will be a warning for it. 1278: Make up a string to describe vaguely what it is. */ 1279: if (that == 0) 1280: { 1281: if (TREE_CODE (cur_type) == POINTER_TYPE) 1282: that = "pointer"; 1283: else 1284: that = "different type"; 1285: } 1286: 1287: /* Make the warning better in case of mismatch of int vs long. */ 1288: if (TREE_CODE (cur_type) == INTEGER_TYPE 1289: && TREE_CODE (wanted_type) == INTEGER_TYPE 1290: && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type) 1291: && TYPE_NAME (cur_type) != 0 1292: && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL) 1293: that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type))); 1294: 1295: if (strcmp (this, that) != 0) 1296: { 1297: sprintf (message, "%s format, %s arg (arg %d)", 1298: this, that, arg_num); 1299: warning (message); 1300: } 1301: } 1302: } 1303: } 1304: 1.1.1.4 root 1305: /* Print a warning if a constant expression had overflow in folding. 1306: Invoke this function on every expression that the language 1307: requires to be a constant expression. 1308: Note the ANSI C standard says it is erroneous for a 1309: constant expression to overflow. */ 1.1.1.3 root 1310: 1311: void 1312: constant_expression_warning (value) 1313: tree value; 1314: { 1.1.1.6 root 1315: if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST 1316: || TREE_CODE (value) == COMPLEX_CST) 1317: && TREE_CONSTANT_OVERFLOW (value) && pedantic) 1318: pedwarn ("overflow in constant expression"); 1.1.1.4 root 1319: } 1320: 1321: /* Print a warning if an expression had overflow in folding. 1322: Invoke this function on every expression that 1323: (1) appears in the source code, and 1324: (2) might be a constant expression that overflowed, and 1325: (3) is not already checked by convert_and_check; 1326: however, do not invoke this function on operands of explicit casts. */ 1327: 1328: void 1329: overflow_warning (value) 1330: tree value; 1331: { 1.1.1.6 root 1332: if ((TREE_CODE (value) == INTEGER_CST 1333: || (TREE_CODE (value) == COMPLEX_CST 1334: && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)) 1335: && TREE_OVERFLOW (value)) 1.1.1.4 root 1336: { 1.1.1.5 root 1337: TREE_OVERFLOW (value) = 0; 1.1.1.4 root 1338: warning ("integer overflow in expression"); 1339: } 1.1.1.6 root 1340: else if ((TREE_CODE (value) == REAL_CST 1341: || (TREE_CODE (value) == COMPLEX_CST 1342: && TREE_CODE (TREE_REALPART (value)) == REAL_CST)) 1343: && TREE_OVERFLOW (value)) 1344: { 1345: TREE_OVERFLOW (value) = 0; 1346: warning ("floating-pointer overflow in expression"); 1347: } 1.1.1.4 root 1348: } 1349: 1350: /* Print a warning if a large constant is truncated to unsigned, 1351: or if -Wconversion is used and a constant < 0 is converted to unsigned. 1352: Invoke this function on every expression that might be implicitly 1353: converted to an unsigned type. */ 1354: 1355: void 1356: unsigned_conversion_warning (result, operand) 1357: tree result, operand; 1358: { 1359: if (TREE_CODE (operand) == INTEGER_CST 1360: && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE 1361: && TREE_UNSIGNED (TREE_TYPE (result)) 1362: && !int_fits_type_p (operand, TREE_TYPE (result))) 1363: { 1364: if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result)))) 1365: /* This detects cases like converting -129 or 256 to unsigned char. */ 1.1.1.5 root 1366: warning ("large integer implicitly truncated to unsigned type"); 1.1.1.4 root 1367: else if (warn_conversion) 1.1.1.5 root 1368: warning ("negative integer implicitly converted to unsigned type"); 1.1.1.4 root 1369: } 1370: } 1371: 1372: /* Convert EXPR to TYPE, warning about conversion problems with constants. 1373: Invoke this function on every expression that is converted implicitly, 1374: i.e. because of language rules and not because of an explicit cast. */ 1375: 1376: tree 1377: convert_and_check (type, expr) 1378: tree type, expr; 1379: { 1380: tree t = convert (type, expr); 1381: if (TREE_CODE (t) == INTEGER_CST) 1382: { 1.1.1.5 root 1383: if (TREE_OVERFLOW (t)) 1384: { 1385: TREE_OVERFLOW (t) = 0; 1386: 1.1.1.7 ! root 1387: /* Do not diagnose overflow in a constant expression merely ! 1388: because a conversion overflowed. */ ! 1389: TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr); ! 1390: 1.1.1.5 root 1391: /* No warning for converting 0x80000000 to int. */ 1392: if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr)) 1393: && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE 1394: && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr)))) 1395: /* If EXPR fits in the unsigned version of TYPE, 1396: don't warn unless pedantic. */ 1397: if (pedantic 1398: || TREE_UNSIGNED (type) 1399: || ! int_fits_type_p (expr, unsigned_type (type))) 1400: warning ("overflow in implicit constant conversion"); 1.1.1.4 root 1401: } 1402: else 1403: unsigned_conversion_warning (t, expr); 1404: } 1405: return t; 1.1.1.3 root 1406: } 1407: 1.1 root 1408: void 1409: c_expand_expr_stmt (expr) 1410: tree expr; 1411: { 1412: /* Do default conversion if safe and possibly important, 1413: in case within ({...}). */ 1414: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr)) 1415: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE) 1416: expr = default_conversion (expr); 1417: 1418: if (TREE_TYPE (expr) != error_mark_node 1419: && TYPE_SIZE (TREE_TYPE (expr)) == 0 1420: && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 1421: error ("expression statement has incomplete type"); 1422: 1423: expand_expr_stmt (expr); 1424: } 1425: 1426: /* Validate the expression after `case' and apply default promotions. */ 1427: 1428: tree 1429: check_case_value (value) 1430: tree value; 1431: { 1432: if (value == NULL_TREE) 1433: return value; 1434: 1435: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 1.1.1.3 root 1436: STRIP_TYPE_NOPS (value); 1.1 root 1437: 1438: if (TREE_CODE (value) != INTEGER_CST 1439: && value != error_mark_node) 1440: { 1441: error ("case label does not reduce to an integer constant"); 1442: value = error_mark_node; 1443: } 1444: else 1445: /* Promote char or short to int. */ 1446: value = default_conversion (value); 1447: 1.1.1.3 root 1448: constant_expression_warning (value); 1449: 1.1 root 1450: return value; 1451: } 1452: 1453: /* Return an integer type with BITS bits of precision, 1454: that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 1455: 1456: tree 1457: type_for_size (bits, unsignedp) 1458: unsigned bits; 1459: int unsignedp; 1460: { 1.1.1.7 ! root 1461: if (bits == TYPE_PRECISION (integer_type_node)) ! 1462: return unsignedp ? unsigned_type_node : integer_type_node; ! 1463: 1.1.1.3 root 1464: if (bits == TYPE_PRECISION (signed_char_type_node)) 1.1 root 1465: return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1466: 1.1.1.3 root 1467: if (bits == TYPE_PRECISION (short_integer_type_node)) 1.1 root 1468: return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1469: 1.1.1.3 root 1470: if (bits == TYPE_PRECISION (long_integer_type_node)) 1.1 root 1471: return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1472: 1.1.1.3 root 1473: if (bits == TYPE_PRECISION (long_long_integer_type_node)) 1.1 root 1474: return (unsignedp ? long_long_unsigned_type_node 1475: : long_long_integer_type_node); 1476: 1.1.1.3 root 1477: if (bits <= TYPE_PRECISION (intQI_type_node)) 1478: return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1479: 1480: if (bits <= TYPE_PRECISION (intHI_type_node)) 1481: return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1482: 1483: if (bits <= TYPE_PRECISION (intSI_type_node)) 1484: return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1485: 1486: if (bits <= TYPE_PRECISION (intDI_type_node)) 1487: return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1488: 1.1 root 1489: return 0; 1490: } 1491: 1492: /* Return a data type that has machine mode MODE. 1493: If the mode is an integer, 1494: then UNSIGNEDP selects between signed and unsigned types. */ 1495: 1496: tree 1497: type_for_mode (mode, unsignedp) 1498: enum machine_mode mode; 1499: int unsignedp; 1500: { 1.1.1.7 ! root 1501: if (mode == TYPE_MODE (integer_type_node)) ! 1502: return unsignedp ? unsigned_type_node : integer_type_node; ! 1503: 1.1 root 1504: if (mode == TYPE_MODE (signed_char_type_node)) 1505: return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1506: 1507: if (mode == TYPE_MODE (short_integer_type_node)) 1508: return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1509: 1510: if (mode == TYPE_MODE (long_integer_type_node)) 1511: return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1512: 1513: if (mode == TYPE_MODE (long_long_integer_type_node)) 1514: return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 1515: 1.1.1.3 root 1516: if (mode == TYPE_MODE (intQI_type_node)) 1517: return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1518: 1519: if (mode == TYPE_MODE (intHI_type_node)) 1520: return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1521: 1522: if (mode == TYPE_MODE (intSI_type_node)) 1523: return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1524: 1525: if (mode == TYPE_MODE (intDI_type_node)) 1526: return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1527: 1.1 root 1528: if (mode == TYPE_MODE (float_type_node)) 1529: return float_type_node; 1530: 1531: if (mode == TYPE_MODE (double_type_node)) 1532: return double_type_node; 1533: 1534: if (mode == TYPE_MODE (long_double_type_node)) 1535: return long_double_type_node; 1536: 1537: if (mode == TYPE_MODE (build_pointer_type (char_type_node))) 1538: return build_pointer_type (char_type_node); 1539: 1540: if (mode == TYPE_MODE (build_pointer_type (integer_type_node))) 1541: return build_pointer_type (integer_type_node); 1542: 1543: return 0; 1544: } 1545: 1.1.1.6 root 1546: /* Return the minimum number of bits needed to represent VALUE in a 1547: signed or unsigned type, UNSIGNEDP says which. */ 1548: 1549: int 1550: min_precision (value, unsignedp) 1551: tree value; 1552: int unsignedp; 1553: { 1554: int log; 1555: 1556: /* If the value is negative, compute its negative minus 1. The latter 1557: adjustment is because the absolute value of the largest negative value 1558: is one larger than the largest positive value. This is equivalent to 1559: a bit-wise negation, so use that operation instead. */ 1560: 1561: if (tree_int_cst_sgn (value) < 0) 1562: value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value)); 1563: 1564: /* Return the number of bits needed, taking into account the fact 1565: that we need one more bit for a signed than unsigned type. */ 1566: 1567: if (integer_zerop (value)) 1568: log = 0; 1569: else if (TREE_INT_CST_HIGH (value) != 0) 1570: log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value)); 1571: else 1572: log = floor_log2 (TREE_INT_CST_LOW (value)); 1573: 1574: return log + 1 + ! unsignedp; 1575: } 1576: 1.1 root 1577: /* Print an error message for invalid operands to arith operation CODE. 1578: NOP_EXPR is used as a special case (see truthvalue_conversion). */ 1579: 1580: void 1581: binary_op_error (code) 1582: enum tree_code code; 1583: { 1.1.1.6 root 1584: register char *opname = "unknown"; 1585: 1.1 root 1586: switch (code) 1587: { 1588: case NOP_EXPR: 1589: error ("invalid truth-value expression"); 1590: return; 1591: 1592: case PLUS_EXPR: 1593: opname = "+"; break; 1594: case MINUS_EXPR: 1595: opname = "-"; break; 1596: case MULT_EXPR: 1597: opname = "*"; break; 1598: case MAX_EXPR: 1599: opname = "max"; break; 1600: case MIN_EXPR: 1601: opname = "min"; break; 1602: case EQ_EXPR: 1603: opname = "=="; break; 1604: case NE_EXPR: 1605: opname = "!="; break; 1606: case LE_EXPR: 1607: opname = "<="; break; 1608: case GE_EXPR: 1609: opname = ">="; break; 1610: case LT_EXPR: 1611: opname = "<"; break; 1612: case GT_EXPR: 1613: opname = ">"; break; 1614: case LSHIFT_EXPR: 1615: opname = "<<"; break; 1616: case RSHIFT_EXPR: 1617: opname = ">>"; break; 1618: case TRUNC_MOD_EXPR: 1.1.1.2 root 1619: case FLOOR_MOD_EXPR: 1.1 root 1620: opname = "%"; break; 1621: case TRUNC_DIV_EXPR: 1.1.1.2 root 1622: case FLOOR_DIV_EXPR: 1.1 root 1623: opname = "/"; break; 1624: case BIT_AND_EXPR: 1625: opname = "&"; break; 1626: case BIT_IOR_EXPR: 1627: opname = "|"; break; 1628: case TRUTH_ANDIF_EXPR: 1629: opname = "&&"; break; 1630: case TRUTH_ORIF_EXPR: 1631: opname = "||"; break; 1632: case BIT_XOR_EXPR: 1633: opname = "^"; break; 1.1.1.2 root 1634: case LROTATE_EXPR: 1635: case RROTATE_EXPR: 1636: opname = "rotate"; break; 1.1 root 1637: } 1638: error ("invalid operands to binary %s", opname); 1639: } 1640: 1641: /* Subroutine of build_binary_op, used for comparison operations. 1642: See if the operands have both been converted from subword integer types 1643: and, if so, perhaps change them both back to their original type. 1.1.1.5 root 1644: This function is also responsible for converting the two operands 1645: to the proper common type for comparison. 1.1 root 1646: 1647: The arguments of this function are all pointers to local variables 1648: of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, 1649: RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. 1650: 1651: If this function returns nonzero, it means that the comparison has 1652: a constant value. What this function returns is an expression for 1653: that value. */ 1654: 1655: tree 1656: shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr) 1657: tree *op0_ptr, *op1_ptr; 1658: tree *restype_ptr; 1659: enum tree_code *rescode_ptr; 1660: { 1661: register tree type; 1662: tree op0 = *op0_ptr; 1663: tree op1 = *op1_ptr; 1664: int unsignedp0, unsignedp1; 1665: int real1, real2; 1666: tree primop0, primop1; 1667: enum tree_code code = *rescode_ptr; 1668: 1669: /* Throw away any conversions to wider types 1670: already present in the operands. */ 1671: 1672: primop0 = get_narrower (op0, &unsignedp0); 1673: primop1 = get_narrower (op1, &unsignedp1); 1674: 1675: /* Handle the case that OP0 does not *contain* a conversion 1676: but it *requires* conversion to FINAL_TYPE. */ 1677: 1678: if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) 1679: unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0)); 1680: if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) 1681: unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1)); 1682: 1683: /* If one of the operands must be floated, we cannot optimize. */ 1684: real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; 1685: real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; 1686: 1687: /* If first arg is constant, swap the args (changing operation 1.1.1.6 root 1688: so value is preserved), for canonicalization. Don't do this if 1689: the second arg is 0. */ 1.1 root 1690: 1.1.1.6 root 1691: if (TREE_CONSTANT (primop0) 1692: && ! integer_zerop (primop1) && ! real_zerop (primop1)) 1.1 root 1693: { 1694: register tree tem = primop0; 1695: register int temi = unsignedp0; 1696: primop0 = primop1; 1697: primop1 = tem; 1698: tem = op0; 1699: op0 = op1; 1700: op1 = tem; 1701: *op0_ptr = op0; 1702: *op1_ptr = op1; 1703: unsignedp0 = unsignedp1; 1704: unsignedp1 = temi; 1705: temi = real1; 1706: real1 = real2; 1707: real2 = temi; 1708: 1709: switch (code) 1710: { 1711: case LT_EXPR: 1712: code = GT_EXPR; 1713: break; 1714: case GT_EXPR: 1715: code = LT_EXPR; 1716: break; 1717: case LE_EXPR: 1718: code = GE_EXPR; 1719: break; 1720: case GE_EXPR: 1721: code = LE_EXPR; 1722: break; 1723: } 1724: *rescode_ptr = code; 1725: } 1726: 1727: /* If comparing an integer against a constant more bits wide, 1728: maybe we can deduce a value of 1 or 0 independent of the data. 1729: Or else truncate the constant now 1730: rather than extend the variable at run time. 1731: 1732: This is only interesting if the constant is the wider arg. 1733: Also, it is not safe if the constant is unsigned and the 1734: variable arg is signed, since in this case the variable 1735: would be sign-extended and then regarded as unsigned. 1736: Our technique fails in this case because the lowest/highest 1737: possible unsigned results don't follow naturally from the 1738: lowest/highest possible values of the variable operand. 1739: For just EQ_EXPR and NE_EXPR there is another technique that 1740: could be used: see if the constant can be faithfully represented 1741: in the other operand's type, by truncating it and reextending it 1742: and see if that preserves the constant's value. */ 1743: 1744: if (!real1 && !real2 1745: && TREE_CODE (primop1) == INTEGER_CST 1746: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) 1747: { 1748: int min_gt, max_gt, min_lt, max_lt; 1749: tree maxval, minval; 1750: /* 1 if comparison is nominally unsigned. */ 1751: int unsignedp = TREE_UNSIGNED (*restype_ptr); 1752: tree val; 1753: 1754: type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)); 1755: 1756: maxval = TYPE_MAX_VALUE (type); 1757: minval = TYPE_MIN_VALUE (type); 1758: 1759: if (unsignedp && !unsignedp0) 1760: *restype_ptr = signed_type (*restype_ptr); 1761: 1762: if (TREE_TYPE (primop1) != *restype_ptr) 1763: primop1 = convert (*restype_ptr, primop1); 1764: if (type != *restype_ptr) 1765: { 1766: minval = convert (*restype_ptr, minval); 1767: maxval = convert (*restype_ptr, maxval); 1768: } 1769: 1770: if (unsignedp && unsignedp0) 1771: { 1772: min_gt = INT_CST_LT_UNSIGNED (primop1, minval); 1773: max_gt = INT_CST_LT_UNSIGNED (primop1, maxval); 1774: min_lt = INT_CST_LT_UNSIGNED (minval, primop1); 1775: max_lt = INT_CST_LT_UNSIGNED (maxval, primop1); 1776: } 1777: else 1778: { 1779: min_gt = INT_CST_LT (primop1, minval); 1780: max_gt = INT_CST_LT (primop1, maxval); 1781: min_lt = INT_CST_LT (minval, primop1); 1782: max_lt = INT_CST_LT (maxval, primop1); 1783: } 1784: 1785: val = 0; 1786: /* This used to be a switch, but Genix compiler can't handle that. */ 1787: if (code == NE_EXPR) 1788: { 1789: if (max_lt || min_gt) 1.1.1.7 ! root 1790: val = boolean_true_node; 1.1 root 1791: } 1792: else if (code == EQ_EXPR) 1793: { 1794: if (max_lt || min_gt) 1.1.1.7 ! root 1795: val = boolean_false_node; 1.1 root 1796: } 1797: else if (code == LT_EXPR) 1798: { 1799: if (max_lt) 1.1.1.7 ! root 1800: val = boolean_true_node; 1.1 root 1801: if (!min_lt) 1.1.1.7 ! root 1802: val = boolean_false_node; 1.1 root 1803: } 1804: else if (code == GT_EXPR) 1805: { 1806: if (min_gt) 1.1.1.7 ! root 1807: val = boolean_true_node; 1.1 root 1808: if (!max_gt) 1.1.1.7 ! root 1809: val = boolean_false_node; 1.1 root 1810: } 1811: else if (code == LE_EXPR) 1812: { 1813: if (!max_gt) 1.1.1.7 ! root 1814: val = boolean_true_node; 1.1 root 1815: if (min_gt) 1.1.1.7 ! root 1816: val = boolean_false_node; 1.1 root 1817: } 1818: else if (code == GE_EXPR) 1819: { 1820: if (!min_lt) 1.1.1.7 ! root 1821: val = boolean_true_node; 1.1 root 1822: if (max_lt) 1.1.1.7 ! root 1823: val = boolean_false_node; 1.1 root 1824: } 1825: 1826: /* If primop0 was sign-extended and unsigned comparison specd, 1827: we did a signed comparison above using the signed type bounds. 1828: But the comparison we output must be unsigned. 1829: 1830: Also, for inequalities, VAL is no good; but if the signed 1831: comparison had *any* fixed result, it follows that the 1832: unsigned comparison just tests the sign in reverse 1833: (positive values are LE, negative ones GE). 1834: So we can generate an unsigned comparison 1835: against an extreme value of the signed type. */ 1836: 1837: if (unsignedp && !unsignedp0) 1838: { 1839: if (val != 0) 1840: switch (code) 1841: { 1842: case LT_EXPR: 1843: case GE_EXPR: 1844: primop1 = TYPE_MIN_VALUE (type); 1845: val = 0; 1846: break; 1847: 1848: case LE_EXPR: 1849: case GT_EXPR: 1850: primop1 = TYPE_MAX_VALUE (type); 1851: val = 0; 1852: break; 1853: } 1854: type = unsigned_type (type); 1855: } 1856: 1.1.1.5 root 1857: if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST) 1.1 root 1858: { 1859: /* This is the case of (char)x >?< 0x80, which people used to use 1860: expecting old C compilers to change the 0x80 into -0x80. */ 1.1.1.7 ! root 1861: if (val == boolean_false_node) 1.1 root 1862: warning ("comparison is always 0 due to limited range of data type"); 1.1.1.7 ! root 1863: if (val == boolean_true_node) 1.1 root 1864: warning ("comparison is always 1 due to limited range of data type"); 1865: } 1866: 1.1.1.5 root 1867: if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST) 1.1 root 1868: { 1.1.1.2 root 1869: /* This is the case of (unsigned char)x >?< -1 or < 0. */ 1.1.1.7 ! root 1870: if (val == boolean_false_node) 1.1 root 1871: warning ("comparison is always 0 due to limited range of data type"); 1.1.1.7 ! root 1872: if (val == boolean_true_node) 1.1 root 1873: warning ("comparison is always 1 due to limited range of data type"); 1874: } 1875: 1876: if (val != 0) 1877: { 1878: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 1879: if (TREE_SIDE_EFFECTS (primop0)) 1880: return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); 1881: return val; 1882: } 1883: 1884: /* Value is not predetermined, but do the comparison 1885: in the type of the operand that is not constant. 1886: TYPE is already properly set. */ 1887: } 1888: else if (real1 && real2 1.1.1.4 root 1889: && (TYPE_PRECISION (TREE_TYPE (primop0)) 1890: == TYPE_PRECISION (TREE_TYPE (primop1)))) 1.1 root 1891: type = TREE_TYPE (primop0); 1892: 1893: /* If args' natural types are both narrower than nominal type 1894: and both extend in the same manner, compare them 1895: in the type of the wider arg. 1896: Otherwise must actually extend both to the nominal 1897: common type lest different ways of extending 1898: alter the result. 1899: (eg, (short)-1 == (unsigned short)-1 should be 0.) */ 1900: 1901: else if (unsignedp0 == unsignedp1 && real1 == real2 1902: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) 1903: && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) 1904: { 1905: type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 1906: type = signed_or_unsigned_type (unsignedp0 1907: || TREE_UNSIGNED (*restype_ptr), 1908: type); 1909: /* Make sure shorter operand is extended the right way 1910: to match the longer operand. */ 1911: primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)), 1912: primop0); 1913: primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)), 1914: primop1); 1915: } 1916: else 1917: { 1918: /* Here we must do the comparison on the nominal type 1919: using the args exactly as we received them. */ 1920: type = *restype_ptr; 1921: primop0 = op0; 1922: primop1 = op1; 1923: 1924: if (!real1 && !real2 && integer_zerop (primop1) 1.1.1.6 root 1925: && TREE_UNSIGNED (*restype_ptr)) 1.1 root 1926: { 1927: tree value = 0; 1928: switch (code) 1929: { 1930: case GE_EXPR: 1.1.1.6 root 1931: /* All unsigned values are >= 0, so we warn if extra warnings 1932: are requested. However, if OP0 is a constant that is 1933: >= 0, the signedness of the comparison isn't an issue, 1934: so suppress the warning. */ 1935: if (extra_warnings 1936: && ! (TREE_CODE (primop0) == INTEGER_CST 1937: && ! TREE_OVERFLOW (convert (signed_type (type), 1938: primop0)))) 1.1 root 1939: warning ("unsigned value >= 0 is always 1"); 1.1.1.7 ! root 1940: value = boolean_true_node; 1.1 root 1941: break; 1942: 1943: case LT_EXPR: 1.1.1.6 root 1944: if (extra_warnings 1945: && ! (TREE_CODE (primop0) == INTEGER_CST 1946: && ! TREE_OVERFLOW (convert (signed_type (type), 1947: primop0)))) 1.1 root 1948: warning ("unsigned value < 0 is always 0"); 1.1.1.7 ! root 1949: value = boolean_false_node; 1.1 root 1950: } 1951: 1952: if (value != 0) 1953: { 1954: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 1955: if (TREE_SIDE_EFFECTS (primop0)) 1956: return build (COMPOUND_EXPR, TREE_TYPE (value), 1957: primop0, value); 1958: return value; 1959: } 1960: } 1961: } 1962: 1963: *op0_ptr = convert (type, primop0); 1964: *op1_ptr = convert (type, primop1); 1965: 1.1.1.7 ! root 1966: *restype_ptr = boolean_type_node; 1.1 root 1967: 1968: return 0; 1969: } 1970: 1971: /* Prepare expr to be an argument of a TRUTH_NOT_EXPR, 1972: or validate its data type for an `if' or `while' statement or ?..: exp. 1973: 1974: This preparation consists of taking the ordinary 1975: representation of an expression expr and producing a valid tree 1976: boolean expression describing whether expr is nonzero. We could 1.1.1.7 ! root 1977: simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1), 1.1 root 1978: but we optimize comparisons, &&, ||, and !. 1979: 1.1.1.7 ! root 1980: The resulting type should always be `boolean_type_node'. */ 1.1 root 1981: 1982: tree 1983: truthvalue_conversion (expr) 1984: tree expr; 1985: { 1.1.1.4 root 1986: if (TREE_CODE (expr) == ERROR_MARK) 1987: return expr; 1988: 1989: #if 0 /* This appears to be wrong for C++. */ 1990: /* These really should return error_mark_node after 2.4 is stable. 1991: But not all callers handle ERROR_MARK properly. */ 1992: switch (TREE_CODE (TREE_TYPE (expr))) 1993: { 1994: case RECORD_TYPE: 1995: error ("struct type value used where scalar is required"); 1.1.1.7 ! root 1996: return boolean_false_node; 1.1.1.4 root 1997: 1998: case UNION_TYPE: 1999: error ("union type value used where scalar is required"); 1.1.1.7 ! root 2000: return boolean_false_node; 1.1.1.4 root 2001: 2002: case ARRAY_TYPE: 2003: error ("array type value used where scalar is required"); 1.1.1.7 ! root 2004: return boolean_false_node; 1.1.1.4 root 2005: 2006: default: 2007: break; 2008: } 2009: #endif /* 0 */ 2010: 1.1 root 2011: switch (TREE_CODE (expr)) 2012: { 2013: /* It is simpler and generates better code to have only TRUTH_*_EXPR 2014: or comparison expressions as truth values at this level. */ 2015: #if 0 2016: case COMPONENT_REF: 2017: /* A one-bit unsigned bit-field is already acceptable. */ 2018: if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1))) 2019: && TREE_UNSIGNED (TREE_OPERAND (expr, 1))) 2020: return expr; 2021: break; 2022: #endif 2023: 2024: case EQ_EXPR: 2025: /* It is simpler and generates better code to have only TRUTH_*_EXPR 2026: or comparison expressions as truth values at this level. */ 2027: #if 0 2028: if (integer_zerop (TREE_OPERAND (expr, 1))) 2029: return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0); 2030: #endif 2031: case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 2032: case TRUTH_ANDIF_EXPR: 2033: case TRUTH_ORIF_EXPR: 2034: case TRUTH_AND_EXPR: 2035: case TRUTH_OR_EXPR: 1.1.1.4 root 2036: case TRUTH_XOR_EXPR: 1.1.1.7 ! root 2037: case TRUTH_NOT_EXPR: ! 2038: TREE_TYPE (expr) = boolean_type_node; ! 2039: return expr; 1.1.1.6 root 2040: 1.1 root 2041: case ERROR_MARK: 2042: return expr; 2043: 2044: case INTEGER_CST: 1.1.1.7 ! root 2045: return integer_zerop (expr) ? boolean_false_node : boolean_true_node; 1.1 root 2046: 2047: case REAL_CST: 1.1.1.7 ! root 2048: return real_zerop (expr) ? boolean_false_node : boolean_true_node; 1.1 root 2049: 2050: case ADDR_EXPR: 2051: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0))) 1.1.1.7 ! root 2052: return build (COMPOUND_EXPR, boolean_type_node, ! 2053: TREE_OPERAND (expr, 0), boolean_true_node); 1.1 root 2054: else 1.1.1.7 ! root 2055: return boolean_true_node; 1.1 root 2056: 1.1.1.4 root 2057: case COMPLEX_EXPR: 2058: return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) 1.1.1.5 root 2059: ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 1.1.1.4 root 2060: truthvalue_conversion (TREE_OPERAND (expr, 0)), 2061: truthvalue_conversion (TREE_OPERAND (expr, 1)), 2062: 0); 2063: 1.1 root 2064: case NEGATE_EXPR: 2065: case ABS_EXPR: 2066: case FLOAT_EXPR: 2067: case FFS_EXPR: 2068: /* These don't change whether an object is non-zero or zero. */ 2069: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 2070: 2071: case LROTATE_EXPR: 2072: case RROTATE_EXPR: 2073: /* These don't change whether an object is zero or non-zero, but 2074: we can't ignore them if their second arg has side-effects. */ 2075: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 1.1.1.7 ! root 2076: return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1), 1.1 root 2077: truthvalue_conversion (TREE_OPERAND (expr, 0))); 2078: else 2079: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 2080: 2081: case COND_EXPR: 2082: /* Distribute the conversion into the arms of a COND_EXPR. */ 1.1.1.7 ! root 2083: return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0), 1.1 root 2084: truthvalue_conversion (TREE_OPERAND (expr, 1)), 2085: truthvalue_conversion (TREE_OPERAND (expr, 2)))); 2086: 2087: case CONVERT_EXPR: 2088: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, 2089: since that affects how `default_conversion' will behave. */ 2090: if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE 2091: || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) 2092: break; 2093: /* fall through... */ 2094: case NOP_EXPR: 2095: /* If this is widening the argument, we can ignore it. */ 2096: if (TYPE_PRECISION (TREE_TYPE (expr)) 2097: >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) 2098: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 2099: break; 2100: 2101: case MINUS_EXPR: 1.1.1.4 root 2102: /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize 2103: this case. */ 2104: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT 2105: && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE) 2106: break; 2107: /* fall through... */ 2108: case BIT_XOR_EXPR: 2109: /* This and MINUS_EXPR can be changed into a comparison of the 2110: two objects. */ 1.1 root 2111: if (TREE_TYPE (TREE_OPERAND (expr, 0)) 2112: == TREE_TYPE (TREE_OPERAND (expr, 1))) 2113: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), 2114: TREE_OPERAND (expr, 1), 1); 2115: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), 2116: fold (build1 (NOP_EXPR, 2117: TREE_TYPE (TREE_OPERAND (expr, 0)), 2118: TREE_OPERAND (expr, 1))), 1); 1.1.1.3 root 2119: 1.1.1.6 root 2120: case BIT_AND_EXPR: 1.1.1.7 ! root 2121: if (integer_onep (TREE_OPERAND (expr, 1)) ! 2122: && TREE_TYPE (expr) != boolean_type_node) ! 2123: /* Using convert here would cause infinite recursion. */ ! 2124: return build1 (NOP_EXPR, boolean_type_node, expr); ! 2125: break; 1.1.1.6 root 2126: 1.1.1.3 root 2127: case MODIFY_EXPR: 2128: if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR) 2129: warning ("suggest parentheses around assignment used as truth value"); 2130: break; 1.1 root 2131: } 2132: 1.1.1.4 root 2133: if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE) 2134: return (build_binary_op 2135: ((TREE_SIDE_EFFECTS (expr) 1.1.1.5 root 2136: ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 1.1.1.4 root 2137: truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)), 2138: truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)), 2139: 0)); 2140: 1.1 root 2141: return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); 2142: } 2143: 2144: /* Read the rest of a #-directive from input stream FINPUT. 2145: In normal use, the directive name and the white space after it 2146: have already been read, so they won't be included in the result. 2147: We allow for the fact that the directive line may contain 2148: a newline embedded within a character or string literal which forms 2149: a part of the directive. 2150: 2151: The value is a string in a reusable buffer. It remains valid 2152: only until the next time this function is called. */ 2153: 2154: char * 2155: get_directive_line (finput) 2156: register FILE *finput; 2157: { 2158: static char *directive_buffer = NULL; 2159: static unsigned buffer_length = 0; 2160: register char *p; 2161: register char *buffer_limit; 2162: register int looking_for = 0; 2163: register int char_escaped = 0; 2164: 2165: if (buffer_length == 0) 2166: { 2167: directive_buffer = (char *)xmalloc (128); 2168: buffer_length = 128; 2169: } 2170: 2171: buffer_limit = &directive_buffer[buffer_length]; 2172: 2173: for (p = directive_buffer; ; ) 2174: { 2175: int c; 2176: 2177: /* Make buffer bigger if it is full. */ 2178: if (p >= buffer_limit) 2179: { 2180: register unsigned bytes_used = (p - directive_buffer); 2181: 2182: buffer_length *= 2; 2183: directive_buffer 2184: = (char *)xrealloc (directive_buffer, buffer_length); 2185: p = &directive_buffer[bytes_used]; 2186: buffer_limit = &directive_buffer[buffer_length]; 2187: } 2188: 2189: c = getc (finput); 2190: 2191: /* Discard initial whitespace. */ 2192: if ((c == ' ' || c == '\t') && p == directive_buffer) 2193: continue; 2194: 2195: /* Detect the end of the directive. */ 2196: if (c == '\n' && looking_for == 0) 2197: { 2198: ungetc (c, finput); 2199: c = '\0'; 2200: } 2201: 2202: *p++ = c; 2203: 2204: if (c == 0) 2205: return directive_buffer; 2206: 2207: /* Handle string and character constant syntax. */ 2208: if (looking_for) 2209: { 2210: if (looking_for == c && !char_escaped) 2211: looking_for = 0; /* Found terminator... stop looking. */ 2212: } 2213: else 2214: if (c == '\'' || c == '"') 2215: looking_for = c; /* Don't stop buffering until we see another 2216: another one of these (or an EOF). */ 2217: 2218: /* Handle backslash. */ 2219: char_escaped = (c == '\\' && ! char_escaped); 2220: } 2221: } 1.1.1.4 root 2222: 2223: /* Make a variant type in the proper way for C/C++, propagating qualifiers 2224: down to the element type of an array. */ 2225: 2226: tree 2227: c_build_type_variant (type, constp, volatilep) 2228: tree type; 2229: int constp, volatilep; 2230: { 2231: if (TREE_CODE (type) == ARRAY_TYPE) 2232: { 2233: tree real_main_variant = TYPE_MAIN_VARIANT (type); 2234: 1.1.1.6 root 2235: push_obstacks (TYPE_OBSTACK (real_main_variant), 2236: TYPE_OBSTACK (real_main_variant)); 1.1.1.4 root 2237: type = build_array_type (c_build_type_variant (TREE_TYPE (type), 2238: constp, volatilep), 2239: TYPE_DOMAIN (type)); 1.1.1.6 root 2240: 2241: /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not, 2242: make a copy. (TYPE might have come from the hash table and 2243: REAL_MAIN_VARIANT might be in some function's obstack.) */ 2244: 2245: if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant)) 2246: { 2247: type = copy_node (type); 2248: TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0; 2249: } 2250: 1.1.1.4 root 2251: TYPE_MAIN_VARIANT (type) = real_main_variant; 1.1.1.5 root 2252: pop_obstacks (); 1.1.1.4 root 2253: } 2254: return build_type_variant (type, constp, volatilep); 2255: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.