c-typeck.c revision 90075
1243830Sdim/* Build expressions with type checking for C compiler. 2226584Sdim Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 3226584Sdim 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. 4226584Sdim 5226584SdimThis file is part of GCC. 6226584Sdim 7226584SdimGCC is free software; you can redistribute it and/or modify it under 8226584Sdimthe terms of the GNU General Public License as published by the Free 9226584SdimSoftware Foundation; either version 2, or (at your option) any later 10226584Sdimversion. 11226584Sdim 12226584SdimGCC is distributed in the hope that it will be useful, but WITHOUT ANY 13226584SdimWARRANTY; without even the implied warranty of MERCHANTABILITY or 14251662SdimFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15249423Sdimfor more details. 16226584Sdim 17226584SdimYou should have received a copy of the GNU General Public License 18226584Sdimalong with GCC; see the file COPYING. If not, write to the Free 19226584SdimSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 20226584Sdim02111-1307, USA. */ 21226584Sdim 22226584Sdim 23226584Sdim/* This file is part of the C front end. 24226584Sdim It contains routines to build C expressions given their operands, 25226584Sdim including computing the types of the result, C-specific error checks, 26226584Sdim and some optimization. 27226584Sdim 28226584Sdim There are also routines to build RETURN_STMT nodes and CASE_STMT nodes, 29226584Sdim and to process initializations in declarations (since they work 30234353Sdim like a strange sort of assignment). */ 31226584Sdim 32226584Sdim#include "config.h" 33226584Sdim#include "system.h" 34226584Sdim#include "rtl.h" 35226584Sdim#include "tree.h" 36226584Sdim#include "c-tree.h" 37226584Sdim#include "tm_p.h" 38226584Sdim#include "flags.h" 39226584Sdim#include "output.h" 40226584Sdim#include "expr.h" 41226584Sdim#include "toplev.h" 42226584Sdim#include "intl.h" 43249423Sdim#include "ggc.h" 44226584Sdim#include "target.h" 45226584Sdim 46226584Sdim/* Nonzero if we've already printed a "missing braces around initializer" 47226584Sdim message within this initializer. */ 48226584Sdimstatic int missing_braces_mentioned; 49226584Sdim 50226584Sdim/* 1 if we explained undeclared var errors. */ 51226584Sdimstatic int undeclared_variable_notice; 52226584Sdim 53226584Sdimstatic tree qualify_type PARAMS ((tree, tree)); 54226584Sdimstatic int comp_target_types PARAMS ((tree, tree)); 55226584Sdimstatic int function_types_compatible_p PARAMS ((tree, tree)); 56226584Sdimstatic int type_lists_compatible_p PARAMS ((tree, tree)); 57226584Sdimstatic tree decl_constant_value_for_broken_optimization PARAMS ((tree)); 58226584Sdimstatic tree default_function_array_conversion PARAMS ((tree)); 59226584Sdimstatic tree lookup_field PARAMS ((tree, tree)); 60226584Sdimstatic tree convert_arguments PARAMS ((tree, tree, tree, tree)); 61226584Sdimstatic tree pointer_int_sum PARAMS ((enum tree_code, tree, tree)); 62226584Sdimstatic tree pointer_diff PARAMS ((tree, tree)); 63226584Sdimstatic tree unary_complex_lvalue PARAMS ((enum tree_code, tree, int)); 64226584Sdimstatic void pedantic_lvalue_warning PARAMS ((enum tree_code)); 65226584Sdimstatic tree internal_build_compound_expr PARAMS ((tree, int)); 66226584Sdimstatic tree convert_for_assignment PARAMS ((tree, tree, const char *, 67226584Sdim tree, tree, int)); 68226584Sdimstatic void warn_for_assignment PARAMS ((const char *, const char *, 69226584Sdim tree, int)); 70226584Sdimstatic tree valid_compound_expr_initializer PARAMS ((tree, tree)); 71226584Sdimstatic void push_string PARAMS ((const char *)); 72226584Sdimstatic void push_member_name PARAMS ((tree)); 73226584Sdimstatic void push_array_bounds PARAMS ((int)); 74226584Sdimstatic int spelling_length PARAMS ((void)); 75226584Sdimstatic char *print_spelling PARAMS ((char *)); 76226584Sdimstatic void warning_init PARAMS ((const char *)); 77226584Sdimstatic tree digest_init PARAMS ((tree, tree, int, int)); 78226584Sdimstatic void output_init_element PARAMS ((tree, tree, tree, int)); 79226584Sdimstatic void output_pending_init_elements PARAMS ((int)); 80226584Sdimstatic int set_designator PARAMS ((int)); 81226584Sdimstatic void push_range_stack PARAMS ((tree)); 82226584Sdimstatic void add_pending_init PARAMS ((tree, tree)); 83226584Sdimstatic void set_nonincremental_init PARAMS ((void)); 84226584Sdimstatic void set_nonincremental_init_from_string PARAMS ((tree)); 85226584Sdimstatic tree find_init_member PARAMS ((tree)); 86226584Sdim 87226584Sdim/* Do `exp = require_complete_type (exp);' to make sure exp 88226584Sdim does not have an incomplete type. (That includes void types.) */ 89226584Sdim 90226584Sdimtree 91226584Sdimrequire_complete_type (value) 92226584Sdim tree value; 93226584Sdim{ 94226584Sdim tree type = TREE_TYPE (value); 95226584Sdim 96226584Sdim if (value == error_mark_node || type == error_mark_node) 97251662Sdim return error_mark_node; 98251662Sdim 99251662Sdim /* First, detect a valid value with a complete type. */ 100251662Sdim if (COMPLETE_TYPE_P (type)) 101251662Sdim return value; 102251662Sdim 103251662Sdim incomplete_type_error (value, type); 104251662Sdim return error_mark_node; 105251662Sdim} 106251662Sdim 107251662Sdim/* Print an error message for invalid use of an incomplete type. 108251662Sdim VALUE is the expression that was used (or 0 if that isn't known) 109251662Sdim and TYPE is the type that was invalid. */ 110251662Sdim 111226584Sdimvoid 112251662Sdimincomplete_type_error (value, type) 113251662Sdim tree value; 114251662Sdim tree type; 115226584Sdim{ 116251662Sdim const char *type_code_string; 117251662Sdim 118251662Sdim /* Avoid duplicate error message. */ 119251662Sdim if (TREE_CODE (type) == ERROR_MARK) 120251662Sdim return; 121251662Sdim 122251662Sdim if (value != 0 && (TREE_CODE (value) == VAR_DECL 123251662Sdim || TREE_CODE (value) == PARM_DECL)) 124251662Sdim error ("`%s' has an incomplete type", 125251662Sdim IDENTIFIER_POINTER (DECL_NAME (value))); 126251662Sdim else 127251662Sdim { 128226584Sdim retry: 129226584Sdim /* We must print an error message. Be clever about what it says. */ 130251662Sdim 131226584Sdim switch (TREE_CODE (type)) 132226584Sdim { 133226584Sdim case RECORD_TYPE: 134251662Sdim type_code_string = "struct"; 135251662Sdim break; 136251662Sdim 137251662Sdim case UNION_TYPE: 138251662Sdim type_code_string = "union"; 139251662Sdim break; 140251662Sdim 141251662Sdim case ENUMERAL_TYPE: 142251662Sdim type_code_string = "enum"; 143251662Sdim break; 144251662Sdim 145251662Sdim case VOID_TYPE: 146251662Sdim error ("invalid use of void expression"); 147251662Sdim return; 148251662Sdim 149251662Sdim case ARRAY_TYPE: 150251662Sdim if (TYPE_DOMAIN (type)) 151251662Sdim { 152251662Sdim type = TREE_TYPE (type); 153251662Sdim goto retry; 154251662Sdim } 155251662Sdim error ("invalid use of array with unspecified bounds"); 156226584Sdim return; 157251662Sdim 158251662Sdim default: 159251662Sdim abort (); 160251662Sdim } 161226584Sdim 162251662Sdim if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 163251662Sdim error ("invalid use of undefined type `%s %s'", 164251662Sdim type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type))); 165251662Sdim else 166251662Sdim /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 167251662Sdim error ("invalid use of incomplete typedef `%s'", 168251662Sdim IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); 169226584Sdim } 170251662Sdim} 171251662Sdim 172251662Sdim/* Return a variant of TYPE which has all the type qualifiers of LIKE 173251662Sdim as well as those of TYPE. */ 174251662Sdim 175226584Sdimstatic tree 176226584Sdimqualify_type (type, like) 177251662Sdim tree type, like; 178226584Sdim{ 179226584Sdim return c_build_qualified_type (type, 180243830Sdim TYPE_QUALS (type) | TYPE_QUALS (like)); 181243830Sdim} 182243830Sdim 183243830Sdim/* Return the common type of two types. 184243830Sdim We assume that comptypes has already been done and returned 1; 185243830Sdim if that isn't so, this may crash. In particular, we assume that qualifiers 186243830Sdim match. 187243830Sdim 188243830Sdim This is the type for the result of most arithmetic operations 189243830Sdim if the operands have the given two types. */ 190226584Sdim 191226584Sdimtree 192226584Sdimcommon_type (t1, t2) 193226584Sdim tree t1, t2; 194226584Sdim{ 195226584Sdim enum tree_code code1; 196226584Sdim enum tree_code code2; 197226584Sdim tree attributes; 198226584Sdim 199226584Sdim /* Save time if the two types are the same. */ 200226584Sdim 201226584Sdim if (t1 == t2) return t1; 202226584Sdim 203226584Sdim /* If one type is nonsense, use the other. */ 204226584Sdim if (t1 == error_mark_node) 205226584Sdim return t2; 206226584Sdim if (t2 == error_mark_node) 207226584Sdim return t1; 208226584Sdim 209226584Sdim /* Merge the attributes. */ 210226584Sdim attributes = (*targetm.merge_type_attributes) (t1, t2); 211226584Sdim 212226584Sdim /* Treat an enum type as the unsigned integer type of the same width. */ 213226584Sdim 214226584Sdim if (TREE_CODE (t1) == ENUMERAL_TYPE) 215226584Sdim t1 = type_for_size (TYPE_PRECISION (t1), 1); 216226584Sdim if (TREE_CODE (t2) == ENUMERAL_TYPE) 217226584Sdim t2 = type_for_size (TYPE_PRECISION (t2), 1); 218226584Sdim 219226584Sdim code1 = TREE_CODE (t1); 220226584Sdim code2 = TREE_CODE (t2); 221226584Sdim 222226584Sdim /* If one type is complex, form the common type of the non-complex 223226584Sdim components, then make that complex. Use T1 or T2 if it is the 224226584Sdim required type. */ 225226584Sdim if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 226226584Sdim { 227243830Sdim tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 228243830Sdim tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 229243830Sdim tree subtype = common_type (subtype1, subtype2); 230243830Sdim 231226584Sdim if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 232226584Sdim return build_type_attribute_variant (t1, attributes); 233249423Sdim else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 234226584Sdim return build_type_attribute_variant (t2, attributes); 235226584Sdim else 236226584Sdim return build_type_attribute_variant (build_complex_type (subtype), 237226584Sdim attributes); 238226584Sdim } 239226584Sdim 240226584Sdim switch (code1) 241243830Sdim { 242243830Sdim case INTEGER_TYPE: 243243830Sdim case REAL_TYPE: 244226584Sdim /* If only one is real, use it as the result. */ 245226584Sdim 246226584Sdim if (code1 == REAL_TYPE && code2 != REAL_TYPE) 247226584Sdim return build_type_attribute_variant (t1, attributes); 248226584Sdim 249226584Sdim if (code2 == REAL_TYPE && code1 != REAL_TYPE) 250226584Sdim return build_type_attribute_variant (t2, attributes); 251226584Sdim 252243830Sdim /* Both real or both integers; use the one with greater precision. */ 253243830Sdim 254243830Sdim if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 255226584Sdim return build_type_attribute_variant (t1, attributes); 256226584Sdim else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 257226584Sdim return build_type_attribute_variant (t2, attributes); 258226584Sdim 259226584Sdim /* Same precision. Prefer longs to ints even when same size. */ 260226584Sdim 261226584Sdim if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node 262226584Sdim || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) 263243830Sdim return build_type_attribute_variant (long_unsigned_type_node, 264243830Sdim attributes); 265243830Sdim 266243830Sdim if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node 267226584Sdim || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) 268226584Sdim { 269226584Sdim /* But preserve unsignedness from the other type, 270226584Sdim since long cannot hold all the values of an unsigned int. */ 271226584Sdim if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2)) 272226584Sdim t1 = long_unsigned_type_node; 273243830Sdim else 274243830Sdim t1 = long_integer_type_node; 275243830Sdim return build_type_attribute_variant (t1, attributes); 276243830Sdim } 277243830Sdim 278243830Sdim /* Likewise, prefer long double to double even if same size. */ 279243830Sdim if (TYPE_MAIN_VARIANT (t1) == long_double_type_node 280243830Sdim || TYPE_MAIN_VARIANT (t2) == long_double_type_node) 281243830Sdim return build_type_attribute_variant (long_double_type_node, 282243830Sdim attributes); 283226584Sdim 284243830Sdim /* Otherwise prefer the unsigned one. */ 285243830Sdim 286226584Sdim if (TREE_UNSIGNED (t1)) 287226584Sdim return build_type_attribute_variant (t1, attributes); 288243830Sdim else 289243830Sdim return build_type_attribute_variant (t2, attributes); 290243830Sdim 291243830Sdim case POINTER_TYPE: 292243830Sdim /* For two pointers, do this recursively on the target type, 293243830Sdim and combine the qualifiers of the two types' targets. */ 294226584Sdim /* This code was turned off; I don't know why. 295226584Sdim But ANSI C specifies doing this with the qualifiers. 296226584Sdim So I turned it on again. */ 297226584Sdim { 298243830Sdim tree pointed_to_1 = TREE_TYPE (t1); 299226584Sdim tree pointed_to_2 = TREE_TYPE (t2); 300226584Sdim tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1), 301226584Sdim TYPE_MAIN_VARIANT (pointed_to_2)); 302226584Sdim t1 = build_pointer_type (c_build_qualified_type 303239462Sdim (target, 304239462Sdim TYPE_QUALS (pointed_to_1) | 305239462Sdim TYPE_QUALS (pointed_to_2))); 306243830Sdim return build_type_attribute_variant (t1, attributes); 307243830Sdim } 308243830Sdim#if 0 309243830Sdim t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2))); 310243830Sdim return build_type_attribute_variant (t1, attributes); 311243830Sdim#endif 312243830Sdim 313243830Sdim case ARRAY_TYPE: 314243830Sdim { 315243830Sdim tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2)); 316243830Sdim /* Save space: see if the result is identical to one of the args. */ 317243830Sdim if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)) 318243830Sdim return build_type_attribute_variant (t1, attributes); 319243830Sdim if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)) 320239462Sdim return build_type_attribute_variant (t2, attributes); 321239462Sdim /* Merge the element types, and have a size if either arg has one. */ 322239462Sdim t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2)); 323239462Sdim return build_type_attribute_variant (t1, attributes); 324239462Sdim } 325243830Sdim 326243830Sdim case FUNCTION_TYPE: 327243830Sdim /* Function types: prefer the one that specified arg types. 328239462Sdim If both do, merge the arg types. Also merge the return types. */ 329239462Sdim { 330239462Sdim tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2)); 331243830Sdim tree p1 = TYPE_ARG_TYPES (t1); 332239462Sdim tree p2 = TYPE_ARG_TYPES (t2); 333243830Sdim int len; 334239462Sdim tree newargs, n; 335243830Sdim int i; 336239462Sdim 337239462Sdim /* Save space: see if the result is identical to one of the args. */ 338239462Sdim if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2)) 339243830Sdim return build_type_attribute_variant (t1, attributes); 340239462Sdim if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1)) 341239462Sdim return build_type_attribute_variant (t2, attributes); 342243830Sdim 343243830Sdim /* Simple way if one arg fails to specify argument types. */ 344239462Sdim if (TYPE_ARG_TYPES (t1) == 0) 345239462Sdim { 346239462Sdim t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2)); 347239462Sdim return build_type_attribute_variant (t1, attributes); 348239462Sdim } 349243830Sdim if (TYPE_ARG_TYPES (t2) == 0) 350239462Sdim { 351239462Sdim t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1)); 352243830Sdim return build_type_attribute_variant (t1, attributes); 353243830Sdim } 354239462Sdim 355239462Sdim /* If both args specify argument types, we must merge the two 356239462Sdim lists, argument by argument. */ 357239462Sdim 358239462Sdim pushlevel (0); 359243830Sdim declare_parm_level (1); 360243830Sdim 361243830Sdim len = list_length (p1); 362243830Sdim newargs = 0; 363243830Sdim 364243830Sdim for (i = 0; i < len; i++) 365243830Sdim newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 366243830Sdim 367243830Sdim n = newargs; 368243830Sdim 369243830Sdim for (; p1; 370243830Sdim p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) 371243830Sdim { 372243830Sdim /* A null type means arg type is not specified. 373243830Sdim Take whatever the other function type has. */ 374243830Sdim if (TREE_VALUE (p1) == 0) 375243830Sdim { 376243830Sdim TREE_VALUE (n) = TREE_VALUE (p2); 377243830Sdim goto parm_done; 378243830Sdim } 379243830Sdim if (TREE_VALUE (p2) == 0) 380243830Sdim { 381243830Sdim TREE_VALUE (n) = TREE_VALUE (p1); 382243830Sdim goto parm_done; 383243830Sdim } 384243830Sdim 385243830Sdim /* Given wait (union {union wait *u; int *i} *) 386243830Sdim and wait (union wait *), 387243830Sdim prefer union wait * as type of parm. */ 388243830Sdim if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE 389243830Sdim && TREE_VALUE (p1) != TREE_VALUE (p2)) 390243830Sdim { 391243830Sdim tree memb; 392243830Sdim for (memb = TYPE_FIELDS (TREE_VALUE (p1)); 393243830Sdim memb; memb = TREE_CHAIN (memb)) 394243830Sdim if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2))) 395243830Sdim { 396243830Sdim TREE_VALUE (n) = TREE_VALUE (p2); 397243830Sdim if (pedantic) 398 pedwarn ("function types not truly compatible in ISO C"); 399 goto parm_done; 400 } 401 } 402 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE 403 && TREE_VALUE (p2) != TREE_VALUE (p1)) 404 { 405 tree memb; 406 for (memb = TYPE_FIELDS (TREE_VALUE (p2)); 407 memb; memb = TREE_CHAIN (memb)) 408 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1))) 409 { 410 TREE_VALUE (n) = TREE_VALUE (p1); 411 if (pedantic) 412 pedwarn ("function types not truly compatible in ISO C"); 413 goto parm_done; 414 } 415 } 416 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2)); 417 parm_done: ; 418 } 419 420 poplevel (0, 0, 0); 421 422 t1 = build_function_type (valtype, newargs); 423 /* ... falls through ... */ 424 } 425 426 default: 427 return build_type_attribute_variant (t1, attributes); 428 } 429 430} 431 432/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 433 or various other operations. Return 2 if they are compatible 434 but a warning may be needed if you use them together. */ 435 436int 437comptypes (type1, type2) 438 tree type1, type2; 439{ 440 tree t1 = type1; 441 tree t2 = type2; 442 int attrval, val; 443 444 /* Suppress errors caused by previously reported errors. */ 445 446 if (t1 == t2 || !t1 || !t2 447 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK) 448 return 1; 449 450 /* If either type is the internal version of sizetype, return the 451 language version. */ 452 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 453 && TYPE_DOMAIN (t1) != 0) 454 t1 = TYPE_DOMAIN (t1); 455 456 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 457 && TYPE_DOMAIN (t2) != 0) 458 t2 = TYPE_DOMAIN (t2); 459 460 /* Treat an enum type as the integer type of the same width and 461 signedness. */ 462 463 if (TREE_CODE (t1) == ENUMERAL_TYPE) 464 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1)); 465 if (TREE_CODE (t2) == ENUMERAL_TYPE) 466 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2)); 467 468 if (t1 == t2) 469 return 1; 470 471 /* Different classes of types can't be compatible. */ 472 473 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0; 474 475 /* Qualifiers must match. */ 476 477 if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 478 return 0; 479 480 /* Allow for two different type nodes which have essentially the same 481 definition. Note that we already checked for equality of the type 482 qualifiers (just above). */ 483 484 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 485 return 1; 486 487 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 488 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2))) 489 return 0; 490 491 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 492 val = 0; 493 494 switch (TREE_CODE (t1)) 495 { 496 case POINTER_TYPE: 497 val = (TREE_TYPE (t1) == TREE_TYPE (t2) 498 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2))); 499 break; 500 501 case FUNCTION_TYPE: 502 val = function_types_compatible_p (t1, t2); 503 break; 504 505 case ARRAY_TYPE: 506 { 507 tree d1 = TYPE_DOMAIN (t1); 508 tree d2 = TYPE_DOMAIN (t2); 509 bool d1_variable, d2_variable; 510 bool d1_zero, d2_zero; 511 val = 1; 512 513 /* Target types must match incl. qualifiers. */ 514 if (TREE_TYPE (t1) != TREE_TYPE (t2) 515 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))) 516 return 0; 517 518 /* Sizes must match unless one is missing or variable. */ 519 if (d1 == 0 || d2 == 0 || d1 == d2) 520 break; 521 522 d1_zero = ! TYPE_MAX_VALUE (d1); 523 d2_zero = ! TYPE_MAX_VALUE (d2); 524 525 d1_variable = (! d1_zero 526 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 527 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 528 d2_variable = (! d2_zero 529 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 530 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 531 532 if (d1_variable || d2_variable) 533 break; 534 if (d1_zero && d2_zero) 535 break; 536 if (d1_zero || d2_zero 537 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)) 538 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2))) 539 val = 0; 540 541 break; 542 } 543 544 case RECORD_TYPE: 545 if (maybe_objc_comptypes (t1, t2, 0) == 1) 546 val = 1; 547 break; 548 549 default: 550 break; 551 } 552 return attrval == 2 && val == 1 ? 2 : val; 553} 554 555/* Return 1 if TTL and TTR are pointers to types that are equivalent, 556 ignoring their qualifiers. */ 557 558static int 559comp_target_types (ttl, ttr) 560 tree ttl, ttr; 561{ 562 int val; 563 564 /* Give maybe_objc_comptypes a crack at letting these types through. */ 565 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0) 566 return val; 567 568 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)), 569 TYPE_MAIN_VARIANT (TREE_TYPE (ttr))); 570 571 if (val == 2 && pedantic) 572 pedwarn ("types are not quite compatible"); 573 return val; 574} 575 576/* Subroutines of `comptypes'. */ 577 578/* Return 1 if two function types F1 and F2 are compatible. 579 If either type specifies no argument types, 580 the other must specify a fixed number of self-promoting arg types. 581 Otherwise, if one type specifies only the number of arguments, 582 the other must specify that number of self-promoting arg types. 583 Otherwise, the argument types must match. */ 584 585static int 586function_types_compatible_p (f1, f2) 587 tree f1, f2; 588{ 589 tree args1, args2; 590 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 591 int val = 1; 592 int val1; 593 594 if (!(TREE_TYPE (f1) == TREE_TYPE (f2) 595 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2))))) 596 return 0; 597 598 args1 = TYPE_ARG_TYPES (f1); 599 args2 = TYPE_ARG_TYPES (f2); 600 601 /* An unspecified parmlist matches any specified parmlist 602 whose argument types don't need default promotions. */ 603 604 if (args1 == 0) 605 { 606 if (!self_promoting_args_p (args2)) 607 return 0; 608 /* If one of these types comes from a non-prototype fn definition, 609 compare that with the other type's arglist. 610 If they don't match, ask for a warning (but no error). */ 611 if (TYPE_ACTUAL_ARG_TYPES (f1) 612 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1))) 613 val = 2; 614 return val; 615 } 616 if (args2 == 0) 617 { 618 if (!self_promoting_args_p (args1)) 619 return 0; 620 if (TYPE_ACTUAL_ARG_TYPES (f2) 621 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2))) 622 val = 2; 623 return val; 624 } 625 626 /* Both types have argument lists: compare them and propagate results. */ 627 val1 = type_lists_compatible_p (args1, args2); 628 return val1 != 1 ? val1 : val; 629} 630 631/* Check two lists of types for compatibility, 632 returning 0 for incompatible, 1 for compatible, 633 or 2 for compatible with warning. */ 634 635static int 636type_lists_compatible_p (args1, args2) 637 tree args1, args2; 638{ 639 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 640 int val = 1; 641 int newval = 0; 642 643 while (1) 644 { 645 if (args1 == 0 && args2 == 0) 646 return val; 647 /* If one list is shorter than the other, 648 they fail to match. */ 649 if (args1 == 0 || args2 == 0) 650 return 0; 651 /* A null pointer instead of a type 652 means there is supposed to be an argument 653 but nothing is specified about what type it has. 654 So match anything that self-promotes. */ 655 if (TREE_VALUE (args1) == 0) 656 { 657 if (simple_type_promotes_to (TREE_VALUE (args2)) != NULL_TREE) 658 return 0; 659 } 660 else if (TREE_VALUE (args2) == 0) 661 { 662 if (simple_type_promotes_to (TREE_VALUE (args1)) != NULL_TREE) 663 return 0; 664 } 665 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)), 666 TYPE_MAIN_VARIANT (TREE_VALUE (args2))))) 667 { 668 /* Allow wait (union {union wait *u; int *i} *) 669 and wait (union wait *) to be compatible. */ 670 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE 671 && (TYPE_NAME (TREE_VALUE (args1)) == 0 672 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1))) 673 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST 674 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)), 675 TYPE_SIZE (TREE_VALUE (args2)))) 676 { 677 tree memb; 678 for (memb = TYPE_FIELDS (TREE_VALUE (args1)); 679 memb; memb = TREE_CHAIN (memb)) 680 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2))) 681 break; 682 if (memb == 0) 683 return 0; 684 } 685 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE 686 && (TYPE_NAME (TREE_VALUE (args2)) == 0 687 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2))) 688 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST 689 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)), 690 TYPE_SIZE (TREE_VALUE (args1)))) 691 { 692 tree memb; 693 for (memb = TYPE_FIELDS (TREE_VALUE (args2)); 694 memb; memb = TREE_CHAIN (memb)) 695 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1))) 696 break; 697 if (memb == 0) 698 return 0; 699 } 700 else 701 return 0; 702 } 703 704 /* comptypes said ok, but record if it said to warn. */ 705 if (newval > val) 706 val = newval; 707 708 args1 = TREE_CHAIN (args1); 709 args2 = TREE_CHAIN (args2); 710 } 711} 712 713/* Compute the value of the `sizeof' operator. */ 714 715tree 716c_sizeof (type) 717 tree type; 718{ 719 enum tree_code code = TREE_CODE (type); 720 tree size; 721 722 if (code == FUNCTION_TYPE) 723 { 724 if (pedantic || warn_pointer_arith) 725 pedwarn ("sizeof applied to a function type"); 726 size = size_one_node; 727 } 728 else if (code == VOID_TYPE) 729 { 730 if (pedantic || warn_pointer_arith) 731 pedwarn ("sizeof applied to a void type"); 732 size = size_one_node; 733 } 734 else if (code == ERROR_MARK) 735 size = size_one_node; 736 else if (!COMPLETE_TYPE_P (type)) 737 { 738 error ("sizeof applied to an incomplete type"); 739 size = size_zero_node; 740 } 741 else 742 /* Convert in case a char is more than one unit. */ 743 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 744 size_int (TYPE_PRECISION (char_type_node) 745 / BITS_PER_UNIT)); 746 747 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set. 748 TYPE_IS_SIZETYPE means that certain things (like overflow) will 749 never happen. However, this node should really have type 750 `size_t', which is just a typedef for an ordinary integer type. */ 751 return fold (build1 (NOP_EXPR, c_size_type_node, size)); 752} 753 754tree 755c_sizeof_nowarn (type) 756 tree type; 757{ 758 enum tree_code code = TREE_CODE (type); 759 tree size; 760 761 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 762 size = size_one_node; 763 else if (!COMPLETE_TYPE_P (type)) 764 size = size_zero_node; 765 else 766 /* Convert in case a char is more than one unit. */ 767 size = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 768 size_int (TYPE_PRECISION (char_type_node) 769 / BITS_PER_UNIT)); 770 771 /* SIZE will have an integer type with TYPE_IS_SIZETYPE set. 772 TYPE_IS_SIZETYPE means that certain things (like overflow) will 773 never happen. However, this node should really have type 774 `size_t', which is just a typedef for an ordinary integer type. */ 775 return fold (build1 (NOP_EXPR, c_size_type_node, size)); 776} 777 778/* Compute the size to increment a pointer by. */ 779 780tree 781c_size_in_bytes (type) 782 tree type; 783{ 784 enum tree_code code = TREE_CODE (type); 785 786 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 787 return size_one_node; 788 789 if (!COMPLETE_OR_VOID_TYPE_P (type)) 790 { 791 error ("arithmetic on pointer to an incomplete type"); 792 return size_one_node; 793 } 794 795 /* Convert in case a char is more than one unit. */ 796 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 797 size_int (TYPE_PRECISION (char_type_node) 798 / BITS_PER_UNIT)); 799} 800 801/* Return either DECL or its known constant value (if it has one). */ 802 803tree 804decl_constant_value (decl) 805 tree decl; 806{ 807 if (/* Don't change a variable array bound or initial value to a constant 808 in a place where a variable is invalid. */ 809 current_function_decl != 0 810 && ! TREE_THIS_VOLATILE (decl) 811 && TREE_READONLY (decl) 812 && DECL_INITIAL (decl) != 0 813 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK 814 /* This is invalid if initial value is not constant. 815 If it has either a function call, a memory reference, 816 or a variable, then re-evaluating it could give different results. */ 817 && TREE_CONSTANT (DECL_INITIAL (decl)) 818 /* Check for cases where this is sub-optimal, even though valid. */ 819 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR) 820 return DECL_INITIAL (decl); 821 return decl; 822} 823 824/* Return either DECL or its known constant value (if it has one), but 825 return DECL if pedantic or DECL has mode BLKmode. This is for 826 bug-compatibility with the old behavior of decl_constant_value 827 (before GCC 3.0); every use of this function is a bug and it should 828 be removed before GCC 3.1. It is not appropriate to use pedantic 829 in a way that affects optimization, and BLKmode is probably not the 830 right test for avoiding misoptimizations either. */ 831 832static tree 833decl_constant_value_for_broken_optimization (decl) 834 tree decl; 835{ 836 if (pedantic || DECL_MODE (decl) == BLKmode) 837 return decl; 838 else 839 return decl_constant_value (decl); 840} 841 842 843/* Perform the default conversion of arrays and functions to pointers. 844 Return the result of converting EXP. For any other expression, just 845 return EXP. */ 846 847static tree 848default_function_array_conversion (exp) 849 tree exp; 850{ 851 tree orig_exp; 852 tree type = TREE_TYPE (exp); 853 enum tree_code code = TREE_CODE (type); 854 int not_lvalue = 0; 855 856 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as 857 an lvalue. 858 859 Do not use STRIP_NOPS here! It will remove conversions from pointer 860 to integer and cause infinite recursion. */ 861 orig_exp = exp; 862 while (TREE_CODE (exp) == NON_LVALUE_EXPR 863 || (TREE_CODE (exp) == NOP_EXPR 864 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp))) 865 { 866 if (TREE_CODE (exp) == NON_LVALUE_EXPR) 867 not_lvalue = 1; 868 exp = TREE_OPERAND (exp, 0); 869 } 870 871 /* Preserve the original expression code. */ 872 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp)))) 873 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp)); 874 875 if (code == FUNCTION_TYPE) 876 { 877 return build_unary_op (ADDR_EXPR, exp, 0); 878 } 879 if (code == ARRAY_TYPE) 880 { 881 tree adr; 882 tree restype = TREE_TYPE (type); 883 tree ptrtype; 884 int constp = 0; 885 int volatilep = 0; 886 int lvalue_array_p; 887 888 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp)) 889 { 890 constp = TREE_READONLY (exp); 891 volatilep = TREE_THIS_VOLATILE (exp); 892 } 893 894 if (TYPE_QUALS (type) || constp || volatilep) 895 restype 896 = c_build_qualified_type (restype, 897 TYPE_QUALS (type) 898 | (constp * TYPE_QUAL_CONST) 899 | (volatilep * TYPE_QUAL_VOLATILE)); 900 901 if (TREE_CODE (exp) == INDIRECT_REF) 902 return convert (TYPE_POINTER_TO (restype), 903 TREE_OPERAND (exp, 0)); 904 905 if (TREE_CODE (exp) == COMPOUND_EXPR) 906 { 907 tree op1 = default_conversion (TREE_OPERAND (exp, 1)); 908 return build (COMPOUND_EXPR, TREE_TYPE (op1), 909 TREE_OPERAND (exp, 0), op1); 910 } 911 912 lvalue_array_p = !not_lvalue && lvalue_p (exp); 913 if (!flag_isoc99 && !lvalue_array_p) 914 { 915 /* Before C99, non-lvalue arrays do not decay to pointers. 916 Normally, using such an array would be invalid; but it can 917 be used correctly inside sizeof or as a statement expression. 918 Thus, do not give an error here; an error will result later. */ 919 return exp; 920 } 921 922 ptrtype = build_pointer_type (restype); 923 924 if (TREE_CODE (exp) == VAR_DECL) 925 { 926 /* ??? This is not really quite correct 927 in that the type of the operand of ADDR_EXPR 928 is not the target type of the type of the ADDR_EXPR itself. 929 Question is, can this lossage be avoided? */ 930 adr = build1 (ADDR_EXPR, ptrtype, exp); 931 if (mark_addressable (exp) == 0) 932 return error_mark_node; 933 TREE_CONSTANT (adr) = staticp (exp); 934 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ 935 return adr; 936 } 937 /* This way is better for a COMPONENT_REF since it can 938 simplify the offset for a component. */ 939 adr = build_unary_op (ADDR_EXPR, exp, 1); 940 return convert (ptrtype, adr); 941 } 942 return exp; 943} 944 945/* Perform default promotions for C data used in expressions. 946 Arrays and functions are converted to pointers; 947 enumeral types or short or char, to int. 948 In addition, manifest constants symbols are replaced by their values. */ 949 950tree 951default_conversion (exp) 952 tree exp; 953{ 954 tree orig_exp; 955 tree type = TREE_TYPE (exp); 956 enum tree_code code = TREE_CODE (type); 957 958 if (code == FUNCTION_TYPE || code == ARRAY_TYPE) 959 return default_function_array_conversion (exp); 960 961 /* Constants can be used directly unless they're not loadable. */ 962 if (TREE_CODE (exp) == CONST_DECL) 963 exp = DECL_INITIAL (exp); 964 965 /* Replace a nonvolatile const static variable with its value unless 966 it is an array, in which case we must be sure that taking the 967 address of the array produces consistent results. */ 968 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) 969 { 970 exp = decl_constant_value_for_broken_optimization (exp); 971 type = TREE_TYPE (exp); 972 } 973 974 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as 975 an lvalue. 976 977 Do not use STRIP_NOPS here! It will remove conversions from pointer 978 to integer and cause infinite recursion. */ 979 orig_exp = exp; 980 while (TREE_CODE (exp) == NON_LVALUE_EXPR 981 || (TREE_CODE (exp) == NOP_EXPR 982 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp))) 983 exp = TREE_OPERAND (exp, 0); 984 985 /* Preserve the original expression code. */ 986 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp)))) 987 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp)); 988 989 /* Normally convert enums to int, 990 but convert wide enums to something wider. */ 991 if (code == ENUMERAL_TYPE) 992 { 993 type = type_for_size (MAX (TYPE_PRECISION (type), 994 TYPE_PRECISION (integer_type_node)), 995 ((flag_traditional 996 || (TYPE_PRECISION (type) 997 >= TYPE_PRECISION (integer_type_node))) 998 && TREE_UNSIGNED (type))); 999 1000 return convert (type, exp); 1001 } 1002 1003 if (TREE_CODE (exp) == COMPONENT_REF 1004 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) 1005 /* If it's thinner than an int, promote it like a 1006 c_promoting_integer_type_p, otherwise leave it alone. */ 1007 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), 1008 TYPE_PRECISION (integer_type_node))) 1009 return convert (flag_traditional && TREE_UNSIGNED (type) 1010 ? unsigned_type_node : integer_type_node, 1011 exp); 1012 1013 if (c_promoting_integer_type_p (type)) 1014 { 1015 /* Traditionally, unsignedness is preserved in default promotions. 1016 Also preserve unsignedness if not really getting any wider. */ 1017 if (TREE_UNSIGNED (type) 1018 && (flag_traditional 1019 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))) 1020 return convert (unsigned_type_node, exp); 1021 1022 return convert (integer_type_node, exp); 1023 } 1024 1025 if (flag_traditional && !flag_allow_single_precision 1026 && TYPE_MAIN_VARIANT (type) == float_type_node) 1027 return convert (double_type_node, exp); 1028 1029 if (code == VOID_TYPE) 1030 { 1031 error ("void value not ignored as it ought to be"); 1032 return error_mark_node; 1033 } 1034 return exp; 1035} 1036 1037/* Look up COMPONENT in a structure or union DECL. 1038 1039 If the component name is not found, returns NULL_TREE. Otherwise, 1040 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL 1041 stepping down the chain to the component, which is in the last 1042 TREE_VALUE of the list. Normally the list is of length one, but if 1043 the component is embedded within (nested) anonymous structures or 1044 unions, the list steps down the chain to the component. */ 1045 1046static tree 1047lookup_field (decl, component) 1048 tree decl, component; 1049{ 1050 tree type = TREE_TYPE (decl); 1051 tree field; 1052 1053 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers 1054 to the field elements. Use a binary search on this array to quickly 1055 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC 1056 will always be set for structures which have many elements. */ 1057 1058 if (TYPE_LANG_SPECIFIC (type)) 1059 { 1060 int bot, top, half; 1061 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0]; 1062 1063 field = TYPE_FIELDS (type); 1064 bot = 0; 1065 top = TYPE_LANG_SPECIFIC (type)->len; 1066 while (top - bot > 1) 1067 { 1068 half = (top - bot + 1) >> 1; 1069 field = field_array[bot+half]; 1070 1071 if (DECL_NAME (field) == NULL_TREE) 1072 { 1073 /* Step through all anon unions in linear fashion. */ 1074 while (DECL_NAME (field_array[bot]) == NULL_TREE) 1075 { 1076 field = field_array[bot++]; 1077 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 1078 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 1079 { 1080 tree anon = lookup_field (field, component); 1081 1082 if (anon) 1083 return tree_cons (NULL_TREE, field, anon); 1084 } 1085 } 1086 1087 /* Entire record is only anon unions. */ 1088 if (bot > top) 1089 return NULL_TREE; 1090 1091 /* Restart the binary search, with new lower bound. */ 1092 continue; 1093 } 1094 1095 if (DECL_NAME (field) == component) 1096 break; 1097 if (DECL_NAME (field) < component) 1098 bot += half; 1099 else 1100 top = bot + half; 1101 } 1102 1103 if (DECL_NAME (field_array[bot]) == component) 1104 field = field_array[bot]; 1105 else if (DECL_NAME (field) != component) 1106 return NULL_TREE; 1107 } 1108 else 1109 { 1110 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1111 { 1112 if (DECL_NAME (field) == NULL_TREE 1113 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 1114 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)) 1115 { 1116 tree anon = lookup_field (field, component); 1117 1118 if (anon) 1119 return tree_cons (NULL_TREE, field, anon); 1120 } 1121 1122 if (DECL_NAME (field) == component) 1123 break; 1124 } 1125 1126 if (field == NULL_TREE) 1127 return NULL_TREE; 1128 } 1129 1130 return tree_cons (NULL_TREE, field, NULL_TREE); 1131} 1132 1133/* Make an expression to refer to the COMPONENT field of 1134 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */ 1135 1136tree 1137build_component_ref (datum, component) 1138 tree datum, component; 1139{ 1140 tree type = TREE_TYPE (datum); 1141 enum tree_code code = TREE_CODE (type); 1142 tree field = NULL; 1143 tree ref; 1144 1145 /* If DATUM is a COMPOUND_EXPR, move our reference inside it. 1146 If pedantic ensure that the arguments are not lvalues; otherwise, 1147 if the component is an array, it would wrongly decay to a pointer in 1148 C89 mode. 1149 We cannot do this with a COND_EXPR, because in a conditional expression 1150 the default promotions are applied to both sides, and this would yield 1151 the wrong type of the result; for example, if the components have 1152 type "char". */ 1153 switch (TREE_CODE (datum)) 1154 { 1155 case COMPOUND_EXPR: 1156 { 1157 tree value = build_component_ref (TREE_OPERAND (datum, 1), component); 1158 return build (COMPOUND_EXPR, TREE_TYPE (value), 1159 TREE_OPERAND (datum, 0), pedantic_non_lvalue (value)); 1160 } 1161 default: 1162 break; 1163 } 1164 1165 /* See if there is a field or component with name COMPONENT. */ 1166 1167 if (code == RECORD_TYPE || code == UNION_TYPE) 1168 { 1169 if (!COMPLETE_TYPE_P (type)) 1170 { 1171 incomplete_type_error (NULL_TREE, type); 1172 return error_mark_node; 1173 } 1174 1175 field = lookup_field (datum, component); 1176 1177 if (!field) 1178 { 1179 error ("%s has no member named `%s'", 1180 code == RECORD_TYPE ? "structure" : "union", 1181 IDENTIFIER_POINTER (component)); 1182 return error_mark_node; 1183 } 1184 1185 /* Chain the COMPONENT_REFs if necessary down to the FIELD. 1186 This might be better solved in future the way the C++ front 1187 end does it - by giving the anonymous entities each a 1188 separate name and type, and then have build_component_ref 1189 recursively call itself. We can't do that here. */ 1190 for (; field; field = TREE_CHAIN (field)) 1191 { 1192 tree subdatum = TREE_VALUE (field); 1193 1194 if (TREE_TYPE (subdatum) == error_mark_node) 1195 return error_mark_node; 1196 1197 ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum); 1198 if (TREE_READONLY (datum) || TREE_READONLY (subdatum)) 1199 TREE_READONLY (ref) = 1; 1200 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum)) 1201 TREE_THIS_VOLATILE (ref) = 1; 1202 1203 if (TREE_DEPRECATED (subdatum)) 1204 warn_deprecated_use (subdatum); 1205 1206 datum = ref; 1207 } 1208 1209 return ref; 1210 } 1211 else if (code != ERROR_MARK) 1212 error ("request for member `%s' in something not a structure or union", 1213 IDENTIFIER_POINTER (component)); 1214 1215 return error_mark_node; 1216} 1217 1218/* Given an expression PTR for a pointer, return an expression 1219 for the value pointed to. 1220 ERRORSTRING is the name of the operator to appear in error messages. */ 1221 1222tree 1223build_indirect_ref (ptr, errorstring) 1224 tree ptr; 1225 const char *errorstring; 1226{ 1227 tree pointer = default_conversion (ptr); 1228 tree type = TREE_TYPE (pointer); 1229 1230 if (TREE_CODE (type) == POINTER_TYPE) 1231 { 1232 if (TREE_CODE (pointer) == ADDR_EXPR 1233 && !flag_volatile 1234 && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 1235 == TREE_TYPE (type))) 1236 return TREE_OPERAND (pointer, 0); 1237 else 1238 { 1239 tree t = TREE_TYPE (type); 1240 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer); 1241 1242 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 1243 { 1244 error ("dereferencing pointer to incomplete type"); 1245 return error_mark_node; 1246 } 1247 if (VOID_TYPE_P (t) && skip_evaluation == 0) 1248 warning ("dereferencing `void *' pointer"); 1249 1250 /* We *must* set TREE_READONLY when dereferencing a pointer to const, 1251 so that we get the proper error message if the result is used 1252 to assign to. Also, &* is supposed to be a no-op. 1253 And ANSI C seems to specify that the type of the result 1254 should be the const type. */ 1255 /* A de-reference of a pointer to const is not a const. It is valid 1256 to change it via some other pointer. */ 1257 TREE_READONLY (ref) = TYPE_READONLY (t); 1258 TREE_SIDE_EFFECTS (ref) 1259 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile; 1260 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 1261 return ref; 1262 } 1263 } 1264 else if (TREE_CODE (pointer) != ERROR_MARK) 1265 error ("invalid type argument of `%s'", errorstring); 1266 return error_mark_node; 1267} 1268 1269/* This handles expressions of the form "a[i]", which denotes 1270 an array reference. 1271 1272 This is logically equivalent in C to *(a+i), but we may do it differently. 1273 If A is a variable or a member, we generate a primitive ARRAY_REF. 1274 This avoids forcing the array out of registers, and can work on 1275 arrays that are not lvalues (for example, members of structures returned 1276 by functions). */ 1277 1278tree 1279build_array_ref (array, index) 1280 tree array, index; 1281{ 1282 if (index == 0) 1283 { 1284 error ("subscript missing in array reference"); 1285 return error_mark_node; 1286 } 1287 1288 if (TREE_TYPE (array) == error_mark_node 1289 || TREE_TYPE (index) == error_mark_node) 1290 return error_mark_node; 1291 1292 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE 1293 && TREE_CODE (array) != INDIRECT_REF) 1294 { 1295 tree rval, type; 1296 1297 /* Subscripting with type char is likely to lose 1298 on a machine where chars are signed. 1299 So warn on any machine, but optionally. 1300 Don't warn for unsigned char since that type is safe. 1301 Don't warn for signed char because anyone who uses that 1302 must have done so deliberately. */ 1303 if (warn_char_subscripts 1304 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node) 1305 warning ("array subscript has type `char'"); 1306 1307 /* Apply default promotions *after* noticing character types. */ 1308 index = default_conversion (index); 1309 1310 /* Require integer *after* promotion, for sake of enums. */ 1311 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE) 1312 { 1313 error ("array subscript is not an integer"); 1314 return error_mark_node; 1315 } 1316 1317 /* An array that is indexed by a non-constant 1318 cannot be stored in a register; we must be able to do 1319 address arithmetic on its address. 1320 Likewise an array of elements of variable size. */ 1321 if (TREE_CODE (index) != INTEGER_CST 1322 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 1323 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 1324 { 1325 if (mark_addressable (array) == 0) 1326 return error_mark_node; 1327 } 1328 /* An array that is indexed by a constant value which is not within 1329 the array bounds cannot be stored in a register either; because we 1330 would get a crash in store_bit_field/extract_bit_field when trying 1331 to access a non-existent part of the register. */ 1332 if (TREE_CODE (index) == INTEGER_CST 1333 && TYPE_VALUES (TREE_TYPE (array)) 1334 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array)))) 1335 { 1336 if (mark_addressable (array) == 0) 1337 return error_mark_node; 1338 } 1339 1340 if (pedantic) 1341 { 1342 tree foo = array; 1343 while (TREE_CODE (foo) == COMPONENT_REF) 1344 foo = TREE_OPERAND (foo, 0); 1345 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo)) 1346 pedwarn ("ISO C forbids subscripting `register' array"); 1347 else if (! flag_isoc99 && ! lvalue_p (foo)) 1348 pedwarn ("ISO C89 forbids subscripting non-lvalue array"); 1349 } 1350 1351 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array))); 1352 rval = build (ARRAY_REF, type, array, index); 1353 /* Array ref is const/volatile if the array elements are 1354 or if the array is. */ 1355 TREE_READONLY (rval) 1356 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 1357 | TREE_READONLY (array)); 1358 TREE_SIDE_EFFECTS (rval) 1359 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 1360 | TREE_SIDE_EFFECTS (array)); 1361 TREE_THIS_VOLATILE (rval) 1362 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 1363 /* This was added by rms on 16 Nov 91. 1364 It fixes vol struct foo *a; a->elts[1] 1365 in an inline function. 1366 Hope it doesn't break something else. */ 1367 | TREE_THIS_VOLATILE (array)); 1368 return require_complete_type (fold (rval)); 1369 } 1370 1371 { 1372 tree ar = default_conversion (array); 1373 tree ind = default_conversion (index); 1374 1375 /* Do the same warning check as above, but only on the part that's 1376 syntactically the index and only if it is also semantically 1377 the index. */ 1378 if (warn_char_subscripts 1379 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE 1380 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node) 1381 warning ("subscript has type `char'"); 1382 1383 /* Put the integer in IND to simplify error checking. */ 1384 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE) 1385 { 1386 tree temp = ar; 1387 ar = ind; 1388 ind = temp; 1389 } 1390 1391 if (ar == error_mark_node) 1392 return ar; 1393 1394 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE 1395 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE) 1396 { 1397 error ("subscripted value is neither array nor pointer"); 1398 return error_mark_node; 1399 } 1400 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE) 1401 { 1402 error ("array subscript is not an integer"); 1403 return error_mark_node; 1404 } 1405 1406 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0), 1407 "array indexing"); 1408 } 1409} 1410 1411/* Build an external reference to identifier ID. FUN indicates 1412 whether this will be used for a function call. */ 1413tree 1414build_external_ref (id, fun) 1415 tree id; 1416 int fun; 1417{ 1418 tree ref; 1419 tree decl = lookup_name (id); 1420 tree objc_ivar = lookup_objc_ivar (id); 1421 1422 if (decl && TREE_DEPRECATED (decl)) 1423 warn_deprecated_use (decl); 1424 1425 if (!decl || decl == error_mark_node || C_DECL_ANTICIPATED (decl)) 1426 { 1427 if (objc_ivar) 1428 ref = objc_ivar; 1429 else if (fun) 1430 { 1431 if (!decl || decl == error_mark_node) 1432 /* Ordinary implicit function declaration. */ 1433 ref = implicitly_declare (id); 1434 else 1435 { 1436 /* Implicit declaration of built-in function. Don't 1437 change the built-in declaration, but don't let this 1438 go by silently, either. */ 1439 implicit_decl_warning (id); 1440 1441 /* only issue this warning once */ 1442 C_DECL_ANTICIPATED (decl) = 0; 1443 ref = decl; 1444 } 1445 } 1446 else 1447 { 1448 /* Reference to undeclared variable, including reference to 1449 builtin outside of function-call context. */ 1450 if (current_function_decl == 0) 1451 error ("`%s' undeclared here (not in a function)", 1452 IDENTIFIER_POINTER (id)); 1453 else 1454 { 1455 if (IDENTIFIER_GLOBAL_VALUE (id) != error_mark_node 1456 || IDENTIFIER_ERROR_LOCUS (id) != current_function_decl) 1457 { 1458 error ("`%s' undeclared (first use in this function)", 1459 IDENTIFIER_POINTER (id)); 1460 1461 if (! undeclared_variable_notice) 1462 { 1463 error ("(Each undeclared identifier is reported only once"); 1464 error ("for each function it appears in.)"); 1465 undeclared_variable_notice = 1; 1466 } 1467 } 1468 IDENTIFIER_GLOBAL_VALUE (id) = error_mark_node; 1469 IDENTIFIER_ERROR_LOCUS (id) = current_function_decl; 1470 } 1471 return error_mark_node; 1472 } 1473 } 1474 else 1475 { 1476 /* Properly declared variable or function reference. */ 1477 if (!objc_ivar) 1478 ref = decl; 1479 else if (decl != objc_ivar && IDENTIFIER_LOCAL_VALUE (id)) 1480 { 1481 warning ("local declaration of `%s' hides instance variable", 1482 IDENTIFIER_POINTER (id)); 1483 ref = decl; 1484 } 1485 else 1486 ref = objc_ivar; 1487 } 1488 1489 if (TREE_TYPE (ref) == error_mark_node) 1490 return error_mark_node; 1491 1492 assemble_external (ref); 1493 TREE_USED (ref) = 1; 1494 1495 if (TREE_CODE (ref) == CONST_DECL) 1496 { 1497 ref = DECL_INITIAL (ref); 1498 TREE_CONSTANT (ref) = 1; 1499 } 1500 1501 return ref; 1502} 1503 1504/* Build a function call to function FUNCTION with parameters PARAMS. 1505 PARAMS is a list--a chain of TREE_LIST nodes--in which the 1506 TREE_VALUE of each node is a parameter-expression. 1507 FUNCTION's data type may be a function type or a pointer-to-function. */ 1508 1509tree 1510build_function_call (function, params) 1511 tree function, params; 1512{ 1513 tree fntype, fundecl = 0; 1514 tree coerced_params; 1515 tree name = NULL_TREE, assembler_name = NULL_TREE, result; 1516 1517 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 1518 STRIP_TYPE_NOPS (function); 1519 1520 /* Convert anything with function type to a pointer-to-function. */ 1521 if (TREE_CODE (function) == FUNCTION_DECL) 1522 { 1523 name = DECL_NAME (function); 1524 assembler_name = DECL_ASSEMBLER_NAME (function); 1525 1526 /* Differs from default_conversion by not setting TREE_ADDRESSABLE 1527 (because calling an inline function does not mean the function 1528 needs to be separately compiled). */ 1529 fntype = build_type_variant (TREE_TYPE (function), 1530 TREE_READONLY (function), 1531 TREE_THIS_VOLATILE (function)); 1532 fundecl = function; 1533 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function); 1534 } 1535 else 1536 function = default_conversion (function); 1537 1538 fntype = TREE_TYPE (function); 1539 1540 if (TREE_CODE (fntype) == ERROR_MARK) 1541 return error_mark_node; 1542 1543 if (!(TREE_CODE (fntype) == POINTER_TYPE 1544 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 1545 { 1546 error ("called object is not a function"); 1547 return error_mark_node; 1548 } 1549 1550 /* fntype now gets the type of function pointed to. */ 1551 fntype = TREE_TYPE (fntype); 1552 1553 /* Convert the parameters to the types declared in the 1554 function prototype, or apply default promotions. */ 1555 1556 coerced_params 1557 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl); 1558 1559 /* Check for errors in format strings. */ 1560 1561 if (warn_format) 1562 check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params); 1563 1564 /* Recognize certain built-in functions so we can make tree-codes 1565 other than CALL_EXPR. We do this when it enables fold-const.c 1566 to do something useful. */ 1567 1568 if (TREE_CODE (function) == ADDR_EXPR 1569 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL 1570 && DECL_BUILT_IN (TREE_OPERAND (function, 0))) 1571 { 1572 result = expand_tree_builtin (TREE_OPERAND (function, 0), 1573 params, coerced_params); 1574 if (result) 1575 return result; 1576 } 1577 1578 result = build (CALL_EXPR, TREE_TYPE (fntype), 1579 function, coerced_params, NULL_TREE); 1580 TREE_SIDE_EFFECTS (result) = 1; 1581 result = fold (result); 1582 1583 if (VOID_TYPE_P (TREE_TYPE (result))) 1584 return result; 1585 return require_complete_type (result); 1586} 1587 1588/* Convert the argument expressions in the list VALUES 1589 to the types in the list TYPELIST. The result is a list of converted 1590 argument expressions. 1591 1592 If TYPELIST is exhausted, or when an element has NULL as its type, 1593 perform the default conversions. 1594 1595 PARMLIST is the chain of parm decls for the function being called. 1596 It may be 0, if that info is not available. 1597 It is used only for generating error messages. 1598 1599 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages. 1600 1601 This is also where warnings about wrong number of args are generated. 1602 1603 Both VALUES and the returned value are chains of TREE_LIST nodes 1604 with the elements of the list in the TREE_VALUE slots of those nodes. */ 1605 1606static tree 1607convert_arguments (typelist, values, name, fundecl) 1608 tree typelist, values, name, fundecl; 1609{ 1610 tree typetail, valtail; 1611 tree result = NULL; 1612 int parmnum; 1613 1614 /* Scan the given expressions and types, producing individual 1615 converted arguments and pushing them on RESULT in reverse order. */ 1616 1617 for (valtail = values, typetail = typelist, parmnum = 0; 1618 valtail; 1619 valtail = TREE_CHAIN (valtail), parmnum++) 1620 { 1621 tree type = typetail ? TREE_VALUE (typetail) : 0; 1622 tree val = TREE_VALUE (valtail); 1623 1624 if (type == void_type_node) 1625 { 1626 if (name) 1627 error ("too many arguments to function `%s'", 1628 IDENTIFIER_POINTER (name)); 1629 else 1630 error ("too many arguments to function"); 1631 break; 1632 } 1633 1634 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 1635 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0 1636 to convert automatically to a pointer. */ 1637 if (TREE_CODE (val) == NON_LVALUE_EXPR) 1638 val = TREE_OPERAND (val, 0); 1639 1640 val = default_function_array_conversion (val); 1641 1642 val = require_complete_type (val); 1643 1644 if (type != 0) 1645 { 1646 /* Formal parm type is specified by a function prototype. */ 1647 tree parmval; 1648 1649 if (!COMPLETE_TYPE_P (type)) 1650 { 1651 error ("type of formal parameter %d is incomplete", parmnum + 1); 1652 parmval = val; 1653 } 1654 else 1655 { 1656 /* Optionally warn about conversions that 1657 differ from the default conversions. */ 1658 if (warn_conversion || warn_traditional) 1659 { 1660 int formal_prec = TYPE_PRECISION (type); 1661 1662 if (INTEGRAL_TYPE_P (type) 1663 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 1664 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1); 1665 if (INTEGRAL_TYPE_P (type) 1666 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 1667 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1); 1668 else if (TREE_CODE (type) == COMPLEX_TYPE 1669 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 1670 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1); 1671 else if (TREE_CODE (type) == REAL_TYPE 1672 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 1673 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1); 1674 else if (TREE_CODE (type) == COMPLEX_TYPE 1675 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 1676 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1); 1677 else if (TREE_CODE (type) == REAL_TYPE 1678 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 1679 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1); 1680 /* ??? At some point, messages should be written about 1681 conversions between complex types, but that's too messy 1682 to do now. */ 1683 else if (TREE_CODE (type) == REAL_TYPE 1684 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 1685 { 1686 /* Warn if any argument is passed as `float', 1687 since without a prototype it would be `double'. */ 1688 if (formal_prec == TYPE_PRECISION (float_type_node)) 1689 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1); 1690 } 1691 /* Detect integer changing in width or signedness. 1692 These warnings are only activated with 1693 -Wconversion, not with -Wtraditional. */ 1694 else if (warn_conversion && INTEGRAL_TYPE_P (type) 1695 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 1696 { 1697 tree would_have_been = default_conversion (val); 1698 tree type1 = TREE_TYPE (would_have_been); 1699 1700 if (TREE_CODE (type) == ENUMERAL_TYPE 1701 && (TYPE_MAIN_VARIANT (type) 1702 == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 1703 /* No warning if function asks for enum 1704 and the actual arg is that enum type. */ 1705 ; 1706 else if (formal_prec != TYPE_PRECISION (type1)) 1707 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1); 1708 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1)) 1709 ; 1710 /* Don't complain if the formal parameter type 1711 is an enum, because we can't tell now whether 1712 the value was an enum--even the same enum. */ 1713 else if (TREE_CODE (type) == ENUMERAL_TYPE) 1714 ; 1715 else if (TREE_CODE (val) == INTEGER_CST 1716 && int_fits_type_p (val, type)) 1717 /* Change in signedness doesn't matter 1718 if a constant value is unaffected. */ 1719 ; 1720 /* Likewise for a constant in a NOP_EXPR. */ 1721 else if (TREE_CODE (val) == NOP_EXPR 1722 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST 1723 && int_fits_type_p (TREE_OPERAND (val, 0), type)) 1724 ; 1725#if 0 /* We never get such tree structure here. */ 1726 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE 1727 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type) 1728 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type)) 1729 /* Change in signedness doesn't matter 1730 if an enum value is unaffected. */ 1731 ; 1732#endif 1733 /* If the value is extended from a narrower 1734 unsigned type, it doesn't matter whether we 1735 pass it as signed or unsigned; the value 1736 certainly is the same either way. */ 1737 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 1738 && TREE_UNSIGNED (TREE_TYPE (val))) 1739 ; 1740 else if (TREE_UNSIGNED (type)) 1741 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1); 1742 else 1743 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1); 1744 } 1745 } 1746 1747 parmval = convert_for_assignment (type, val, 1748 (char *) 0, /* arg passing */ 1749 fundecl, name, parmnum + 1); 1750 1751 if (PROMOTE_PROTOTYPES 1752 && INTEGRAL_TYPE_P (type) 1753 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 1754 parmval = default_conversion (parmval); 1755 } 1756 result = tree_cons (NULL_TREE, parmval, result); 1757 } 1758 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 1759 && (TYPE_PRECISION (TREE_TYPE (val)) 1760 < TYPE_PRECISION (double_type_node))) 1761 /* Convert `float' to `double'. */ 1762 result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 1763 else 1764 /* Convert `short' and `char' to full-size `int'. */ 1765 result = tree_cons (NULL_TREE, default_conversion (val), result); 1766 1767 if (typetail) 1768 typetail = TREE_CHAIN (typetail); 1769 } 1770 1771 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 1772 { 1773 if (name) 1774 error ("too few arguments to function `%s'", 1775 IDENTIFIER_POINTER (name)); 1776 else 1777 error ("too few arguments to function"); 1778 } 1779 1780 return nreverse (result); 1781} 1782 1783/* This is the entry point used by the parser 1784 for binary operators in the input. 1785 In addition to constructing the expression, 1786 we check for operands that were written with other binary operators 1787 in a way that is likely to confuse the user. */ 1788 1789tree 1790parser_build_binary_op (code, arg1, arg2) 1791 enum tree_code code; 1792 tree arg1, arg2; 1793{ 1794 tree result = build_binary_op (code, arg1, arg2, 1); 1795 1796 char class; 1797 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1)); 1798 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2)); 1799 enum tree_code code1 = ERROR_MARK; 1800 enum tree_code code2 = ERROR_MARK; 1801 1802 if (TREE_CODE (result) == ERROR_MARK) 1803 return error_mark_node; 1804 1805 if (IS_EXPR_CODE_CLASS (class1)) 1806 code1 = C_EXP_ORIGINAL_CODE (arg1); 1807 if (IS_EXPR_CODE_CLASS (class2)) 1808 code2 = C_EXP_ORIGINAL_CODE (arg2); 1809 1810 /* Check for cases such as x+y<<z which users are likely 1811 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE 1812 is cleared to prevent these warnings. */ 1813 if (warn_parentheses) 1814 { 1815 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) 1816 { 1817 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 1818 || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 1819 warning ("suggest parentheses around + or - inside shift"); 1820 } 1821 1822 if (code == TRUTH_ORIF_EXPR) 1823 { 1824 if (code1 == TRUTH_ANDIF_EXPR 1825 || code2 == TRUTH_ANDIF_EXPR) 1826 warning ("suggest parentheses around && within ||"); 1827 } 1828 1829 if (code == BIT_IOR_EXPR) 1830 { 1831 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR 1832 || code1 == PLUS_EXPR || code1 == MINUS_EXPR 1833 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR 1834 || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 1835 warning ("suggest parentheses around arithmetic in operand of |"); 1836 /* Check cases like x|y==z */ 1837 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<') 1838 warning ("suggest parentheses around comparison in operand of |"); 1839 } 1840 1841 if (code == BIT_XOR_EXPR) 1842 { 1843 if (code1 == BIT_AND_EXPR 1844 || code1 == PLUS_EXPR || code1 == MINUS_EXPR 1845 || code2 == BIT_AND_EXPR 1846 || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 1847 warning ("suggest parentheses around arithmetic in operand of ^"); 1848 /* Check cases like x^y==z */ 1849 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<') 1850 warning ("suggest parentheses around comparison in operand of ^"); 1851 } 1852 1853 if (code == BIT_AND_EXPR) 1854 { 1855 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 1856 || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 1857 warning ("suggest parentheses around + or - in operand of &"); 1858 /* Check cases like x&y==z */ 1859 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<') 1860 warning ("suggest parentheses around comparison in operand of &"); 1861 } 1862 } 1863 1864 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ 1865 if (TREE_CODE_CLASS (code) == '<' && extra_warnings 1866 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')) 1867 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning"); 1868 1869 unsigned_conversion_warning (result, arg1); 1870 unsigned_conversion_warning (result, arg2); 1871 overflow_warning (result); 1872 1873 class = TREE_CODE_CLASS (TREE_CODE (result)); 1874 1875 /* Record the code that was specified in the source, 1876 for the sake of warnings about confusing nesting. */ 1877 if (IS_EXPR_CODE_CLASS (class)) 1878 C_SET_EXP_ORIGINAL_CODE (result, code); 1879 else 1880 { 1881 int flag = TREE_CONSTANT (result); 1882 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR 1883 so that convert_for_assignment wouldn't strip it. 1884 That way, we got warnings for things like p = (1 - 1). 1885 But it turns out we should not get those warnings. */ 1886 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result); 1887 C_SET_EXP_ORIGINAL_CODE (result, code); 1888 TREE_CONSTANT (result) = flag; 1889 } 1890 1891 return result; 1892} 1893 1894/* Build a binary-operation expression without default conversions. 1895 CODE is the kind of expression to build. 1896 This function differs from `build' in several ways: 1897 the data type of the result is computed and recorded in it, 1898 warnings are generated if arg data types are invalid, 1899 special handling for addition and subtraction of pointers is known, 1900 and some optimization is done (operations on narrow ints 1901 are done in the narrower type when that gives the same result). 1902 Constant folding is also done before the result is returned. 1903 1904 Note that the operands will never have enumeral types, or function 1905 or array types, because either they will have the default conversions 1906 performed or they have both just been converted to some other type in which 1907 the arithmetic is to be done. */ 1908 1909tree 1910build_binary_op (code, orig_op0, orig_op1, convert_p) 1911 enum tree_code code; 1912 tree orig_op0, orig_op1; 1913 int convert_p; 1914{ 1915 tree type0, type1; 1916 enum tree_code code0, code1; 1917 tree op0, op1; 1918 1919 /* Expression code to give to the expression when it is built. 1920 Normally this is CODE, which is what the caller asked for, 1921 but in some special cases we change it. */ 1922 enum tree_code resultcode = code; 1923 1924 /* Data type in which the computation is to be performed. 1925 In the simplest cases this is the common type of the arguments. */ 1926 tree result_type = NULL; 1927 1928 /* Nonzero means operands have already been type-converted 1929 in whatever way is necessary. 1930 Zero means they need to be converted to RESULT_TYPE. */ 1931 int converted = 0; 1932 1933 /* Nonzero means create the expression with this type, rather than 1934 RESULT_TYPE. */ 1935 tree build_type = 0; 1936 1937 /* Nonzero means after finally constructing the expression 1938 convert it to this type. */ 1939 tree final_type = 0; 1940 1941 /* Nonzero if this is an operation like MIN or MAX which can 1942 safely be computed in short if both args are promoted shorts. 1943 Also implies COMMON. 1944 -1 indicates a bitwise operation; this makes a difference 1945 in the exact conditions for when it is safe to do the operation 1946 in a narrower mode. */ 1947 int shorten = 0; 1948 1949 /* Nonzero if this is a comparison operation; 1950 if both args are promoted shorts, compare the original shorts. 1951 Also implies COMMON. */ 1952 int short_compare = 0; 1953 1954 /* Nonzero if this is a right-shift operation, which can be computed on the 1955 original short and then promoted if the operand is a promoted short. */ 1956 int short_shift = 0; 1957 1958 /* Nonzero means set RESULT_TYPE to the common type of the args. */ 1959 int common = 0; 1960 1961 if (convert_p) 1962 { 1963 op0 = default_conversion (orig_op0); 1964 op1 = default_conversion (orig_op1); 1965 } 1966 else 1967 { 1968 op0 = orig_op0; 1969 op1 = orig_op1; 1970 } 1971 1972 type0 = TREE_TYPE (op0); 1973 type1 = TREE_TYPE (op1); 1974 1975 /* The expression codes of the data types of the arguments tell us 1976 whether the arguments are integers, floating, pointers, etc. */ 1977 code0 = TREE_CODE (type0); 1978 code1 = TREE_CODE (type1); 1979 1980 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 1981 STRIP_TYPE_NOPS (op0); 1982 STRIP_TYPE_NOPS (op1); 1983 1984 /* If an error was already reported for one of the arguments, 1985 avoid reporting another error. */ 1986 1987 if (code0 == ERROR_MARK || code1 == ERROR_MARK) 1988 return error_mark_node; 1989 1990 switch (code) 1991 { 1992 case PLUS_EXPR: 1993 /* Handle the pointer + int case. */ 1994 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 1995 return pointer_int_sum (PLUS_EXPR, op0, op1); 1996 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 1997 return pointer_int_sum (PLUS_EXPR, op1, op0); 1998 else 1999 common = 1; 2000 break; 2001 2002 case MINUS_EXPR: 2003 /* Subtraction of two similar pointers. 2004 We must subtract them as integers, then divide by object size. */ 2005 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 2006 && comp_target_types (type0, type1)) 2007 return pointer_diff (op0, op1); 2008 /* Handle pointer minus int. Just like pointer plus int. */ 2009 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 2010 return pointer_int_sum (MINUS_EXPR, op0, op1); 2011 else 2012 common = 1; 2013 break; 2014 2015 case MULT_EXPR: 2016 common = 1; 2017 break; 2018 2019 case TRUNC_DIV_EXPR: 2020 case CEIL_DIV_EXPR: 2021 case FLOOR_DIV_EXPR: 2022 case ROUND_DIV_EXPR: 2023 case EXACT_DIV_EXPR: 2024 /* Floating point division by zero is a legitimate way to obtain 2025 infinities and NaNs. */ 2026 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1)) 2027 warning ("division by zero"); 2028 2029 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 2030 || code0 == COMPLEX_TYPE) 2031 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 2032 || code1 == COMPLEX_TYPE)) 2033 { 2034 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)) 2035 resultcode = RDIV_EXPR; 2036 else 2037 /* Although it would be tempting to shorten always here, that 2038 loses on some targets, since the modulo instruction is 2039 undefined if the quotient can't be represented in the 2040 computation mode. We shorten only if unsigned or if 2041 dividing by something we know != -1. */ 2042 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0)) 2043 || (TREE_CODE (op1) == INTEGER_CST 2044 && ! integer_all_onesp (op1))); 2045 common = 1; 2046 } 2047 break; 2048 2049 case BIT_AND_EXPR: 2050 case BIT_ANDTC_EXPR: 2051 case BIT_IOR_EXPR: 2052 case BIT_XOR_EXPR: 2053 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 2054 shorten = -1; 2055 /* If one operand is a constant, and the other is a short type 2056 that has been converted to an int, 2057 really do the work in the short type and then convert the 2058 result to int. If we are lucky, the constant will be 0 or 1 2059 in the short type, making the entire operation go away. */ 2060 if (TREE_CODE (op0) == INTEGER_CST 2061 && TREE_CODE (op1) == NOP_EXPR 2062 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))) 2063 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0)))) 2064 { 2065 final_type = result_type; 2066 op1 = TREE_OPERAND (op1, 0); 2067 result_type = TREE_TYPE (op1); 2068 } 2069 if (TREE_CODE (op1) == INTEGER_CST 2070 && TREE_CODE (op0) == NOP_EXPR 2071 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))) 2072 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) 2073 { 2074 final_type = result_type; 2075 op0 = TREE_OPERAND (op0, 0); 2076 result_type = TREE_TYPE (op0); 2077 } 2078 break; 2079 2080 case TRUNC_MOD_EXPR: 2081 case FLOOR_MOD_EXPR: 2082 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1)) 2083 warning ("division by zero"); 2084 2085 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 2086 { 2087 /* Although it would be tempting to shorten always here, that loses 2088 on some targets, since the modulo instruction is undefined if the 2089 quotient can't be represented in the computation mode. We shorten 2090 only if unsigned or if dividing by something we know != -1. */ 2091 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0)) 2092 || (TREE_CODE (op1) == INTEGER_CST 2093 && ! integer_all_onesp (op1))); 2094 common = 1; 2095 } 2096 break; 2097 2098 case TRUTH_ANDIF_EXPR: 2099 case TRUTH_ORIF_EXPR: 2100 case TRUTH_AND_EXPR: 2101 case TRUTH_OR_EXPR: 2102 case TRUTH_XOR_EXPR: 2103 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 2104 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 2105 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 2106 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 2107 { 2108 /* Result of these operations is always an int, 2109 but that does not mean the operands should be 2110 converted to ints! */ 2111 result_type = integer_type_node; 2112 op0 = truthvalue_conversion (op0); 2113 op1 = truthvalue_conversion (op1); 2114 converted = 1; 2115 } 2116 break; 2117 2118 /* Shift operations: result has same type as first operand; 2119 always convert second operand to int. 2120 Also set SHORT_SHIFT if shifting rightward. */ 2121 2122 case RSHIFT_EXPR: 2123 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 2124 { 2125 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 2126 { 2127 if (tree_int_cst_sgn (op1) < 0) 2128 warning ("right shift count is negative"); 2129 else 2130 { 2131 if (! integer_zerop (op1)) 2132 short_shift = 1; 2133 2134 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 2135 warning ("right shift count >= width of type"); 2136 } 2137 } 2138 2139 /* Use the type of the value to be shifted. 2140 This is what most traditional C compilers do. */ 2141 result_type = type0; 2142 /* Unless traditional, convert the shift-count to an integer, 2143 regardless of size of value being shifted. */ 2144 if (! flag_traditional) 2145 { 2146 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 2147 op1 = convert (integer_type_node, op1); 2148 /* Avoid converting op1 to result_type later. */ 2149 converted = 1; 2150 } 2151 } 2152 break; 2153 2154 case LSHIFT_EXPR: 2155 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 2156 { 2157 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 2158 { 2159 if (tree_int_cst_sgn (op1) < 0) 2160 warning ("left shift count is negative"); 2161 2162 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 2163 warning ("left shift count >= width of type"); 2164 } 2165 2166 /* Use the type of the value to be shifted. 2167 This is what most traditional C compilers do. */ 2168 result_type = type0; 2169 /* Unless traditional, convert the shift-count to an integer, 2170 regardless of size of value being shifted. */ 2171 if (! flag_traditional) 2172 { 2173 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 2174 op1 = convert (integer_type_node, op1); 2175 /* Avoid converting op1 to result_type later. */ 2176 converted = 1; 2177 } 2178 } 2179 break; 2180 2181 case RROTATE_EXPR: 2182 case LROTATE_EXPR: 2183 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 2184 { 2185 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 2186 { 2187 if (tree_int_cst_sgn (op1) < 0) 2188 warning ("shift count is negative"); 2189 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 2190 warning ("shift count >= width of type"); 2191 } 2192 2193 /* Use the type of the value to be shifted. 2194 This is what most traditional C compilers do. */ 2195 result_type = type0; 2196 /* Unless traditional, convert the shift-count to an integer, 2197 regardless of size of value being shifted. */ 2198 if (! flag_traditional) 2199 { 2200 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 2201 op1 = convert (integer_type_node, op1); 2202 /* Avoid converting op1 to result_type later. */ 2203 converted = 1; 2204 } 2205 } 2206 break; 2207 2208 case EQ_EXPR: 2209 case NE_EXPR: 2210 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE)) 2211 warning ("comparing floating point with == or != is unsafe"); 2212 /* Result of comparison is always int, 2213 but don't convert the args to int! */ 2214 build_type = integer_type_node; 2215 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 2216 || code0 == COMPLEX_TYPE) 2217 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 2218 || code1 == COMPLEX_TYPE)) 2219 short_compare = 1; 2220 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 2221 { 2222 tree tt0 = TREE_TYPE (type0); 2223 tree tt1 = TREE_TYPE (type1); 2224 /* Anything compares with void *. void * compares with anything. 2225 Otherwise, the targets must be compatible 2226 and both must be object or both incomplete. */ 2227 if (comp_target_types (type0, type1)) 2228 result_type = common_type (type0, type1); 2229 else if (VOID_TYPE_P (tt0)) 2230 { 2231 /* op0 != orig_op0 detects the case of something 2232 whose value is 0 but which isn't a valid null ptr const. */ 2233 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0) 2234 && TREE_CODE (tt1) == FUNCTION_TYPE) 2235 pedwarn ("ISO C forbids comparison of `void *' with function pointer"); 2236 } 2237 else if (VOID_TYPE_P (tt1)) 2238 { 2239 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1) 2240 && TREE_CODE (tt0) == FUNCTION_TYPE) 2241 pedwarn ("ISO C forbids comparison of `void *' with function pointer"); 2242 } 2243 else 2244 pedwarn ("comparison of distinct pointer types lacks a cast"); 2245 2246 if (result_type == NULL_TREE) 2247 result_type = ptr_type_node; 2248 } 2249 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST 2250 && integer_zerop (op1)) 2251 result_type = type0; 2252 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST 2253 && integer_zerop (op0)) 2254 result_type = type1; 2255 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 2256 { 2257 result_type = type0; 2258 if (! flag_traditional) 2259 pedwarn ("comparison between pointer and integer"); 2260 } 2261 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 2262 { 2263 result_type = type1; 2264 if (! flag_traditional) 2265 pedwarn ("comparison between pointer and integer"); 2266 } 2267 break; 2268 2269 case MAX_EXPR: 2270 case MIN_EXPR: 2271 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 2272 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 2273 shorten = 1; 2274 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 2275 { 2276 if (comp_target_types (type0, type1)) 2277 { 2278 result_type = common_type (type0, type1); 2279 if (pedantic 2280 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 2281 pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 2282 } 2283 else 2284 { 2285 result_type = ptr_type_node; 2286 pedwarn ("comparison of distinct pointer types lacks a cast"); 2287 } 2288 } 2289 break; 2290 2291 case LE_EXPR: 2292 case GE_EXPR: 2293 case LT_EXPR: 2294 case GT_EXPR: 2295 build_type = integer_type_node; 2296 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 2297 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 2298 short_compare = 1; 2299 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 2300 { 2301 if (comp_target_types (type0, type1)) 2302 { 2303 result_type = common_type (type0, type1); 2304 if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 2305 != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 2306 pedwarn ("comparison of complete and incomplete pointers"); 2307 else if (pedantic 2308 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 2309 pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 2310 } 2311 else 2312 { 2313 result_type = ptr_type_node; 2314 pedwarn ("comparison of distinct pointer types lacks a cast"); 2315 } 2316 } 2317 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST 2318 && integer_zerop (op1)) 2319 { 2320 result_type = type0; 2321 if (pedantic || extra_warnings) 2322 pedwarn ("ordered comparison of pointer with integer zero"); 2323 } 2324 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST 2325 && integer_zerop (op0)) 2326 { 2327 result_type = type1; 2328 if (pedantic) 2329 pedwarn ("ordered comparison of pointer with integer zero"); 2330 } 2331 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 2332 { 2333 result_type = type0; 2334 if (! flag_traditional) 2335 pedwarn ("comparison between pointer and integer"); 2336 } 2337 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 2338 { 2339 result_type = type1; 2340 if (! flag_traditional) 2341 pedwarn ("comparison between pointer and integer"); 2342 } 2343 break; 2344 2345 case UNORDERED_EXPR: 2346 case ORDERED_EXPR: 2347 case UNLT_EXPR: 2348 case UNLE_EXPR: 2349 case UNGT_EXPR: 2350 case UNGE_EXPR: 2351 case UNEQ_EXPR: 2352 build_type = integer_type_node; 2353 if (code0 != REAL_TYPE || code1 != REAL_TYPE) 2354 { 2355 error ("unordered comparison on non-floating point argument"); 2356 return error_mark_node; 2357 } 2358 common = 1; 2359 break; 2360 2361 default: 2362 break; 2363 } 2364 2365 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 2366 && 2367 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 2368 { 2369 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 2370 2371 if (shorten || common || short_compare) 2372 result_type = common_type (type0, type1); 2373 2374 /* For certain operations (which identify themselves by shorten != 0) 2375 if both args were extended from the same smaller type, 2376 do the arithmetic in that type and then extend. 2377 2378 shorten !=0 and !=1 indicates a bitwise operation. 2379 For them, this optimization is safe only if 2380 both args are zero-extended or both are sign-extended. 2381 Otherwise, we might change the result. 2382 Eg, (short)-1 | (unsigned short)-1 is (int)-1 2383 but calculated in (unsigned short) it would be (unsigned short)-1. */ 2384 2385 if (shorten && none_complex) 2386 { 2387 int unsigned0, unsigned1; 2388 tree arg0 = get_narrower (op0, &unsigned0); 2389 tree arg1 = get_narrower (op1, &unsigned1); 2390 /* UNS is 1 if the operation to be done is an unsigned one. */ 2391 int uns = TREE_UNSIGNED (result_type); 2392 tree type; 2393 2394 final_type = result_type; 2395 2396 /* Handle the case that OP0 (or OP1) does not *contain* a conversion 2397 but it *requires* conversion to FINAL_TYPE. */ 2398 2399 if ((TYPE_PRECISION (TREE_TYPE (op0)) 2400 == TYPE_PRECISION (TREE_TYPE (arg0))) 2401 && TREE_TYPE (op0) != final_type) 2402 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0)); 2403 if ((TYPE_PRECISION (TREE_TYPE (op1)) 2404 == TYPE_PRECISION (TREE_TYPE (arg1))) 2405 && TREE_TYPE (op1) != final_type) 2406 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1)); 2407 2408 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 2409 2410 /* For bitwise operations, signedness of nominal type 2411 does not matter. Consider only how operands were extended. */ 2412 if (shorten == -1) 2413 uns = unsigned0; 2414 2415 /* Note that in all three cases below we refrain from optimizing 2416 an unsigned operation on sign-extended args. 2417 That would not be valid. */ 2418 2419 /* Both args variable: if both extended in same way 2420 from same width, do it in that width. 2421 Do it unsigned if args were zero-extended. */ 2422 if ((TYPE_PRECISION (TREE_TYPE (arg0)) 2423 < TYPE_PRECISION (result_type)) 2424 && (TYPE_PRECISION (TREE_TYPE (arg1)) 2425 == TYPE_PRECISION (TREE_TYPE (arg0))) 2426 && unsigned0 == unsigned1 2427 && (unsigned0 || !uns)) 2428 result_type 2429 = signed_or_unsigned_type (unsigned0, 2430 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 2431 else if (TREE_CODE (arg0) == INTEGER_CST 2432 && (unsigned1 || !uns) 2433 && (TYPE_PRECISION (TREE_TYPE (arg1)) 2434 < TYPE_PRECISION (result_type)) 2435 && (type = signed_or_unsigned_type (unsigned1, 2436 TREE_TYPE (arg1)), 2437 int_fits_type_p (arg0, type))) 2438 result_type = type; 2439 else if (TREE_CODE (arg1) == INTEGER_CST 2440 && (unsigned0 || !uns) 2441 && (TYPE_PRECISION (TREE_TYPE (arg0)) 2442 < TYPE_PRECISION (result_type)) 2443 && (type = signed_or_unsigned_type (unsigned0, 2444 TREE_TYPE (arg0)), 2445 int_fits_type_p (arg1, type))) 2446 result_type = type; 2447 } 2448 2449 /* Shifts can be shortened if shifting right. */ 2450 2451 if (short_shift) 2452 { 2453 int unsigned_arg; 2454 tree arg0 = get_narrower (op0, &unsigned_arg); 2455 2456 final_type = result_type; 2457 2458 if (arg0 == op0 && final_type == TREE_TYPE (op0)) 2459 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0)); 2460 2461 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 2462 /* We can shorten only if the shift count is less than the 2463 number of bits in the smaller type size. */ 2464 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 2465 /* We cannot drop an unsigned shift after sign-extension. */ 2466 && (!TREE_UNSIGNED (final_type) || unsigned_arg)) 2467 { 2468 /* Do an unsigned shift if the operand was zero-extended. */ 2469 result_type 2470 = signed_or_unsigned_type (unsigned_arg, TREE_TYPE (arg0)); 2471 /* Convert value-to-be-shifted to that type. */ 2472 if (TREE_TYPE (op0) != result_type) 2473 op0 = convert (result_type, op0); 2474 converted = 1; 2475 } 2476 } 2477 2478 /* Comparison operations are shortened too but differently. 2479 They identify themselves by setting short_compare = 1. */ 2480 2481 if (short_compare) 2482 { 2483 /* Don't write &op0, etc., because that would prevent op0 2484 from being kept in a register. 2485 Instead, make copies of the our local variables and 2486 pass the copies by reference, then copy them back afterward. */ 2487 tree xop0 = op0, xop1 = op1, xresult_type = result_type; 2488 enum tree_code xresultcode = resultcode; 2489 tree val 2490 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 2491 2492 if (val != 0) 2493 return val; 2494 2495 op0 = xop0, op1 = xop1; 2496 converted = 1; 2497 resultcode = xresultcode; 2498 2499 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0) 2500 && skip_evaluation == 0) 2501 { 2502 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0)); 2503 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1)); 2504 int unsignedp0, unsignedp1; 2505 tree primop0 = get_narrower (op0, &unsignedp0); 2506 tree primop1 = get_narrower (op1, &unsignedp1); 2507 2508 xop0 = orig_op0; 2509 xop1 = orig_op1; 2510 STRIP_TYPE_NOPS (xop0); 2511 STRIP_TYPE_NOPS (xop1); 2512 2513 /* Give warnings for comparisons between signed and unsigned 2514 quantities that may fail. 2515 2516 Do the checking based on the original operand trees, so that 2517 casts will be considered, but default promotions won't be. 2518 2519 Do not warn if the comparison is being done in a signed type, 2520 since the signed type will only be chosen if it can represent 2521 all the values of the unsigned type. */ 2522 if (! TREE_UNSIGNED (result_type)) 2523 /* OK */; 2524 /* Do not warn if both operands are the same signedness. */ 2525 else if (op0_signed == op1_signed) 2526 /* OK */; 2527 else 2528 { 2529 tree sop, uop; 2530 2531 if (op0_signed) 2532 sop = xop0, uop = xop1; 2533 else 2534 sop = xop1, uop = xop0; 2535 2536 /* Do not warn if the signed quantity is an 2537 unsuffixed integer literal (or some static 2538 constant expression involving such literals or a 2539 conditional expression involving such literals) 2540 and it is non-negative. */ 2541 if (tree_expr_nonnegative_p (sop)) 2542 /* OK */; 2543 /* Do not warn if the comparison is an equality operation, 2544 the unsigned quantity is an integral constant, and it 2545 would fit in the result if the result were signed. */ 2546 else if (TREE_CODE (uop) == INTEGER_CST 2547 && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 2548 && int_fits_type_p (uop, signed_type (result_type))) 2549 /* OK */; 2550 /* Do not warn if the unsigned quantity is an enumeration 2551 constant and its maximum value would fit in the result 2552 if the result were signed. */ 2553 else if (TREE_CODE (uop) == INTEGER_CST 2554 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 2555 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE(uop)), 2556 signed_type (result_type))) 2557 /* OK */; 2558 else 2559 warning ("comparison between signed and unsigned"); 2560 } 2561 2562 /* Warn if two unsigned values are being compared in a size 2563 larger than their original size, and one (and only one) is the 2564 result of a `~' operator. This comparison will always fail. 2565 2566 Also warn if one operand is a constant, and the constant 2567 does not have all bits set that are set in the ~ operand 2568 when it is extended. */ 2569 2570 if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 2571 != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 2572 { 2573 if (TREE_CODE (primop0) == BIT_NOT_EXPR) 2574 primop0 = get_narrower (TREE_OPERAND (primop0, 0), 2575 &unsignedp0); 2576 else 2577 primop1 = get_narrower (TREE_OPERAND (primop1, 0), 2578 &unsignedp1); 2579 2580 if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 2581 { 2582 tree primop; 2583 HOST_WIDE_INT constant, mask; 2584 int unsignedp, bits; 2585 2586 if (host_integerp (primop0, 0)) 2587 { 2588 primop = primop1; 2589 unsignedp = unsignedp1; 2590 constant = tree_low_cst (primop0, 0); 2591 } 2592 else 2593 { 2594 primop = primop0; 2595 unsignedp = unsignedp0; 2596 constant = tree_low_cst (primop1, 0); 2597 } 2598 2599 bits = TYPE_PRECISION (TREE_TYPE (primop)); 2600 if (bits < TYPE_PRECISION (result_type) 2601 && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 2602 { 2603 mask = (~ (HOST_WIDE_INT) 0) << bits; 2604 if ((mask & constant) != mask) 2605 warning ("comparison of promoted ~unsigned with constant"); 2606 } 2607 } 2608 else if (unsignedp0 && unsignedp1 2609 && (TYPE_PRECISION (TREE_TYPE (primop0)) 2610 < TYPE_PRECISION (result_type)) 2611 && (TYPE_PRECISION (TREE_TYPE (primop1)) 2612 < TYPE_PRECISION (result_type))) 2613 warning ("comparison of promoted ~unsigned with unsigned"); 2614 } 2615 } 2616 } 2617 } 2618 2619 /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 2620 If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 2621 Then the expression will be built. 2622 It will be given type FINAL_TYPE if that is nonzero; 2623 otherwise, it will be given type RESULT_TYPE. */ 2624 2625 if (!result_type) 2626 { 2627 binary_op_error (code); 2628 return error_mark_node; 2629 } 2630 2631 if (! converted) 2632 { 2633 if (TREE_TYPE (op0) != result_type) 2634 op0 = convert (result_type, op0); 2635 if (TREE_TYPE (op1) != result_type) 2636 op1 = convert (result_type, op1); 2637 } 2638 2639 if (build_type == NULL_TREE) 2640 build_type = result_type; 2641 2642 { 2643 tree result = build (resultcode, build_type, op0, op1); 2644 tree folded; 2645 2646 folded = fold (result); 2647 if (folded == result) 2648 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1); 2649 if (final_type != 0) 2650 return convert (final_type, folded); 2651 return folded; 2652 } 2653} 2654 2655/* Return a tree for the sum or difference (RESULTCODE says which) 2656 of pointer PTROP and integer INTOP. */ 2657 2658static tree 2659pointer_int_sum (resultcode, ptrop, intop) 2660 enum tree_code resultcode; 2661 tree ptrop, intop; 2662{ 2663 tree size_exp; 2664 2665 tree result; 2666 tree folded; 2667 2668 /* The result is a pointer of the same type that is being added. */ 2669 2670 tree result_type = TREE_TYPE (ptrop); 2671 2672 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) 2673 { 2674 if (pedantic || warn_pointer_arith) 2675 pedwarn ("pointer of type `void *' used in arithmetic"); 2676 size_exp = integer_one_node; 2677 } 2678 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) 2679 { 2680 if (pedantic || warn_pointer_arith) 2681 pedwarn ("pointer to a function used in arithmetic"); 2682 size_exp = integer_one_node; 2683 } 2684 else 2685 size_exp = c_size_in_bytes (TREE_TYPE (result_type)); 2686 2687 /* If what we are about to multiply by the size of the elements 2688 contains a constant term, apply distributive law 2689 and multiply that constant term separately. 2690 This helps produce common subexpressions. */ 2691 2692 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR) 2693 && ! TREE_CONSTANT (intop) 2694 && TREE_CONSTANT (TREE_OPERAND (intop, 1)) 2695 && TREE_CONSTANT (size_exp) 2696 /* If the constant comes from pointer subtraction, 2697 skip this optimization--it would cause an error. */ 2698 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE 2699 /* If the constant is unsigned, and smaller than the pointer size, 2700 then we must skip this optimization. This is because it could cause 2701 an overflow error if the constant is negative but INTOP is not. */ 2702 && (! TREE_UNSIGNED (TREE_TYPE (intop)) 2703 || (TYPE_PRECISION (TREE_TYPE (intop)) 2704 == TYPE_PRECISION (TREE_TYPE (ptrop))))) 2705 { 2706 enum tree_code subcode = resultcode; 2707 tree int_type = TREE_TYPE (intop); 2708 if (TREE_CODE (intop) == MINUS_EXPR) 2709 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR); 2710 /* Convert both subexpression types to the type of intop, 2711 because weird cases involving pointer arithmetic 2712 can result in a sum or difference with different type args. */ 2713 ptrop = build_binary_op (subcode, ptrop, 2714 convert (int_type, TREE_OPERAND (intop, 1)), 1); 2715 intop = convert (int_type, TREE_OPERAND (intop, 0)); 2716 } 2717 2718 /* Convert the integer argument to a type the same size as sizetype 2719 so the multiply won't overflow spuriously. */ 2720 2721 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype) 2722 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype)) 2723 intop = convert (type_for_size (TYPE_PRECISION (sizetype), 2724 TREE_UNSIGNED (sizetype)), intop); 2725 2726 /* Replace the integer argument with a suitable product by the object size. 2727 Do this multiplication as signed, then convert to the appropriate 2728 pointer type (actually unsigned integral). */ 2729 2730 intop = convert (result_type, 2731 build_binary_op (MULT_EXPR, intop, 2732 convert (TREE_TYPE (intop), size_exp), 1)); 2733 2734 /* Create the sum or difference. */ 2735 2736 result = build (resultcode, result_type, ptrop, intop); 2737 2738 folded = fold (result); 2739 if (folded == result) 2740 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop); 2741 return folded; 2742} 2743 2744/* Return a tree for the difference of pointers OP0 and OP1. 2745 The resulting tree has type int. */ 2746 2747static tree 2748pointer_diff (op0, op1) 2749 tree op0, op1; 2750{ 2751 tree result, folded; 2752 tree restype = ptrdiff_type_node; 2753 2754 tree target_type = TREE_TYPE (TREE_TYPE (op0)); 2755 tree con0, con1, lit0, lit1; 2756 tree orig_op1 = op1; 2757 2758 if (pedantic || warn_pointer_arith) 2759 { 2760 if (TREE_CODE (target_type) == VOID_TYPE) 2761 pedwarn ("pointer of type `void *' used in subtraction"); 2762 if (TREE_CODE (target_type) == FUNCTION_TYPE) 2763 pedwarn ("pointer to a function used in subtraction"); 2764 } 2765 2766 /* If the conversion to ptrdiff_type does anything like widening or 2767 converting a partial to an integral mode, we get a convert_expression 2768 that is in the way to do any simplifications. 2769 (fold-const.c doesn't know that the extra bits won't be needed. 2770 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 2771 different mode in place.) 2772 So first try to find a common term here 'by hand'; we want to cover 2773 at least the cases that occur in legal static initializers. */ 2774 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0; 2775 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1; 2776 2777 if (TREE_CODE (con0) == PLUS_EXPR) 2778 { 2779 lit0 = TREE_OPERAND (con0, 1); 2780 con0 = TREE_OPERAND (con0, 0); 2781 } 2782 else 2783 lit0 = integer_zero_node; 2784 2785 if (TREE_CODE (con1) == PLUS_EXPR) 2786 { 2787 lit1 = TREE_OPERAND (con1, 1); 2788 con1 = TREE_OPERAND (con1, 0); 2789 } 2790 else 2791 lit1 = integer_zero_node; 2792 2793 if (operand_equal_p (con0, con1, 0)) 2794 { 2795 op0 = lit0; 2796 op1 = lit1; 2797 } 2798 2799 2800 /* First do the subtraction as integers; 2801 then drop through to build the divide operator. 2802 Do not do default conversions on the minus operator 2803 in case restype is a short type. */ 2804 2805 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 2806 convert (restype, op1), 0); 2807 /* This generates an error if op1 is pointer to incomplete type. */ 2808 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 2809 error ("arithmetic on pointer to an incomplete type"); 2810 2811 /* This generates an error if op0 is pointer to incomplete type. */ 2812 op1 = c_size_in_bytes (target_type); 2813 2814 /* Divide by the size, in easiest possible way. */ 2815 2816 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 2817 2818 folded = fold (result); 2819 if (folded == result) 2820 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1); 2821 return folded; 2822} 2823 2824/* Construct and perhaps optimize a tree representation 2825 for a unary operation. CODE, a tree_code, specifies the operation 2826 and XARG is the operand. 2827 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 2828 the default promotions (such as from short to int). 2829 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 2830 allows non-lvalues; this is only used to handle conversion of non-lvalue 2831 arrays to pointers in C99. */ 2832 2833tree 2834build_unary_op (code, xarg, flag) 2835 enum tree_code code; 2836 tree xarg; 2837 int flag; 2838{ 2839 /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 2840 tree arg = xarg; 2841 tree argtype = 0; 2842 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 2843 tree val; 2844 int noconvert = flag; 2845 2846 if (typecode == ERROR_MARK) 2847 return error_mark_node; 2848 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 2849 typecode = INTEGER_TYPE; 2850 2851 switch (code) 2852 { 2853 case CONVERT_EXPR: 2854 /* This is used for unary plus, because a CONVERT_EXPR 2855 is enough to prevent anybody from looking inside for 2856 associativity, but won't generate any code. */ 2857 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2858 || typecode == COMPLEX_TYPE)) 2859 { 2860 error ("wrong type argument to unary plus"); 2861 return error_mark_node; 2862 } 2863 else if (!noconvert) 2864 arg = default_conversion (arg); 2865 break; 2866 2867 case NEGATE_EXPR: 2868 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2869 || typecode == COMPLEX_TYPE)) 2870 { 2871 error ("wrong type argument to unary minus"); 2872 return error_mark_node; 2873 } 2874 else if (!noconvert) 2875 arg = default_conversion (arg); 2876 break; 2877 2878 case BIT_NOT_EXPR: 2879 if (typecode == COMPLEX_TYPE) 2880 { 2881 code = CONJ_EXPR; 2882 if (pedantic) 2883 pedwarn ("ISO C does not support `~' for complex conjugation"); 2884 if (!noconvert) 2885 arg = default_conversion (arg); 2886 } 2887 else if (typecode != INTEGER_TYPE) 2888 { 2889 error ("wrong type argument to bit-complement"); 2890 return error_mark_node; 2891 } 2892 else if (!noconvert) 2893 arg = default_conversion (arg); 2894 break; 2895 2896 case ABS_EXPR: 2897 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2898 || typecode == COMPLEX_TYPE)) 2899 { 2900 error ("wrong type argument to abs"); 2901 return error_mark_node; 2902 } 2903 else if (!noconvert) 2904 arg = default_conversion (arg); 2905 break; 2906 2907 case CONJ_EXPR: 2908 /* Conjugating a real value is a no-op, but allow it anyway. */ 2909 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2910 || typecode == COMPLEX_TYPE)) 2911 { 2912 error ("wrong type argument to conjugation"); 2913 return error_mark_node; 2914 } 2915 else if (!noconvert) 2916 arg = default_conversion (arg); 2917 break; 2918 2919 case TRUTH_NOT_EXPR: 2920 if (typecode != INTEGER_TYPE 2921 && typecode != REAL_TYPE && typecode != POINTER_TYPE 2922 && typecode != COMPLEX_TYPE 2923 /* These will convert to a pointer. */ 2924 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE) 2925 { 2926 error ("wrong type argument to unary exclamation mark"); 2927 return error_mark_node; 2928 } 2929 arg = truthvalue_conversion (arg); 2930 return invert_truthvalue (arg); 2931 2932 case NOP_EXPR: 2933 break; 2934 2935 case REALPART_EXPR: 2936 if (TREE_CODE (arg) == COMPLEX_CST) 2937 return TREE_REALPART (arg); 2938 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2939 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg)); 2940 else 2941 return arg; 2942 2943 case IMAGPART_EXPR: 2944 if (TREE_CODE (arg) == COMPLEX_CST) 2945 return TREE_IMAGPART (arg); 2946 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2947 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg)); 2948 else 2949 return convert (TREE_TYPE (arg), integer_zero_node); 2950 2951 case PREINCREMENT_EXPR: 2952 case POSTINCREMENT_EXPR: 2953 case PREDECREMENT_EXPR: 2954 case POSTDECREMENT_EXPR: 2955 /* Handle complex lvalues (when permitted) 2956 by reduction to simpler cases. */ 2957 2958 val = unary_complex_lvalue (code, arg, 0); 2959 if (val != 0) 2960 return val; 2961 2962 /* Increment or decrement the real part of the value, 2963 and don't change the imaginary part. */ 2964 if (typecode == COMPLEX_TYPE) 2965 { 2966 tree real, imag; 2967 2968 if (pedantic) 2969 pedwarn ("ISO C does not support `++' and `--' on complex types"); 2970 2971 arg = stabilize_reference (arg); 2972 real = build_unary_op (REALPART_EXPR, arg, 1); 2973 imag = build_unary_op (IMAGPART_EXPR, arg, 1); 2974 return build (COMPLEX_EXPR, TREE_TYPE (arg), 2975 build_unary_op (code, real, 1), imag); 2976 } 2977 2978 /* Report invalid types. */ 2979 2980 if (typecode != POINTER_TYPE 2981 && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 2982 { 2983 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 2984 error ("wrong type argument to increment"); 2985 else 2986 error ("wrong type argument to decrement"); 2987 2988 return error_mark_node; 2989 } 2990 2991 { 2992 tree inc; 2993 tree result_type = TREE_TYPE (arg); 2994 2995 arg = get_unwidened (arg, 0); 2996 argtype = TREE_TYPE (arg); 2997 2998 /* Compute the increment. */ 2999 3000 if (typecode == POINTER_TYPE) 3001 { 3002 /* If pointer target is an undefined struct, 3003 we just cannot know how to do the arithmetic. */ 3004 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 3005 { 3006 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3007 error ("increment of pointer to unknown structure"); 3008 else 3009 error ("decrement of pointer to unknown structure"); 3010 } 3011 else if ((pedantic || warn_pointer_arith) 3012 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 3013 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 3014 { 3015 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3016 pedwarn ("wrong type argument to increment"); 3017 else 3018 pedwarn ("wrong type argument to decrement"); 3019 } 3020 3021 inc = c_size_in_bytes (TREE_TYPE (result_type)); 3022 } 3023 else 3024 inc = integer_one_node; 3025 3026 inc = convert (argtype, inc); 3027 3028 /* Handle incrementing a cast-expression. */ 3029 3030 while (1) 3031 switch (TREE_CODE (arg)) 3032 { 3033 case NOP_EXPR: 3034 case CONVERT_EXPR: 3035 case FLOAT_EXPR: 3036 case FIX_TRUNC_EXPR: 3037 case FIX_FLOOR_EXPR: 3038 case FIX_ROUND_EXPR: 3039 case FIX_CEIL_EXPR: 3040 pedantic_lvalue_warning (CONVERT_EXPR); 3041 /* If the real type has the same machine representation 3042 as the type it is cast to, we can make better output 3043 by adding directly to the inside of the cast. */ 3044 if ((TREE_CODE (TREE_TYPE (arg)) 3045 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3046 && (TYPE_MODE (TREE_TYPE (arg)) 3047 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0))))) 3048 arg = TREE_OPERAND (arg, 0); 3049 else 3050 { 3051 tree incremented, modify, value; 3052 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 3053 value = boolean_increment (code, arg); 3054 else 3055 { 3056 arg = stabilize_reference (arg); 3057 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR) 3058 value = arg; 3059 else 3060 value = save_expr (arg); 3061 incremented = build (((code == PREINCREMENT_EXPR 3062 || code == POSTINCREMENT_EXPR) 3063 ? PLUS_EXPR : MINUS_EXPR), 3064 argtype, value, inc); 3065 TREE_SIDE_EFFECTS (incremented) = 1; 3066 modify = build_modify_expr (arg, NOP_EXPR, incremented); 3067 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value); 3068 } 3069 TREE_USED (value) = 1; 3070 return value; 3071 } 3072 break; 3073 3074 default: 3075 goto give_up; 3076 } 3077 give_up: 3078 3079 /* Complain about anything else that is not a true lvalue. */ 3080 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 3081 || code == POSTINCREMENT_EXPR) 3082 ? "invalid lvalue in increment" 3083 : "invalid lvalue in decrement"))) 3084 return error_mark_node; 3085 3086 /* Report a read-only lvalue. */ 3087 if (TREE_READONLY (arg)) 3088 readonly_warning (arg, 3089 ((code == PREINCREMENT_EXPR 3090 || code == POSTINCREMENT_EXPR) 3091 ? "increment" : "decrement")); 3092 3093 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 3094 val = boolean_increment (code, arg); 3095 else 3096 val = build (code, TREE_TYPE (arg), arg, inc); 3097 TREE_SIDE_EFFECTS (val) = 1; 3098 val = convert (result_type, val); 3099 if (TREE_CODE (val) != code) 3100 TREE_NO_UNUSED_WARNING (val) = 1; 3101 return val; 3102 } 3103 3104 case ADDR_EXPR: 3105 /* Note that this operation never does default_conversion. */ 3106 3107 /* Let &* cancel out to simplify resulting code. */ 3108 if (TREE_CODE (arg) == INDIRECT_REF) 3109 { 3110 /* Don't let this be an lvalue. */ 3111 if (lvalue_p (TREE_OPERAND (arg, 0))) 3112 return non_lvalue (TREE_OPERAND (arg, 0)); 3113 return TREE_OPERAND (arg, 0); 3114 } 3115 3116 /* For &x[y], return x+y */ 3117 if (TREE_CODE (arg) == ARRAY_REF) 3118 { 3119 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0) 3120 return error_mark_node; 3121 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0), 3122 TREE_OPERAND (arg, 1), 1); 3123 } 3124 3125 /* Handle complex lvalues (when permitted) 3126 by reduction to simpler cases. */ 3127 val = unary_complex_lvalue (code, arg, flag); 3128 if (val != 0) 3129 return val; 3130 3131#if 0 /* Turned off because inconsistent; 3132 float f; *&(int)f = 3.4 stores in int format 3133 whereas (int)f = 3.4 stores in float format. */ 3134 /* Address of a cast is just a cast of the address 3135 of the operand of the cast. */ 3136 switch (TREE_CODE (arg)) 3137 { 3138 case NOP_EXPR: 3139 case CONVERT_EXPR: 3140 case FLOAT_EXPR: 3141 case FIX_TRUNC_EXPR: 3142 case FIX_FLOOR_EXPR: 3143 case FIX_ROUND_EXPR: 3144 case FIX_CEIL_EXPR: 3145 if (pedantic) 3146 pedwarn ("ISO C forbids the address of a cast expression"); 3147 return convert (build_pointer_type (TREE_TYPE (arg)), 3148 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 3149 0)); 3150 } 3151#endif 3152 3153 /* Anything not already handled and not a true memory reference 3154 or a non-lvalue array is an error. */ 3155 else if (typecode != FUNCTION_TYPE && !flag 3156 && !lvalue_or_else (arg, "invalid lvalue in unary `&'")) 3157 return error_mark_node; 3158 3159 /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 3160 argtype = TREE_TYPE (arg); 3161 3162 /* If the lvalue is const or volatile, merge that into the type 3163 to which the address will point. Note that you can't get a 3164 restricted pointer by taking the address of something, so we 3165 only have to deal with `const' and `volatile' here. */ 3166 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r') 3167 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 3168 argtype = c_build_type_variant (argtype, 3169 TREE_READONLY (arg), 3170 TREE_THIS_VOLATILE (arg)); 3171 3172 argtype = build_pointer_type (argtype); 3173 3174 if (mark_addressable (arg) == 0) 3175 return error_mark_node; 3176 3177 { 3178 tree addr; 3179 3180 if (TREE_CODE (arg) == COMPONENT_REF) 3181 { 3182 tree field = TREE_OPERAND (arg, 1); 3183 3184 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag); 3185 3186 if (DECL_C_BIT_FIELD (field)) 3187 { 3188 error ("attempt to take address of bit-field structure member `%s'", 3189 IDENTIFIER_POINTER (DECL_NAME (field))); 3190 return error_mark_node; 3191 } 3192 3193 addr = fold (build (PLUS_EXPR, argtype, 3194 convert (argtype, addr), 3195 convert (argtype, byte_position (field)))); 3196 } 3197 else 3198 addr = build1 (code, argtype, arg); 3199 3200 /* Address of a static or external variable or 3201 file-scope function counts as a constant. */ 3202 if (staticp (arg) 3203 && ! (TREE_CODE (arg) == FUNCTION_DECL 3204 && DECL_CONTEXT (arg) != 0)) 3205 TREE_CONSTANT (addr) = 1; 3206 return addr; 3207 } 3208 3209 default: 3210 break; 3211 } 3212 3213 if (argtype == 0) 3214 argtype = TREE_TYPE (arg); 3215 return fold (build1 (code, argtype, arg)); 3216} 3217 3218#if 0 3219/* If CONVERSIONS is a conversion expression or a nested sequence of such, 3220 convert ARG with the same conversions in the same order 3221 and return the result. */ 3222 3223static tree 3224convert_sequence (conversions, arg) 3225 tree conversions; 3226 tree arg; 3227{ 3228 switch (TREE_CODE (conversions)) 3229 { 3230 case NOP_EXPR: 3231 case CONVERT_EXPR: 3232 case FLOAT_EXPR: 3233 case FIX_TRUNC_EXPR: 3234 case FIX_FLOOR_EXPR: 3235 case FIX_ROUND_EXPR: 3236 case FIX_CEIL_EXPR: 3237 return convert (TREE_TYPE (conversions), 3238 convert_sequence (TREE_OPERAND (conversions, 0), 3239 arg)); 3240 3241 default: 3242 return arg; 3243 } 3244} 3245#endif /* 0 */ 3246 3247/* Return nonzero if REF is an lvalue valid for this language. 3248 Lvalues can be assigned, unless their type has TYPE_READONLY. 3249 Lvalues can have their address taken, unless they have DECL_REGISTER. */ 3250 3251int 3252lvalue_p (ref) 3253 tree ref; 3254{ 3255 enum tree_code code = TREE_CODE (ref); 3256 3257 switch (code) 3258 { 3259 case REALPART_EXPR: 3260 case IMAGPART_EXPR: 3261 case COMPONENT_REF: 3262 return lvalue_p (TREE_OPERAND (ref, 0)); 3263 3264 case COMPOUND_LITERAL_EXPR: 3265 case STRING_CST: 3266 return 1; 3267 3268 case INDIRECT_REF: 3269 case ARRAY_REF: 3270 case VAR_DECL: 3271 case PARM_DECL: 3272 case RESULT_DECL: 3273 case ERROR_MARK: 3274 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 3275 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 3276 3277 case BIND_EXPR: 3278 case RTL_EXPR: 3279 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 3280 3281 default: 3282 return 0; 3283 } 3284} 3285 3286/* Return nonzero if REF is an lvalue valid for this language; 3287 otherwise, print an error message and return zero. */ 3288 3289int 3290lvalue_or_else (ref, msgid) 3291 tree ref; 3292 const char *msgid; 3293{ 3294 int win = lvalue_p (ref); 3295 3296 if (! win) 3297 error ("%s", msgid); 3298 3299 return win; 3300} 3301 3302/* Apply unary lvalue-demanding operator CODE to the expression ARG 3303 for certain kinds of expressions which are not really lvalues 3304 but which we can accept as lvalues. If FLAG is nonzero, then 3305 non-lvalues are OK since we may be converting a non-lvalue array to 3306 a pointer in C99. 3307 3308 If ARG is not a kind of expression we can handle, return zero. */ 3309 3310static tree 3311unary_complex_lvalue (code, arg, flag) 3312 enum tree_code code; 3313 tree arg; 3314 int flag; 3315{ 3316 /* Handle (a, b) used as an "lvalue". */ 3317 if (TREE_CODE (arg) == COMPOUND_EXPR) 3318 { 3319 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0); 3320 3321 /* If this returns a function type, it isn't really being used as 3322 an lvalue, so don't issue a warning about it. */ 3323 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag) 3324 pedantic_lvalue_warning (COMPOUND_EXPR); 3325 3326 return build (COMPOUND_EXPR, TREE_TYPE (real_result), 3327 TREE_OPERAND (arg, 0), real_result); 3328 } 3329 3330 /* Handle (a ? b : c) used as an "lvalue". */ 3331 if (TREE_CODE (arg) == COND_EXPR) 3332 { 3333 if (!flag) 3334 pedantic_lvalue_warning (COND_EXPR); 3335 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag) 3336 pedantic_lvalue_warning (COMPOUND_EXPR); 3337 3338 return (build_conditional_expr 3339 (TREE_OPERAND (arg, 0), 3340 build_unary_op (code, TREE_OPERAND (arg, 1), flag), 3341 build_unary_op (code, TREE_OPERAND (arg, 2), flag))); 3342 } 3343 3344 return 0; 3345} 3346 3347/* If pedantic, warn about improper lvalue. CODE is either COND_EXPR 3348 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */ 3349 3350static void 3351pedantic_lvalue_warning (code) 3352 enum tree_code code; 3353{ 3354 if (pedantic) 3355 switch (code) 3356 { 3357 case COND_EXPR: 3358 pedwarn ("ISO C forbids use of conditional expressions as lvalues"); 3359 break; 3360 case COMPOUND_EXPR: 3361 pedwarn ("ISO C forbids use of compound expressions as lvalues"); 3362 break; 3363 default: 3364 pedwarn ("ISO C forbids use of cast expressions as lvalues"); 3365 break; 3366 } 3367} 3368 3369/* Warn about storing in something that is `const'. */ 3370 3371void 3372readonly_warning (arg, msgid) 3373 tree arg; 3374 const char *msgid; 3375{ 3376 if (TREE_CODE (arg) == COMPONENT_REF) 3377 { 3378 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3379 readonly_warning (TREE_OPERAND (arg, 0), msgid); 3380 else 3381 pedwarn ("%s of read-only member `%s'", _(msgid), 3382 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1)))); 3383 } 3384 else if (TREE_CODE (arg) == VAR_DECL) 3385 pedwarn ("%s of read-only variable `%s'", _(msgid), 3386 IDENTIFIER_POINTER (DECL_NAME (arg))); 3387 else 3388 pedwarn ("%s of read-only location", _(msgid)); 3389} 3390 3391/* Mark EXP saying that we need to be able to take the 3392 address of it; it should not be allocated in a register. 3393 Value is 1 if successful. */ 3394 3395int 3396mark_addressable (exp) 3397 tree exp; 3398{ 3399 tree x = exp; 3400 while (1) 3401 switch (TREE_CODE (x)) 3402 { 3403 case COMPONENT_REF: 3404 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 3405 { 3406 error ("cannot take address of bit-field `%s'", 3407 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1)))); 3408 return 0; 3409 } 3410 3411 /* ... fall through ... */ 3412 3413 case ADDR_EXPR: 3414 case ARRAY_REF: 3415 case REALPART_EXPR: 3416 case IMAGPART_EXPR: 3417 x = TREE_OPERAND (x, 0); 3418 break; 3419 3420 case COMPOUND_LITERAL_EXPR: 3421 case CONSTRUCTOR: 3422 TREE_ADDRESSABLE (x) = 1; 3423 return 1; 3424 3425 case VAR_DECL: 3426 case CONST_DECL: 3427 case PARM_DECL: 3428 case RESULT_DECL: 3429 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x) 3430 && DECL_NONLOCAL (x)) 3431 { 3432 if (TREE_PUBLIC (x)) 3433 { 3434 error ("global register variable `%s' used in nested function", 3435 IDENTIFIER_POINTER (DECL_NAME (x))); 3436 return 0; 3437 } 3438 pedwarn ("register variable `%s' used in nested function", 3439 IDENTIFIER_POINTER (DECL_NAME (x))); 3440 } 3441 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)) 3442 { 3443 if (TREE_PUBLIC (x)) 3444 { 3445 error ("address of global register variable `%s' requested", 3446 IDENTIFIER_POINTER (DECL_NAME (x))); 3447 return 0; 3448 } 3449 3450 /* If we are making this addressable due to its having 3451 volatile components, give a different error message. Also 3452 handle the case of an unnamed parameter by not trying 3453 to give the name. */ 3454 3455 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x))) 3456 { 3457 error ("cannot put object with volatile field into register"); 3458 return 0; 3459 } 3460 3461 pedwarn ("address of register variable `%s' requested", 3462 IDENTIFIER_POINTER (DECL_NAME (x))); 3463 } 3464 put_var_into_stack (x); 3465 3466 /* drops in */ 3467 case FUNCTION_DECL: 3468 TREE_ADDRESSABLE (x) = 1; 3469#if 0 /* poplevel deals with this now. */ 3470 if (DECL_CONTEXT (x) == 0) 3471 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1; 3472#endif 3473 3474 default: 3475 return 1; 3476 } 3477} 3478 3479/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 3480 3481tree 3482build_conditional_expr (ifexp, op1, op2) 3483 tree ifexp, op1, op2; 3484{ 3485 tree type1; 3486 tree type2; 3487 enum tree_code code1; 3488 enum tree_code code2; 3489 tree result_type = NULL; 3490 tree orig_op1 = op1, orig_op2 = op2; 3491 3492 ifexp = truthvalue_conversion (default_conversion (ifexp)); 3493 3494#if 0 /* Produces wrong result if within sizeof. */ 3495 /* Don't promote the operands separately if they promote 3496 the same way. Return the unpromoted type and let the combined 3497 value get promoted if necessary. */ 3498 3499 if (TREE_TYPE (op1) == TREE_TYPE (op2) 3500 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE 3501 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE 3502 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE) 3503 { 3504 if (TREE_CODE (ifexp) == INTEGER_CST) 3505 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1); 3506 3507 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2)); 3508 } 3509#endif 3510 3511 /* Promote both alternatives. */ 3512 3513 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 3514 op1 = default_conversion (op1); 3515 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 3516 op2 = default_conversion (op2); 3517 3518 if (TREE_CODE (ifexp) == ERROR_MARK 3519 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 3520 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 3521 return error_mark_node; 3522 3523 type1 = TREE_TYPE (op1); 3524 code1 = TREE_CODE (type1); 3525 type2 = TREE_TYPE (op2); 3526 code2 = TREE_CODE (type2); 3527 3528 /* Quickly detect the usual case where op1 and op2 have the same type 3529 after promotion. */ 3530 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 3531 { 3532 if (type1 == type2) 3533 result_type = type1; 3534 else 3535 result_type = TYPE_MAIN_VARIANT (type1); 3536 } 3537 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3538 || code1 == COMPLEX_TYPE) 3539 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3540 || code2 == COMPLEX_TYPE)) 3541 { 3542 result_type = common_type (type1, type2); 3543 3544 /* If -Wsign-compare, warn here if type1 and type2 have 3545 different signedness. We'll promote the signed to unsigned 3546 and later code won't know it used to be different. 3547 Do this check on the original types, so that explicit casts 3548 will be considered, but default promotions won't. */ 3549 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare) 3550 && !skip_evaluation) 3551 { 3552 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1)); 3553 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2)); 3554 3555 if (unsigned_op1 ^ unsigned_op2) 3556 { 3557 /* Do not warn if the result type is signed, since the 3558 signed type will only be chosen if it can represent 3559 all the values of the unsigned type. */ 3560 if (! TREE_UNSIGNED (result_type)) 3561 /* OK */; 3562 /* Do not warn if the signed quantity is an unsuffixed 3563 integer literal (or some static constant expression 3564 involving such literals) and it is non-negative. */ 3565 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1)) 3566 || (unsigned_op1 && tree_expr_nonnegative_p (op2))) 3567 /* OK */; 3568 else 3569 warning ("signed and unsigned type in conditional expression"); 3570 } 3571 } 3572 } 3573 else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 3574 { 3575 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 3576 pedwarn ("ISO C forbids conditional expr with only one void side"); 3577 result_type = void_type_node; 3578 } 3579 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) 3580 { 3581 if (comp_target_types (type1, type2)) 3582 result_type = common_type (type1, type2); 3583 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node 3584 && TREE_CODE (orig_op1) != NOP_EXPR) 3585 result_type = qualify_type (type2, type1); 3586 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node 3587 && TREE_CODE (orig_op2) != NOP_EXPR) 3588 result_type = qualify_type (type1, type2); 3589 else if (VOID_TYPE_P (TREE_TYPE (type1))) 3590 { 3591 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3592 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer"); 3593 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 3594 TREE_TYPE (type2))); 3595 } 3596 else if (VOID_TYPE_P (TREE_TYPE (type2))) 3597 { 3598 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3599 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer"); 3600 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 3601 TREE_TYPE (type1))); 3602 } 3603 else 3604 { 3605 pedwarn ("pointer type mismatch in conditional expression"); 3606 result_type = build_pointer_type (void_type_node); 3607 } 3608 } 3609 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 3610 { 3611 if (! integer_zerop (op2)) 3612 pedwarn ("pointer/integer type mismatch in conditional expression"); 3613 else 3614 { 3615 op2 = null_pointer_node; 3616 } 3617 result_type = type1; 3618 } 3619 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 3620 { 3621 if (!integer_zerop (op1)) 3622 pedwarn ("pointer/integer type mismatch in conditional expression"); 3623 else 3624 { 3625 op1 = null_pointer_node; 3626 } 3627 result_type = type2; 3628 } 3629 3630 if (!result_type) 3631 { 3632 if (flag_cond_mismatch) 3633 result_type = void_type_node; 3634 else 3635 { 3636 error ("type mismatch in conditional expression"); 3637 return error_mark_node; 3638 } 3639 } 3640 3641 /* Merge const and volatile flags of the incoming types. */ 3642 result_type 3643 = build_type_variant (result_type, 3644 TREE_READONLY (op1) || TREE_READONLY (op2), 3645 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 3646 3647 if (result_type != TREE_TYPE (op1)) 3648 op1 = convert_and_check (result_type, op1); 3649 if (result_type != TREE_TYPE (op2)) 3650 op2 = convert_and_check (result_type, op2); 3651 3652 if (TREE_CODE (ifexp) == INTEGER_CST) 3653 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1); 3654 3655 return fold (build (COND_EXPR, result_type, ifexp, op1, op2)); 3656} 3657 3658/* Given a list of expressions, return a compound expression 3659 that performs them all and returns the value of the last of them. */ 3660 3661tree 3662build_compound_expr (list) 3663 tree list; 3664{ 3665 return internal_build_compound_expr (list, TRUE); 3666} 3667 3668static tree 3669internal_build_compound_expr (list, first_p) 3670 tree list; 3671 int first_p; 3672{ 3673 tree rest; 3674 3675 if (TREE_CHAIN (list) == 0) 3676 { 3677 /* Convert arrays and functions to pointers when there 3678 really is a comma operator. */ 3679 if (!first_p) 3680 TREE_VALUE (list) 3681 = default_function_array_conversion (TREE_VALUE (list)); 3682 3683#if 0 /* If something inside inhibited lvalueness, we should not override. */ 3684 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */ 3685 3686 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 3687 if (TREE_CODE (list) == NON_LVALUE_EXPR) 3688 list = TREE_OPERAND (list, 0); 3689#endif 3690 3691 /* Don't let (0, 0) be null pointer constant. */ 3692 if (!first_p && integer_zerop (TREE_VALUE (list))) 3693 return non_lvalue (TREE_VALUE (list)); 3694 return TREE_VALUE (list); 3695 } 3696 3697 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE); 3698 3699 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list))) 3700 { 3701 /* The left-hand operand of a comma expression is like an expression 3702 statement: with -W or -Wunused, we should warn if it doesn't have 3703 any side-effects, unless it was explicitly cast to (void). */ 3704 if ((extra_warnings || warn_unused_value) 3705 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR 3706 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list))))) 3707 warning ("left-hand operand of comma expression has no effect"); 3708 3709 /* When pedantic, a compound expression can be neither an lvalue 3710 nor an integer constant expression. */ 3711 if (! pedantic) 3712 return rest; 3713 } 3714 3715 /* With -Wunused, we should also warn if the left-hand operand does have 3716 side-effects, but computes a value which is not used. For example, in 3717 `foo() + bar(), baz()' the result of the `+' operator is not used, 3718 so we should issue a warning. */ 3719 else if (warn_unused_value) 3720 warn_if_unused_value (TREE_VALUE (list)); 3721 3722 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest); 3723} 3724 3725/* Build an expression representing a cast to type TYPE of expression EXPR. */ 3726 3727tree 3728build_c_cast (type, expr) 3729 tree type; 3730 tree expr; 3731{ 3732 tree value = expr; 3733 3734 if (type == error_mark_node || expr == error_mark_node) 3735 return error_mark_node; 3736 type = TYPE_MAIN_VARIANT (type); 3737 3738#if 0 3739 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 3740 if (TREE_CODE (value) == NON_LVALUE_EXPR) 3741 value = TREE_OPERAND (value, 0); 3742#endif 3743 3744 if (TREE_CODE (type) == ARRAY_TYPE) 3745 { 3746 error ("cast specifies array type"); 3747 return error_mark_node; 3748 } 3749 3750 if (TREE_CODE (type) == FUNCTION_TYPE) 3751 { 3752 error ("cast specifies function type"); 3753 return error_mark_node; 3754 } 3755 3756 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 3757 { 3758 if (pedantic) 3759 { 3760 if (TREE_CODE (type) == RECORD_TYPE 3761 || TREE_CODE (type) == UNION_TYPE) 3762 pedwarn ("ISO C forbids casting nonscalar to the same type"); 3763 } 3764 } 3765 else if (TREE_CODE (type) == UNION_TYPE) 3766 { 3767 tree field; 3768 value = default_function_array_conversion (value); 3769 3770 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 3771 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3772 TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 3773 break; 3774 3775 if (field) 3776 { 3777 const char *name; 3778 tree t; 3779 3780 if (pedantic) 3781 pedwarn ("ISO C forbids casts to union type"); 3782 if (TYPE_NAME (type) != 0) 3783 { 3784 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 3785 name = IDENTIFIER_POINTER (TYPE_NAME (type)); 3786 else 3787 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 3788 } 3789 else 3790 name = ""; 3791 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE, 3792 build_tree_list (field, value)), 3793 0, 0); 3794 TREE_CONSTANT (t) = TREE_CONSTANT (value); 3795 return t; 3796 } 3797 error ("cast to union type from type not present in union"); 3798 return error_mark_node; 3799 } 3800 else 3801 { 3802 tree otype, ovalue; 3803 3804 /* If casting to void, avoid the error that would come 3805 from default_conversion in the case of a non-lvalue array. */ 3806 if (type == void_type_node) 3807 return build1 (CONVERT_EXPR, type, value); 3808 3809 /* Convert functions and arrays to pointers, 3810 but don't convert any other types. */ 3811 value = default_function_array_conversion (value); 3812 otype = TREE_TYPE (value); 3813 3814 /* Optionally warn about potentially worrisome casts. */ 3815 3816 if (warn_cast_qual 3817 && TREE_CODE (type) == POINTER_TYPE 3818 && TREE_CODE (otype) == POINTER_TYPE) 3819 { 3820 tree in_type = type; 3821 tree in_otype = otype; 3822 int warn = 0; 3823 3824 /* Check that the qualifiers on IN_TYPE are a superset of 3825 the qualifiers of IN_OTYPE. The outermost level of 3826 POINTER_TYPE nodes is uninteresting and we stop as soon 3827 as we hit a non-POINTER_TYPE node on either type. */ 3828 do 3829 { 3830 in_otype = TREE_TYPE (in_otype); 3831 in_type = TREE_TYPE (in_type); 3832 warn |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 3833 } 3834 while (TREE_CODE (in_type) == POINTER_TYPE 3835 && TREE_CODE (in_otype) == POINTER_TYPE); 3836 3837 if (warn) 3838 /* There are qualifiers present in IN_OTYPE that are not 3839 present in IN_TYPE. */ 3840 warning ("cast discards qualifiers from pointer target type"); 3841 } 3842 3843 /* Warn about possible alignment problems. */ 3844 if (STRICT_ALIGNMENT && warn_cast_align 3845 && TREE_CODE (type) == POINTER_TYPE 3846 && TREE_CODE (otype) == POINTER_TYPE 3847 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 3848 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3849 /* Don't warn about opaque types, where the actual alignment 3850 restriction is unknown. */ 3851 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 3852 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 3853 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 3854 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3855 warning ("cast increases required alignment of target type"); 3856 3857 if (TREE_CODE (type) == INTEGER_TYPE 3858 && TREE_CODE (otype) == POINTER_TYPE 3859 && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 3860 && !TREE_CONSTANT (value)) 3861 warning ("cast from pointer to integer of different size"); 3862 3863 if (warn_bad_function_cast 3864 && TREE_CODE (value) == CALL_EXPR 3865 && TREE_CODE (type) != TREE_CODE (otype)) 3866 warning ("cast does not match function type"); 3867 3868 if (TREE_CODE (type) == POINTER_TYPE 3869 && TREE_CODE (otype) == INTEGER_TYPE 3870 && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 3871 /* Don't warn about converting any constant. */ 3872 && !TREE_CONSTANT (value)) 3873 warning ("cast to pointer from integer of different size"); 3874 3875 ovalue = value; 3876 value = convert (type, value); 3877 3878 /* Ignore any integer overflow caused by the cast. */ 3879 if (TREE_CODE (value) == INTEGER_CST) 3880 { 3881 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3882 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3883 } 3884 } 3885 3886 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */ 3887 if (pedantic && TREE_CODE (value) == INTEGER_CST 3888 && TREE_CODE (expr) == INTEGER_CST 3889 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE) 3890 value = non_lvalue (value); 3891 3892 /* If pedantic, don't let a cast be an lvalue. */ 3893 if (value == expr && pedantic) 3894 value = non_lvalue (value); 3895 3896 return value; 3897} 3898 3899/* Interpret a cast of expression EXPR to type TYPE. */ 3900tree 3901c_cast_expr (type, expr) 3902 tree type, expr; 3903{ 3904 int saved_wsp = warn_strict_prototypes; 3905 3906 /* This avoids warnings about unprototyped casts on 3907 integers. E.g. "#define SIG_DFL (void(*)())0". */ 3908 if (TREE_CODE (expr) == INTEGER_CST) 3909 warn_strict_prototypes = 0; 3910 type = groktypename (type); 3911 warn_strict_prototypes = saved_wsp; 3912 3913 return build_c_cast (type, expr); 3914} 3915 3916 3917/* Build an assignment expression of lvalue LHS from value RHS. 3918 MODIFYCODE is the code for a binary operator that we use 3919 to combine the old value of LHS with RHS to get the new value. 3920 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 3921 3922tree 3923build_modify_expr (lhs, modifycode, rhs) 3924 tree lhs, rhs; 3925 enum tree_code modifycode; 3926{ 3927 tree result; 3928 tree newrhs; 3929 tree lhstype = TREE_TYPE (lhs); 3930 tree olhstype = lhstype; 3931 3932 /* Types that aren't fully specified cannot be used in assignments. */ 3933 lhs = require_complete_type (lhs); 3934 3935 /* Avoid duplicate error messages from operands that had errors. */ 3936 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 3937 return error_mark_node; 3938 3939 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 3940 /* Do not use STRIP_NOPS here. We do not want an enumerator 3941 whose value is 0 to count as a null pointer constant. */ 3942 if (TREE_CODE (rhs) == NON_LVALUE_EXPR) 3943 rhs = TREE_OPERAND (rhs, 0); 3944 3945 newrhs = rhs; 3946 3947 /* Handle control structure constructs used as "lvalues". */ 3948 3949 switch (TREE_CODE (lhs)) 3950 { 3951 /* Handle (a, b) used as an "lvalue". */ 3952 case COMPOUND_EXPR: 3953 pedantic_lvalue_warning (COMPOUND_EXPR); 3954 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs); 3955 if (TREE_CODE (newrhs) == ERROR_MARK) 3956 return error_mark_node; 3957 return build (COMPOUND_EXPR, lhstype, 3958 TREE_OPERAND (lhs, 0), newrhs); 3959 3960 /* Handle (a ? b : c) used as an "lvalue". */ 3961 case COND_EXPR: 3962 pedantic_lvalue_warning (COND_EXPR); 3963 rhs = save_expr (rhs); 3964 { 3965 /* Produce (a ? (b = rhs) : (c = rhs)) 3966 except that the RHS goes through a save-expr 3967 so the code to compute it is only emitted once. */ 3968 tree cond 3969 = build_conditional_expr (TREE_OPERAND (lhs, 0), 3970 build_modify_expr (TREE_OPERAND (lhs, 1), 3971 modifycode, rhs), 3972 build_modify_expr (TREE_OPERAND (lhs, 2), 3973 modifycode, rhs)); 3974 if (TREE_CODE (cond) == ERROR_MARK) 3975 return cond; 3976 /* Make sure the code to compute the rhs comes out 3977 before the split. */ 3978 return build (COMPOUND_EXPR, TREE_TYPE (lhs), 3979 /* But cast it to void to avoid an "unused" error. */ 3980 convert (void_type_node, rhs), cond); 3981 } 3982 default: 3983 break; 3984 } 3985 3986 /* If a binary op has been requested, combine the old LHS value with the RHS 3987 producing the value we should actually store into the LHS. */ 3988 3989 if (modifycode != NOP_EXPR) 3990 { 3991 lhs = stabilize_reference (lhs); 3992 newrhs = build_binary_op (modifycode, lhs, rhs, 1); 3993 } 3994 3995 /* Handle a cast used as an "lvalue". 3996 We have already performed any binary operator using the value as cast. 3997 Now convert the result to the cast type of the lhs, 3998 and then true type of the lhs and store it there; 3999 then convert result back to the cast type to be the value 4000 of the assignment. */ 4001 4002 switch (TREE_CODE (lhs)) 4003 { 4004 case NOP_EXPR: 4005 case CONVERT_EXPR: 4006 case FLOAT_EXPR: 4007 case FIX_TRUNC_EXPR: 4008 case FIX_FLOOR_EXPR: 4009 case FIX_ROUND_EXPR: 4010 case FIX_CEIL_EXPR: 4011 newrhs = default_function_array_conversion (newrhs); 4012 { 4013 tree inner_lhs = TREE_OPERAND (lhs, 0); 4014 tree result; 4015 result = build_modify_expr (inner_lhs, NOP_EXPR, 4016 convert (TREE_TYPE (inner_lhs), 4017 convert (lhstype, newrhs))); 4018 if (TREE_CODE (result) == ERROR_MARK) 4019 return result; 4020 pedantic_lvalue_warning (CONVERT_EXPR); 4021 return convert (TREE_TYPE (lhs), result); 4022 } 4023 4024 default: 4025 break; 4026 } 4027 4028 /* Now we have handled acceptable kinds of LHS that are not truly lvalues. 4029 Reject anything strange now. */ 4030 4031 if (!lvalue_or_else (lhs, "invalid lvalue in assignment")) 4032 return error_mark_node; 4033 4034 /* Warn about storing in something that is `const'. */ 4035 4036 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 4037 || ((TREE_CODE (lhstype) == RECORD_TYPE 4038 || TREE_CODE (lhstype) == UNION_TYPE) 4039 && C_TYPE_FIELDS_READONLY (lhstype))) 4040 readonly_warning (lhs, "assignment"); 4041 4042 /* If storing into a structure or union member, 4043 it has probably been given type `int'. 4044 Compute the type that would go with 4045 the actual amount of storage the member occupies. */ 4046 4047 if (TREE_CODE (lhs) == COMPONENT_REF 4048 && (TREE_CODE (lhstype) == INTEGER_TYPE 4049 || TREE_CODE (lhstype) == BOOLEAN_TYPE 4050 || TREE_CODE (lhstype) == REAL_TYPE 4051 || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 4052 lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 4053 4054 /* If storing in a field that is in actuality a short or narrower than one, 4055 we must store in the field in its actual type. */ 4056 4057 if (lhstype != TREE_TYPE (lhs)) 4058 { 4059 lhs = copy_node (lhs); 4060 TREE_TYPE (lhs) = lhstype; 4061 } 4062 4063 /* Convert new value to destination type. */ 4064 4065 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"), 4066 NULL_TREE, NULL_TREE, 0); 4067 if (TREE_CODE (newrhs) == ERROR_MARK) 4068 return error_mark_node; 4069 4070 /* Scan operands */ 4071 4072 result = build (MODIFY_EXPR, lhstype, lhs, newrhs); 4073 TREE_SIDE_EFFECTS (result) = 1; 4074 4075 /* If we got the LHS in a different type for storing in, 4076 convert the result back to the nominal type of LHS 4077 so that the value we return always has the same type 4078 as the LHS argument. */ 4079 4080 if (olhstype == TREE_TYPE (result)) 4081 return result; 4082 return convert_for_assignment (olhstype, result, _("assignment"), 4083 NULL_TREE, NULL_TREE, 0); 4084} 4085 4086/* Convert value RHS to type TYPE as preparation for an assignment 4087 to an lvalue of type TYPE. 4088 The real work of conversion is done by `convert'. 4089 The purpose of this function is to generate error messages 4090 for assignments that are not allowed in C. 4091 ERRTYPE is a string to use in error messages: 4092 "assignment", "return", etc. If it is null, this is parameter passing 4093 for a function call (and different error messages are output). 4094 4095 FUNNAME is the name of the function being called, 4096 as an IDENTIFIER_NODE, or null. 4097 PARMNUM is the number of the argument, for printing in error messages. */ 4098 4099static tree 4100convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum) 4101 tree type, rhs; 4102 const char *errtype; 4103 tree fundecl, funname; 4104 int parmnum; 4105{ 4106 enum tree_code codel = TREE_CODE (type); 4107 tree rhstype; 4108 enum tree_code coder; 4109 4110 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 4111 /* Do not use STRIP_NOPS here. We do not want an enumerator 4112 whose value is 0 to count as a null pointer constant. */ 4113 if (TREE_CODE (rhs) == NON_LVALUE_EXPR) 4114 rhs = TREE_OPERAND (rhs, 0); 4115 4116 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE 4117 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE) 4118 rhs = default_conversion (rhs); 4119 else if (optimize && TREE_CODE (rhs) == VAR_DECL) 4120 rhs = decl_constant_value_for_broken_optimization (rhs); 4121 4122 rhstype = TREE_TYPE (rhs); 4123 coder = TREE_CODE (rhstype); 4124 4125 if (coder == ERROR_MARK) 4126 return error_mark_node; 4127 4128 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 4129 { 4130 overflow_warning (rhs); 4131 /* Check for Objective-C protocols. This will issue a warning if 4132 there are protocol violations. No need to use the return value. */ 4133 maybe_objc_comptypes (type, rhstype, 0); 4134 return rhs; 4135 } 4136 4137 if (coder == VOID_TYPE) 4138 { 4139 error ("void value not ignored as it ought to be"); 4140 return error_mark_node; 4141 } 4142 /* A type converts to a reference to it. 4143 This code doesn't fully support references, it's just for the 4144 special case of va_start and va_copy. */ 4145 if (codel == REFERENCE_TYPE 4146 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1) 4147 { 4148 if (mark_addressable (rhs) == 0) 4149 return error_mark_node; 4150 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 4151 4152 /* We already know that these two types are compatible, but they 4153 may not be exactly identical. In fact, `TREE_TYPE (type)' is 4154 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 4155 likely to be va_list, a typedef to __builtin_va_list, which 4156 is different enough that it will cause problems later. */ 4157 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 4158 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 4159 4160 rhs = build1 (NOP_EXPR, type, rhs); 4161 return rhs; 4162 } 4163 /* Arithmetic types all interconvert, and enum is treated like int. */ 4164 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 4165 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 4166 || codel == BOOLEAN_TYPE) 4167 && (coder == INTEGER_TYPE || coder == REAL_TYPE 4168 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 4169 || coder == BOOLEAN_TYPE)) 4170 return convert_and_check (type, rhs); 4171 4172 /* Conversion to a transparent union from its member types. 4173 This applies only to function arguments. */ 4174 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype) 4175 { 4176 tree memb_types; 4177 tree marginal_memb_type = 0; 4178 4179 for (memb_types = TYPE_FIELDS (type); memb_types; 4180 memb_types = TREE_CHAIN (memb_types)) 4181 { 4182 tree memb_type = TREE_TYPE (memb_types); 4183 4184 if (comptypes (TYPE_MAIN_VARIANT (memb_type), 4185 TYPE_MAIN_VARIANT (rhstype))) 4186 break; 4187 4188 if (TREE_CODE (memb_type) != POINTER_TYPE) 4189 continue; 4190 4191 if (coder == POINTER_TYPE) 4192 { 4193 tree ttl = TREE_TYPE (memb_type); 4194 tree ttr = TREE_TYPE (rhstype); 4195 4196 /* Any non-function converts to a [const][volatile] void * 4197 and vice versa; otherwise, targets must be the same. 4198 Meanwhile, the lhs target must have all the qualifiers of 4199 the rhs. */ 4200 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4201 || comp_target_types (memb_type, rhstype)) 4202 { 4203 /* If this type won't generate any warnings, use it. */ 4204 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 4205 || ((TREE_CODE (ttr) == FUNCTION_TYPE 4206 && TREE_CODE (ttl) == FUNCTION_TYPE) 4207 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 4208 == TYPE_QUALS (ttr)) 4209 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 4210 == TYPE_QUALS (ttl)))) 4211 break; 4212 4213 /* Keep looking for a better type, but remember this one. */ 4214 if (! marginal_memb_type) 4215 marginal_memb_type = memb_type; 4216 } 4217 } 4218 4219 /* Can convert integer zero to any pointer type. */ 4220 if (integer_zerop (rhs) 4221 || (TREE_CODE (rhs) == NOP_EXPR 4222 && integer_zerop (TREE_OPERAND (rhs, 0)))) 4223 { 4224 rhs = null_pointer_node; 4225 break; 4226 } 4227 } 4228 4229 if (memb_types || marginal_memb_type) 4230 { 4231 if (! memb_types) 4232 { 4233 /* We have only a marginally acceptable member type; 4234 it needs a warning. */ 4235 tree ttl = TREE_TYPE (marginal_memb_type); 4236 tree ttr = TREE_TYPE (rhstype); 4237 4238 /* Const and volatile mean something different for function 4239 types, so the usual warnings are not appropriate. */ 4240 if (TREE_CODE (ttr) == FUNCTION_TYPE 4241 && TREE_CODE (ttl) == FUNCTION_TYPE) 4242 { 4243 /* Because const and volatile on functions are 4244 restrictions that say the function will not do 4245 certain things, it is okay to use a const or volatile 4246 function where an ordinary one is wanted, but not 4247 vice-versa. */ 4248 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4249 warn_for_assignment ("%s makes qualified function pointer from unqualified", 4250 errtype, funname, parmnum); 4251 } 4252 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4253 warn_for_assignment ("%s discards qualifiers from pointer target type", 4254 errtype, funname, 4255 parmnum); 4256 } 4257 4258 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl)) 4259 pedwarn ("ISO C prohibits argument conversion to union type"); 4260 4261 return build1 (NOP_EXPR, type, rhs); 4262 } 4263 } 4264 4265 /* Conversions among pointers */ 4266 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4267 && (coder == POINTER_TYPE || coder == REFERENCE_TYPE)) 4268 { 4269 tree ttl = TREE_TYPE (type); 4270 tree ttr = TREE_TYPE (rhstype); 4271 4272 /* Any non-function converts to a [const][volatile] void * 4273 and vice versa; otherwise, targets must be the same. 4274 Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 4275 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4276 || comp_target_types (type, rhstype) 4277 || (unsigned_type (TYPE_MAIN_VARIANT (ttl)) 4278 == unsigned_type (TYPE_MAIN_VARIANT (ttr)))) 4279 { 4280 if (pedantic 4281 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 4282 || 4283 (VOID_TYPE_P (ttr) 4284 /* Check TREE_CODE to catch cases like (void *) (char *) 0 4285 which are not ANSI null ptr constants. */ 4286 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR) 4287 && TREE_CODE (ttl) == FUNCTION_TYPE))) 4288 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'", 4289 errtype, funname, parmnum); 4290 /* Const and volatile mean something different for function types, 4291 so the usual warnings are not appropriate. */ 4292 else if (TREE_CODE (ttr) != FUNCTION_TYPE 4293 && TREE_CODE (ttl) != FUNCTION_TYPE) 4294 { 4295 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4296 warn_for_assignment ("%s discards qualifiers from pointer target type", 4297 errtype, funname, parmnum); 4298 /* If this is not a case of ignoring a mismatch in signedness, 4299 no warning. */ 4300 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4301 || comp_target_types (type, rhstype)) 4302 ; 4303 /* If there is a mismatch, do warn. */ 4304 else if (pedantic) 4305 warn_for_assignment ("pointer targets in %s differ in signedness", 4306 errtype, funname, parmnum); 4307 } 4308 else if (TREE_CODE (ttl) == FUNCTION_TYPE 4309 && TREE_CODE (ttr) == FUNCTION_TYPE) 4310 { 4311 /* Because const and volatile on functions are restrictions 4312 that say the function will not do certain things, 4313 it is okay to use a const or volatile function 4314 where an ordinary one is wanted, but not vice-versa. */ 4315 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4316 warn_for_assignment ("%s makes qualified function pointer from unqualified", 4317 errtype, funname, parmnum); 4318 } 4319 } 4320 else 4321 warn_for_assignment ("%s from incompatible pointer type", 4322 errtype, funname, parmnum); 4323 return convert (type, rhs); 4324 } 4325 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 4326 { 4327 /* An explicit constant 0 can convert to a pointer, 4328 or one that results from arithmetic, even including 4329 a cast to integer type. */ 4330 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs)) 4331 && 4332 ! (TREE_CODE (rhs) == NOP_EXPR 4333 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE 4334 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST 4335 && integer_zerop (TREE_OPERAND (rhs, 0)))) 4336 { 4337 warn_for_assignment ("%s makes pointer from integer without a cast", 4338 errtype, funname, parmnum); 4339 return convert (type, rhs); 4340 } 4341 return null_pointer_node; 4342 } 4343 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 4344 { 4345 warn_for_assignment ("%s makes integer from pointer without a cast", 4346 errtype, funname, parmnum); 4347 return convert (type, rhs); 4348 } 4349 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 4350 return convert (type, rhs); 4351 4352 if (!errtype) 4353 { 4354 if (funname) 4355 { 4356 tree selector = maybe_building_objc_message_expr (); 4357 4358 if (selector && parmnum > 2) 4359 error ("incompatible type for argument %d of `%s'", 4360 parmnum - 2, IDENTIFIER_POINTER (selector)); 4361 else 4362 error ("incompatible type for argument %d of `%s'", 4363 parmnum, IDENTIFIER_POINTER (funname)); 4364 } 4365 else 4366 error ("incompatible type for argument %d of indirect function call", 4367 parmnum); 4368 } 4369 else 4370 error ("incompatible types in %s", errtype); 4371 4372 return error_mark_node; 4373} 4374 4375/* Print a warning using MSGID. 4376 It gets OPNAME as its one parameter. 4377 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'". 4378 FUNCTION and ARGNUM are handled specially if we are building an 4379 Objective-C selector. */ 4380 4381static void 4382warn_for_assignment (msgid, opname, function, argnum) 4383 const char *msgid; 4384 const char *opname; 4385 tree function; 4386 int argnum; 4387{ 4388 if (opname == 0) 4389 { 4390 tree selector = maybe_building_objc_message_expr (); 4391 char * new_opname; 4392 4393 if (selector && argnum > 2) 4394 { 4395 function = selector; 4396 argnum -= 2; 4397 } 4398 if (function) 4399 { 4400 /* Function name is known; supply it. */ 4401 const char *const argstring = _("passing arg %d of `%s'"); 4402 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function) 4403 + strlen (argstring) + 1 + 25 4404 /*%d*/ + 1); 4405 sprintf (new_opname, argstring, argnum, 4406 IDENTIFIER_POINTER (function)); 4407 } 4408 else 4409 { 4410 /* Function name unknown (call through ptr); just give arg number. */ 4411 const char *const argnofun = _("passing arg %d of pointer to function"); 4412 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1); 4413 sprintf (new_opname, argnofun, argnum); 4414 } 4415 opname = new_opname; 4416 } 4417 pedwarn (msgid, opname); 4418} 4419 4420/* If VALUE is a compound expr all of whose expressions are constant, then 4421 return its value. Otherwise, return error_mark_node. 4422 4423 This is for handling COMPOUND_EXPRs as initializer elements 4424 which is allowed with a warning when -pedantic is specified. */ 4425 4426static tree 4427valid_compound_expr_initializer (value, endtype) 4428 tree value; 4429 tree endtype; 4430{ 4431 if (TREE_CODE (value) == COMPOUND_EXPR) 4432 { 4433 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 4434 == error_mark_node) 4435 return error_mark_node; 4436 return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 4437 endtype); 4438 } 4439 else if (! TREE_CONSTANT (value) 4440 && ! initializer_constant_valid_p (value, endtype)) 4441 return error_mark_node; 4442 else 4443 return value; 4444} 4445 4446/* Perform appropriate conversions on the initial value of a variable, 4447 store it in the declaration DECL, 4448 and print any error messages that are appropriate. 4449 If the init is invalid, store an ERROR_MARK. */ 4450 4451void 4452store_init_value (decl, init) 4453 tree decl, init; 4454{ 4455 tree value, type; 4456 4457 /* If variable's type was invalidly declared, just ignore it. */ 4458 4459 type = TREE_TYPE (decl); 4460 if (TREE_CODE (type) == ERROR_MARK) 4461 return; 4462 4463 /* Digest the specified initializer into an expression. */ 4464 4465 value = digest_init (type, init, TREE_STATIC (decl), 4466 TREE_STATIC (decl) || (pedantic && !flag_isoc99)); 4467 4468 /* Store the expression if valid; else report error. */ 4469 4470#if 0 4471 /* Note that this is the only place we can detect the error 4472 in a case such as struct foo bar = (struct foo) { x, y }; 4473 where there is one initial value which is a constructor expression. */ 4474 if (value == error_mark_node) 4475 ; 4476 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value)) 4477 { 4478 error ("initializer for static variable is not constant"); 4479 value = error_mark_node; 4480 } 4481 else if (TREE_STATIC (decl) 4482 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0) 4483 { 4484 error ("initializer for static variable uses complicated arithmetic"); 4485 value = error_mark_node; 4486 } 4487 else 4488 { 4489 if (pedantic && TREE_CODE (value) == CONSTRUCTOR) 4490 { 4491 if (! TREE_CONSTANT (value)) 4492 pedwarn ("aggregate initializer is not constant"); 4493 else if (! TREE_STATIC (value)) 4494 pedwarn ("aggregate initializer uses complicated arithmetic"); 4495 } 4496 } 4497#endif 4498 4499 if (warn_traditional && !in_system_header 4500 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl)) 4501 warning ("traditional C rejects automatic aggregate initialization"); 4502 4503 DECL_INITIAL (decl) = value; 4504 4505 /* ANSI wants warnings about out-of-range constant initializers. */ 4506 STRIP_TYPE_NOPS (value); 4507 constant_expression_warning (value); 4508 4509 /* Check if we need to set array size from compound literal size. */ 4510 if (TREE_CODE (type) == ARRAY_TYPE 4511 && TYPE_DOMAIN (type) == 0 4512 && value != error_mark_node) 4513 { 4514 tree inside_init = init; 4515 4516 if (TREE_CODE (init) == NON_LVALUE_EXPR) 4517 inside_init = TREE_OPERAND (init, 0); 4518 inside_init = fold (inside_init); 4519 4520 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4521 { 4522 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 4523 4524 if (TYPE_DOMAIN (TREE_TYPE (decl))) 4525 { 4526 /* For int foo[] = (int [3]){1}; we need to set array size 4527 now since later on array initializer will be just the 4528 brace enclosed list of the compound literal. */ 4529 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl)); 4530 layout_type (type); 4531 layout_decl (decl, 0); 4532 } 4533 } 4534 } 4535} 4536 4537/* Methods for storing and printing names for error messages. */ 4538 4539/* Implement a spelling stack that allows components of a name to be pushed 4540 and popped. Each element on the stack is this structure. */ 4541 4542struct spelling 4543{ 4544 int kind; 4545 union 4546 { 4547 int i; 4548 const char *s; 4549 } u; 4550}; 4551 4552#define SPELLING_STRING 1 4553#define SPELLING_MEMBER 2 4554#define SPELLING_BOUNDS 3 4555 4556static struct spelling *spelling; /* Next stack element (unused). */ 4557static struct spelling *spelling_base; /* Spelling stack base. */ 4558static int spelling_size; /* Size of the spelling stack. */ 4559 4560/* Macros to save and restore the spelling stack around push_... functions. 4561 Alternative to SAVE_SPELLING_STACK. */ 4562 4563#define SPELLING_DEPTH() (spelling - spelling_base) 4564#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 4565 4566/* Save and restore the spelling stack around arbitrary C code. */ 4567 4568#define SAVE_SPELLING_DEPTH(code) \ 4569{ \ 4570 int __depth = SPELLING_DEPTH (); \ 4571 code; \ 4572 RESTORE_SPELLING_DEPTH (__depth); \ 4573} 4574 4575/* Push an element on the spelling stack with type KIND and assign VALUE 4576 to MEMBER. */ 4577 4578#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 4579{ \ 4580 int depth = SPELLING_DEPTH (); \ 4581 \ 4582 if (depth >= spelling_size) \ 4583 { \ 4584 spelling_size += 10; \ 4585 if (spelling_base == 0) \ 4586 spelling_base \ 4587 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \ 4588 else \ 4589 spelling_base \ 4590 = (struct spelling *) xrealloc (spelling_base, \ 4591 spelling_size * sizeof (struct spelling)); \ 4592 RESTORE_SPELLING_DEPTH (depth); \ 4593 } \ 4594 \ 4595 spelling->kind = (KIND); \ 4596 spelling->MEMBER = (VALUE); \ 4597 spelling++; \ 4598} 4599 4600/* Push STRING on the stack. Printed literally. */ 4601 4602static void 4603push_string (string) 4604 const char *string; 4605{ 4606 PUSH_SPELLING (SPELLING_STRING, string, u.s); 4607} 4608 4609/* Push a member name on the stack. Printed as '.' STRING. */ 4610 4611static void 4612push_member_name (decl) 4613 tree decl; 4614 4615{ 4616 const char *const string 4617 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 4618 PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 4619} 4620 4621/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 4622 4623static void 4624push_array_bounds (bounds) 4625 int bounds; 4626{ 4627 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 4628} 4629 4630/* Compute the maximum size in bytes of the printed spelling. */ 4631 4632static int 4633spelling_length () 4634{ 4635 int size = 0; 4636 struct spelling *p; 4637 4638 for (p = spelling_base; p < spelling; p++) 4639 { 4640 if (p->kind == SPELLING_BOUNDS) 4641 size += 25; 4642 else 4643 size += strlen (p->u.s) + 1; 4644 } 4645 4646 return size; 4647} 4648 4649/* Print the spelling to BUFFER and return it. */ 4650 4651static char * 4652print_spelling (buffer) 4653 char *buffer; 4654{ 4655 char *d = buffer; 4656 struct spelling *p; 4657 4658 for (p = spelling_base; p < spelling; p++) 4659 if (p->kind == SPELLING_BOUNDS) 4660 { 4661 sprintf (d, "[%d]", p->u.i); 4662 d += strlen (d); 4663 } 4664 else 4665 { 4666 const char *s; 4667 if (p->kind == SPELLING_MEMBER) 4668 *d++ = '.'; 4669 for (s = p->u.s; (*d = *s++); d++) 4670 ; 4671 } 4672 *d++ = '\0'; 4673 return buffer; 4674} 4675 4676/* Issue an error message for a bad initializer component. 4677 MSGID identifies the message. 4678 The component name is taken from the spelling stack. */ 4679 4680void 4681error_init (msgid) 4682 const char *msgid; 4683{ 4684 char *ofwhat; 4685 4686 error ("%s", _(msgid)); 4687 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4688 if (*ofwhat) 4689 error ("(near initialization for `%s')", ofwhat); 4690} 4691 4692/* Issue a pedantic warning for a bad initializer component. 4693 MSGID identifies the message. 4694 The component name is taken from the spelling stack. */ 4695 4696void 4697pedwarn_init (msgid) 4698 const char *msgid; 4699{ 4700 char *ofwhat; 4701 4702 pedwarn ("%s", _(msgid)); 4703 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4704 if (*ofwhat) 4705 pedwarn ("(near initialization for `%s')", ofwhat); 4706} 4707 4708/* Issue a warning for a bad initializer component. 4709 MSGID identifies the message. 4710 The component name is taken from the spelling stack. */ 4711 4712static void 4713warning_init (msgid) 4714 const char *msgid; 4715{ 4716 char *ofwhat; 4717 4718 warning ("%s", _(msgid)); 4719 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4720 if (*ofwhat) 4721 warning ("(near initialization for `%s')", ofwhat); 4722} 4723 4724/* Digest the parser output INIT as an initializer for type TYPE. 4725 Return a C expression of type TYPE to represent the initial value. 4726 4727 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors 4728 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT 4729 applies only to elements of constructors. */ 4730 4731static tree 4732digest_init (type, init, require_constant, constructor_constant) 4733 tree type, init; 4734 int require_constant, constructor_constant; 4735{ 4736 enum tree_code code = TREE_CODE (type); 4737 tree inside_init = init; 4738 4739 if (type == error_mark_node 4740 || init == error_mark_node 4741 || TREE_TYPE (init) == error_mark_node) 4742 return error_mark_node; 4743 4744 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 4745 /* Do not use STRIP_NOPS here. We do not want an enumerator 4746 whose value is 0 to count as a null pointer constant. */ 4747 if (TREE_CODE (init) == NON_LVALUE_EXPR) 4748 inside_init = TREE_OPERAND (init, 0); 4749 4750 inside_init = fold (inside_init); 4751 4752 /* Initialization of an array of chars from a string constant 4753 optionally enclosed in braces. */ 4754 4755 if (code == ARRAY_TYPE) 4756 { 4757 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4758 if ((typ1 == char_type_node 4759 || typ1 == signed_char_type_node 4760 || typ1 == unsigned_char_type_node 4761 || typ1 == unsigned_wchar_type_node 4762 || typ1 == signed_wchar_type_node) 4763 && ((inside_init && TREE_CODE (inside_init) == STRING_CST))) 4764 { 4765 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4766 TYPE_MAIN_VARIANT (type))) 4767 return inside_init; 4768 4769 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4770 != char_type_node) 4771 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node)) 4772 { 4773 error_init ("char-array initialized from wide string"); 4774 return error_mark_node; 4775 } 4776 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4777 == char_type_node) 4778 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)) 4779 { 4780 error_init ("int-array initialized from non-wide string"); 4781 return error_mark_node; 4782 } 4783 4784 TREE_TYPE (inside_init) = type; 4785 if (TYPE_DOMAIN (type) != 0 4786 && TYPE_SIZE (type) != 0 4787 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 4788 /* Subtract 1 (or sizeof (wchar_t)) 4789 because it's ok to ignore the terminating null char 4790 that is counted in the length of the constant. */ 4791 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 4792 TREE_STRING_LENGTH (inside_init) 4793 - ((TYPE_PRECISION (typ1) 4794 != TYPE_PRECISION (char_type_node)) 4795 ? (TYPE_PRECISION (wchar_type_node) 4796 / BITS_PER_UNIT) 4797 : 1))) 4798 pedwarn_init ("initializer-string for array of chars is too long"); 4799 4800 return inside_init; 4801 } 4802 } 4803 4804 /* Any type can be initialized 4805 from an expression of the same type, optionally with braces. */ 4806 4807 if (inside_init && TREE_TYPE (inside_init) != 0 4808 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4809 TYPE_MAIN_VARIANT (type)) 4810 || (code == ARRAY_TYPE 4811 && comptypes (TREE_TYPE (inside_init), type)) 4812 || (code == POINTER_TYPE 4813 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 4814 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE) 4815 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4816 TREE_TYPE (type))))) 4817 { 4818 if (code == POINTER_TYPE) 4819 inside_init = default_function_array_conversion (inside_init); 4820 4821 if (require_constant && !flag_isoc99 4822 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4823 { 4824 /* As an extension, allow initializing objects with static storage 4825 duration with compound literals (which are then treated just as 4826 the brace enclosed list they contain). */ 4827 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 4828 inside_init = DECL_INITIAL (decl); 4829 } 4830 4831 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 4832 && TREE_CODE (inside_init) != CONSTRUCTOR) 4833 { 4834 error_init ("array initialized from non-constant array expression"); 4835 return error_mark_node; 4836 } 4837 4838 if (optimize && TREE_CODE (inside_init) == VAR_DECL) 4839 inside_init = decl_constant_value_for_broken_optimization (inside_init); 4840 4841 /* Compound expressions can only occur here if -pedantic or 4842 -pedantic-errors is specified. In the later case, we always want 4843 an error. In the former case, we simply want a warning. */ 4844 if (require_constant && pedantic 4845 && TREE_CODE (inside_init) == COMPOUND_EXPR) 4846 { 4847 inside_init 4848 = valid_compound_expr_initializer (inside_init, 4849 TREE_TYPE (inside_init)); 4850 if (inside_init == error_mark_node) 4851 error_init ("initializer element is not constant"); 4852 else 4853 pedwarn_init ("initializer element is not constant"); 4854 if (flag_pedantic_errors) 4855 inside_init = error_mark_node; 4856 } 4857 else if (require_constant 4858 && (!TREE_CONSTANT (inside_init) 4859 /* This test catches things like `7 / 0' which 4860 result in an expression for which TREE_CONSTANT 4861 is true, but which is not actually something 4862 that is a legal constant. We really should not 4863 be using this function, because it is a part of 4864 the back-end. Instead, the expression should 4865 already have been turned into ERROR_MARK_NODE. */ 4866 || !initializer_constant_valid_p (inside_init, 4867 TREE_TYPE (inside_init)))) 4868 { 4869 error_init ("initializer element is not constant"); 4870 inside_init = error_mark_node; 4871 } 4872 4873 return inside_init; 4874 } 4875 4876 /* Handle scalar types, including conversions. */ 4877 4878 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4879 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE) 4880 { 4881 /* Note that convert_for_assignment calls default_conversion 4882 for arrays and functions. We must not call it in the 4883 case where inside_init is a null pointer constant. */ 4884 inside_init 4885 = convert_for_assignment (type, init, _("initialization"), 4886 NULL_TREE, NULL_TREE, 0); 4887 4888 if (require_constant && ! TREE_CONSTANT (inside_init)) 4889 { 4890 error_init ("initializer element is not constant"); 4891 inside_init = error_mark_node; 4892 } 4893 else if (require_constant 4894 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0) 4895 { 4896 error_init ("initializer element is not computable at load time"); 4897 inside_init = error_mark_node; 4898 } 4899 4900 return inside_init; 4901 } 4902 4903 /* Come here only for records and arrays. */ 4904 4905 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 4906 { 4907 error_init ("variable-sized object may not be initialized"); 4908 return error_mark_node; 4909 } 4910 4911 /* Traditionally, you can write struct foo x = 0; 4912 and it initializes the first element of x to 0. */ 4913 if (flag_traditional) 4914 { 4915 tree top = 0, prev = 0, otype = type; 4916 while (TREE_CODE (type) == RECORD_TYPE 4917 || TREE_CODE (type) == ARRAY_TYPE 4918 || TREE_CODE (type) == QUAL_UNION_TYPE 4919 || TREE_CODE (type) == UNION_TYPE) 4920 { 4921 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE); 4922 if (prev == 0) 4923 top = temp; 4924 else 4925 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp); 4926 prev = temp; 4927 if (TREE_CODE (type) == ARRAY_TYPE) 4928 type = TREE_TYPE (type); 4929 else if (TYPE_FIELDS (type)) 4930 type = TREE_TYPE (TYPE_FIELDS (type)); 4931 else 4932 { 4933 error_init ("invalid initializer"); 4934 return error_mark_node; 4935 } 4936 } 4937 4938 if (otype != type) 4939 { 4940 TREE_OPERAND (prev, 1) 4941 = build_tree_list (NULL_TREE, 4942 digest_init (type, init, require_constant, 4943 constructor_constant)); 4944 return top; 4945 } 4946 else 4947 return error_mark_node; 4948 } 4949 error_init ("invalid initializer"); 4950 return error_mark_node; 4951} 4952 4953/* Handle initializers that use braces. */ 4954 4955/* Type of object we are accumulating a constructor for. 4956 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 4957static tree constructor_type; 4958 4959/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 4960 left to fill. */ 4961static tree constructor_fields; 4962 4963/* For an ARRAY_TYPE, this is the specified index 4964 at which to store the next element we get. */ 4965static tree constructor_index; 4966 4967/* For an ARRAY_TYPE, this is the maximum index. */ 4968static tree constructor_max_index; 4969 4970/* For a RECORD_TYPE, this is the first field not yet written out. */ 4971static tree constructor_unfilled_fields; 4972 4973/* For an ARRAY_TYPE, this is the index of the first element 4974 not yet written out. */ 4975static tree constructor_unfilled_index; 4976 4977/* In a RECORD_TYPE, the byte index of the next consecutive field. 4978 This is so we can generate gaps between fields, when appropriate. */ 4979static tree constructor_bit_index; 4980 4981/* If we are saving up the elements rather than allocating them, 4982 this is the list of elements so far (in reverse order, 4983 most recent first). */ 4984static tree constructor_elements; 4985 4986/* 1 if constructor should be incrementally stored into a constructor chain, 4987 0 if all the elements should be kept in AVL tree. */ 4988static int constructor_incremental; 4989 4990/* 1 if so far this constructor's elements are all compile-time constants. */ 4991static int constructor_constant; 4992 4993/* 1 if so far this constructor's elements are all valid address constants. */ 4994static int constructor_simple; 4995 4996/* 1 if this constructor is erroneous so far. */ 4997static int constructor_erroneous; 4998 4999/* 1 if have called defer_addressed_constants. */ 5000static int constructor_subconstants_deferred; 5001 5002/* Structure for managing pending initializer elements, organized as an 5003 AVL tree. */ 5004 5005struct init_node 5006{ 5007 struct init_node *left, *right; 5008 struct init_node *parent; 5009 int balance; 5010 tree purpose; 5011 tree value; 5012}; 5013 5014/* Tree of pending elements at this constructor level. 5015 These are elements encountered out of order 5016 which belong at places we haven't reached yet in actually 5017 writing the output. 5018 Will never hold tree nodes across GC runs. */ 5019static struct init_node *constructor_pending_elts; 5020 5021/* The SPELLING_DEPTH of this constructor. */ 5022static int constructor_depth; 5023 5024/* 0 if implicitly pushing constructor levels is allowed. */ 5025int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */ 5026 5027static int require_constant_value; 5028static int require_constant_elements; 5029 5030/* DECL node for which an initializer is being read. 5031 0 means we are reading a constructor expression 5032 such as (struct foo) {...}. */ 5033static tree constructor_decl; 5034 5035/* start_init saves the ASMSPEC arg here for really_start_incremental_init. */ 5036static const char *constructor_asmspec; 5037 5038/* Nonzero if this is an initializer for a top-level decl. */ 5039static int constructor_top_level; 5040 5041/* Nonzero if there were any member designators in this initializer. */ 5042static int constructor_designated; 5043 5044/* Nesting depth of designator list. */ 5045static int designator_depth; 5046 5047/* Nonzero if there were diagnosed errors in this designator list. */ 5048static int designator_errorneous; 5049 5050 5051/* This stack has a level for each implicit or explicit level of 5052 structuring in the initializer, including the outermost one. It 5053 saves the values of most of the variables above. */ 5054 5055struct constructor_range_stack; 5056 5057struct constructor_stack 5058{ 5059 struct constructor_stack *next; 5060 tree type; 5061 tree fields; 5062 tree index; 5063 tree max_index; 5064 tree unfilled_index; 5065 tree unfilled_fields; 5066 tree bit_index; 5067 tree elements; 5068 struct init_node *pending_elts; 5069 int offset; 5070 int depth; 5071 /* If nonzero, this value should replace the entire 5072 constructor at this level. */ 5073 tree replacement_value; 5074 struct constructor_range_stack *range_stack; 5075 char constant; 5076 char simple; 5077 char implicit; 5078 char erroneous; 5079 char outer; 5080 char incremental; 5081 char designated; 5082}; 5083 5084struct constructor_stack *constructor_stack; 5085 5086/* This stack represents designators from some range designator up to 5087 the last designator in the list. */ 5088 5089struct constructor_range_stack 5090{ 5091 struct constructor_range_stack *next, *prev; 5092 struct constructor_stack *stack; 5093 tree range_start; 5094 tree index; 5095 tree range_end; 5096 tree fields; 5097}; 5098 5099struct constructor_range_stack *constructor_range_stack; 5100 5101/* This stack records separate initializers that are nested. 5102 Nested initializers can't happen in ANSI C, but GNU C allows them 5103 in cases like { ... (struct foo) { ... } ... }. */ 5104 5105struct initializer_stack 5106{ 5107 struct initializer_stack *next; 5108 tree decl; 5109 const char *asmspec; 5110 struct constructor_stack *constructor_stack; 5111 struct constructor_range_stack *constructor_range_stack; 5112 tree elements; 5113 struct spelling *spelling; 5114 struct spelling *spelling_base; 5115 int spelling_size; 5116 char top_level; 5117 char require_constant_value; 5118 char require_constant_elements; 5119 char deferred; 5120}; 5121 5122struct initializer_stack *initializer_stack; 5123 5124/* Prepare to parse and output the initializer for variable DECL. */ 5125 5126void 5127start_init (decl, asmspec_tree, top_level) 5128 tree decl; 5129 tree asmspec_tree; 5130 int top_level; 5131{ 5132 const char *locus; 5133 struct initializer_stack *p 5134 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack)); 5135 const char *asmspec = 0; 5136 5137 if (asmspec_tree) 5138 asmspec = TREE_STRING_POINTER (asmspec_tree); 5139 5140 p->decl = constructor_decl; 5141 p->asmspec = constructor_asmspec; 5142 p->require_constant_value = require_constant_value; 5143 p->require_constant_elements = require_constant_elements; 5144 p->constructor_stack = constructor_stack; 5145 p->constructor_range_stack = constructor_range_stack; 5146 p->elements = constructor_elements; 5147 p->spelling = spelling; 5148 p->spelling_base = spelling_base; 5149 p->spelling_size = spelling_size; 5150 p->deferred = constructor_subconstants_deferred; 5151 p->top_level = constructor_top_level; 5152 p->next = initializer_stack; 5153 initializer_stack = p; 5154 5155 constructor_decl = decl; 5156 constructor_asmspec = asmspec; 5157 constructor_subconstants_deferred = 0; 5158 constructor_designated = 0; 5159 constructor_top_level = top_level; 5160 5161 if (decl != 0) 5162 { 5163 require_constant_value = TREE_STATIC (decl); 5164 require_constant_elements 5165 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 5166 /* For a scalar, you can always use any value to initialize, 5167 even within braces. */ 5168 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 5169 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 5170 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 5171 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 5172 locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 5173 } 5174 else 5175 { 5176 require_constant_value = 0; 5177 require_constant_elements = 0; 5178 locus = "(anonymous)"; 5179 } 5180 5181 constructor_stack = 0; 5182 constructor_range_stack = 0; 5183 5184 missing_braces_mentioned = 0; 5185 5186 spelling_base = 0; 5187 spelling_size = 0; 5188 RESTORE_SPELLING_DEPTH (0); 5189 5190 if (locus) 5191 push_string (locus); 5192} 5193 5194void 5195finish_init () 5196{ 5197 struct initializer_stack *p = initializer_stack; 5198 5199 /* Output subconstants (string constants, usually) 5200 that were referenced within this initializer and saved up. 5201 Must do this if and only if we called defer_addressed_constants. */ 5202 if (constructor_subconstants_deferred) 5203 output_deferred_addressed_constants (); 5204 5205 /* Free the whole constructor stack of this initializer. */ 5206 while (constructor_stack) 5207 { 5208 struct constructor_stack *q = constructor_stack; 5209 constructor_stack = q->next; 5210 free (q); 5211 } 5212 5213 if (constructor_range_stack) 5214 abort (); 5215 5216 /* Pop back to the data of the outer initializer (if any). */ 5217 constructor_decl = p->decl; 5218 constructor_asmspec = p->asmspec; 5219 require_constant_value = p->require_constant_value; 5220 require_constant_elements = p->require_constant_elements; 5221 constructor_stack = p->constructor_stack; 5222 constructor_range_stack = p->constructor_range_stack; 5223 constructor_elements = p->elements; 5224 spelling = p->spelling; 5225 spelling_base = p->spelling_base; 5226 spelling_size = p->spelling_size; 5227 constructor_subconstants_deferred = p->deferred; 5228 constructor_top_level = p->top_level; 5229 initializer_stack = p->next; 5230 free (p); 5231} 5232 5233/* Call here when we see the initializer is surrounded by braces. 5234 This is instead of a call to push_init_level; 5235 it is matched by a call to pop_init_level. 5236 5237 TYPE is the type to initialize, for a constructor expression. 5238 For an initializer for a decl, TYPE is zero. */ 5239 5240void 5241really_start_incremental_init (type) 5242 tree type; 5243{ 5244 struct constructor_stack *p 5245 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack)); 5246 5247 if (type == 0) 5248 type = TREE_TYPE (constructor_decl); 5249 5250 p->type = constructor_type; 5251 p->fields = constructor_fields; 5252 p->index = constructor_index; 5253 p->max_index = constructor_max_index; 5254 p->unfilled_index = constructor_unfilled_index; 5255 p->unfilled_fields = constructor_unfilled_fields; 5256 p->bit_index = constructor_bit_index; 5257 p->elements = constructor_elements; 5258 p->constant = constructor_constant; 5259 p->simple = constructor_simple; 5260 p->erroneous = constructor_erroneous; 5261 p->pending_elts = constructor_pending_elts; 5262 p->depth = constructor_depth; 5263 p->replacement_value = 0; 5264 p->implicit = 0; 5265 p->range_stack = 0; 5266 p->outer = 0; 5267 p->incremental = constructor_incremental; 5268 p->designated = constructor_designated; 5269 p->next = 0; 5270 constructor_stack = p; 5271 5272 constructor_constant = 1; 5273 constructor_simple = 1; 5274 constructor_depth = SPELLING_DEPTH (); 5275 constructor_elements = 0; 5276 constructor_pending_elts = 0; 5277 constructor_type = type; 5278 constructor_incremental = 1; 5279 constructor_designated = 0; 5280 designator_depth = 0; 5281 designator_errorneous = 0; 5282 5283 if (TREE_CODE (constructor_type) == RECORD_TYPE 5284 || TREE_CODE (constructor_type) == UNION_TYPE) 5285 { 5286 constructor_fields = TYPE_FIELDS (constructor_type); 5287 /* Skip any nameless bit fields at the beginning. */ 5288 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5289 && DECL_NAME (constructor_fields) == 0) 5290 constructor_fields = TREE_CHAIN (constructor_fields); 5291 5292 constructor_unfilled_fields = constructor_fields; 5293 constructor_bit_index = bitsize_zero_node; 5294 } 5295 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5296 { 5297 if (TYPE_DOMAIN (constructor_type)) 5298 { 5299 constructor_max_index 5300 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5301 5302 /* Detect non-empty initializations of zero-length arrays. */ 5303 if (constructor_max_index == NULL_TREE 5304 && TYPE_SIZE (constructor_type)) 5305 constructor_max_index = build_int_2 (-1, -1); 5306 5307 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5308 to initialize VLAs will cause an proper error; avoid tree 5309 checking errors as well by setting a safe value. */ 5310 if (constructor_max_index 5311 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5312 constructor_max_index = build_int_2 (-1, -1); 5313 5314 constructor_index 5315 = convert (bitsizetype, 5316 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5317 } 5318 else 5319 constructor_index = bitsize_zero_node; 5320 5321 constructor_unfilled_index = constructor_index; 5322 } 5323 else 5324 { 5325 /* Handle the case of int x = {5}; */ 5326 constructor_fields = constructor_type; 5327 constructor_unfilled_fields = constructor_type; 5328 } 5329} 5330 5331/* Push down into a subobject, for initialization. 5332 If this is for an explicit set of braces, IMPLICIT is 0. 5333 If it is because the next element belongs at a lower level, 5334 IMPLICIT is 1 (or 2 if the push is because of designator list). */ 5335 5336void 5337push_init_level (implicit) 5338 int implicit; 5339{ 5340 struct constructor_stack *p; 5341 tree value = NULL_TREE; 5342 5343 /* If we've exhausted any levels that didn't have braces, 5344 pop them now. */ 5345 while (constructor_stack->implicit) 5346 { 5347 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5348 || TREE_CODE (constructor_type) == UNION_TYPE) 5349 && constructor_fields == 0) 5350 process_init_element (pop_init_level (1)); 5351 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5352 && tree_int_cst_lt (constructor_max_index, constructor_index)) 5353 process_init_element (pop_init_level (1)); 5354 else 5355 break; 5356 } 5357 5358 /* Unless this is an explicit brace, we need to preserve previous 5359 content if any. */ 5360 if (implicit) 5361 { 5362 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5363 || TREE_CODE (constructor_type) == UNION_TYPE) 5364 && constructor_fields) 5365 value = find_init_member (constructor_fields); 5366 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5367 value = find_init_member (constructor_index); 5368 } 5369 5370 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack)); 5371 p->type = constructor_type; 5372 p->fields = constructor_fields; 5373 p->index = constructor_index; 5374 p->max_index = constructor_max_index; 5375 p->unfilled_index = constructor_unfilled_index; 5376 p->unfilled_fields = constructor_unfilled_fields; 5377 p->bit_index = constructor_bit_index; 5378 p->elements = constructor_elements; 5379 p->constant = constructor_constant; 5380 p->simple = constructor_simple; 5381 p->erroneous = constructor_erroneous; 5382 p->pending_elts = constructor_pending_elts; 5383 p->depth = constructor_depth; 5384 p->replacement_value = 0; 5385 p->implicit = implicit; 5386 p->outer = 0; 5387 p->incremental = constructor_incremental; 5388 p->designated = constructor_designated; 5389 p->next = constructor_stack; 5390 p->range_stack = 0; 5391 constructor_stack = p; 5392 5393 constructor_constant = 1; 5394 constructor_simple = 1; 5395 constructor_depth = SPELLING_DEPTH (); 5396 constructor_elements = 0; 5397 constructor_incremental = 1; 5398 constructor_designated = 0; 5399 constructor_pending_elts = 0; 5400 if (!implicit) 5401 { 5402 p->range_stack = constructor_range_stack; 5403 constructor_range_stack = 0; 5404 designator_depth = 0; 5405 designator_errorneous = 0; 5406 } 5407 5408 /* Don't die if an entire brace-pair level is superfluous 5409 in the containing level. */ 5410 if (constructor_type == 0) 5411 ; 5412 else if (TREE_CODE (constructor_type) == RECORD_TYPE 5413 || TREE_CODE (constructor_type) == UNION_TYPE) 5414 { 5415 /* Don't die if there are extra init elts at the end. */ 5416 if (constructor_fields == 0) 5417 constructor_type = 0; 5418 else 5419 { 5420 constructor_type = TREE_TYPE (constructor_fields); 5421 push_member_name (constructor_fields); 5422 constructor_depth++; 5423 } 5424 } 5425 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5426 { 5427 constructor_type = TREE_TYPE (constructor_type); 5428 push_array_bounds (tree_low_cst (constructor_index, 0)); 5429 constructor_depth++; 5430 } 5431 5432 if (constructor_type == 0) 5433 { 5434 error_init ("extra brace group at end of initializer"); 5435 constructor_fields = 0; 5436 constructor_unfilled_fields = 0; 5437 return; 5438 } 5439 5440 if (value && TREE_CODE (value) == CONSTRUCTOR) 5441 { 5442 constructor_constant = TREE_CONSTANT (value); 5443 constructor_simple = TREE_STATIC (value); 5444 constructor_elements = TREE_OPERAND (value, 1); 5445 if (constructor_elements 5446 && (TREE_CODE (constructor_type) == RECORD_TYPE 5447 || TREE_CODE (constructor_type) == ARRAY_TYPE)) 5448 set_nonincremental_init (); 5449 } 5450 5451 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 5452 { 5453 missing_braces_mentioned = 1; 5454 warning_init ("missing braces around initializer"); 5455 } 5456 5457 if (TREE_CODE (constructor_type) == RECORD_TYPE 5458 || TREE_CODE (constructor_type) == UNION_TYPE) 5459 { 5460 constructor_fields = TYPE_FIELDS (constructor_type); 5461 /* Skip any nameless bit fields at the beginning. */ 5462 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5463 && DECL_NAME (constructor_fields) == 0) 5464 constructor_fields = TREE_CHAIN (constructor_fields); 5465 5466 constructor_unfilled_fields = constructor_fields; 5467 constructor_bit_index = bitsize_zero_node; 5468 } 5469 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5470 { 5471 if (TYPE_DOMAIN (constructor_type)) 5472 { 5473 constructor_max_index 5474 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5475 5476 /* Detect non-empty initializations of zero-length arrays. */ 5477 if (constructor_max_index == NULL_TREE 5478 && TYPE_SIZE (constructor_type)) 5479 constructor_max_index = build_int_2 (-1, -1); 5480 5481 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5482 to initialize VLAs will cause an proper error; avoid tree 5483 checking errors as well by setting a safe value. */ 5484 if (constructor_max_index 5485 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5486 constructor_max_index = build_int_2 (-1, -1); 5487 5488 constructor_index 5489 = convert (bitsizetype, 5490 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5491 } 5492 else 5493 constructor_index = bitsize_zero_node; 5494 5495 constructor_unfilled_index = constructor_index; 5496 if (value && TREE_CODE (value) == STRING_CST) 5497 { 5498 /* We need to split the char/wchar array into individual 5499 characters, so that we don't have to special case it 5500 everywhere. */ 5501 set_nonincremental_init_from_string (value); 5502 } 5503 } 5504 else 5505 { 5506 warning_init ("braces around scalar initializer"); 5507 constructor_fields = constructor_type; 5508 constructor_unfilled_fields = constructor_type; 5509 } 5510} 5511 5512/* At the end of an implicit or explicit brace level, 5513 finish up that level of constructor. 5514 If we were outputting the elements as they are read, return 0 5515 from inner levels (process_init_element ignores that), 5516 but return error_mark_node from the outermost level 5517 (that's what we want to put in DECL_INITIAL). 5518 Otherwise, return a CONSTRUCTOR expression. */ 5519 5520tree 5521pop_init_level (implicit) 5522 int implicit; 5523{ 5524 struct constructor_stack *p; 5525 tree constructor = 0; 5526 5527 if (implicit == 0) 5528 { 5529 /* When we come to an explicit close brace, 5530 pop any inner levels that didn't have explicit braces. */ 5531 while (constructor_stack->implicit) 5532 process_init_element (pop_init_level (1)); 5533 5534 if (constructor_range_stack) 5535 abort (); 5536 } 5537 5538 p = constructor_stack; 5539 5540 /* Error for initializing a flexible array member, or a zero-length 5541 array member in an inappropriate context. */ 5542 if (constructor_type && constructor_fields 5543 && TREE_CODE (constructor_type) == ARRAY_TYPE 5544 && TYPE_DOMAIN (constructor_type) 5545 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 5546 { 5547 /* Silently discard empty initializations. The parser will 5548 already have pedwarned for empty brackets. */ 5549 if (integer_zerop (constructor_unfilled_index)) 5550 constructor_type = NULL_TREE; 5551 else if (! TYPE_SIZE (constructor_type)) 5552 { 5553 if (constructor_depth > 2) 5554 error_init ("initialization of flexible array member in a nested context"); 5555 else if (pedantic) 5556 pedwarn_init ("initialization of a flexible array member"); 5557 5558 /* We have already issued an error message for the existence 5559 of a flexible array member not at the end of the structure. 5560 Discard the initializer so that we do not abort later. */ 5561 if (TREE_CHAIN (constructor_fields) != NULL_TREE) 5562 constructor_type = NULL_TREE; 5563 } 5564 else 5565 /* Zero-length arrays are no longer special, so we should no longer 5566 get here. */ 5567 abort (); 5568 } 5569 5570 /* Warn when some struct elements are implicitly initialized to zero. */ 5571 if (extra_warnings 5572 && constructor_type 5573 && TREE_CODE (constructor_type) == RECORD_TYPE 5574 && constructor_unfilled_fields) 5575 { 5576 /* Do not warn for flexible array members or zero-length arrays. */ 5577 while (constructor_unfilled_fields 5578 && (! DECL_SIZE (constructor_unfilled_fields) 5579 || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 5580 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5581 5582 /* Do not warn if this level of the initializer uses member 5583 designators; it is likely to be deliberate. */ 5584 if (constructor_unfilled_fields && !constructor_designated) 5585 { 5586 push_member_name (constructor_unfilled_fields); 5587 warning_init ("missing initializer"); 5588 RESTORE_SPELLING_DEPTH (constructor_depth); 5589 } 5590 } 5591 5592 /* Now output all pending elements. */ 5593 constructor_incremental = 1; 5594 output_pending_init_elements (1); 5595 5596 /* Pad out the end of the structure. */ 5597 if (p->replacement_value) 5598 /* If this closes a superfluous brace pair, 5599 just pass out the element between them. */ 5600 constructor = p->replacement_value; 5601 else if (constructor_type == 0) 5602 ; 5603 else if (TREE_CODE (constructor_type) != RECORD_TYPE 5604 && TREE_CODE (constructor_type) != UNION_TYPE 5605 && TREE_CODE (constructor_type) != ARRAY_TYPE) 5606 { 5607 /* A nonincremental scalar initializer--just return 5608 the element, after verifying there is just one. */ 5609 if (constructor_elements == 0) 5610 { 5611 if (!constructor_erroneous) 5612 error_init ("empty scalar initializer"); 5613 constructor = error_mark_node; 5614 } 5615 else if (TREE_CHAIN (constructor_elements) != 0) 5616 { 5617 error_init ("extra elements in scalar initializer"); 5618 constructor = TREE_VALUE (constructor_elements); 5619 } 5620 else 5621 constructor = TREE_VALUE (constructor_elements); 5622 } 5623 else 5624 { 5625 if (constructor_erroneous) 5626 constructor = error_mark_node; 5627 else 5628 { 5629 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE, 5630 nreverse (constructor_elements)); 5631 if (constructor_constant) 5632 TREE_CONSTANT (constructor) = 1; 5633 if (constructor_constant && constructor_simple) 5634 TREE_STATIC (constructor) = 1; 5635 } 5636 } 5637 5638 constructor_type = p->type; 5639 constructor_fields = p->fields; 5640 constructor_index = p->index; 5641 constructor_max_index = p->max_index; 5642 constructor_unfilled_index = p->unfilled_index; 5643 constructor_unfilled_fields = p->unfilled_fields; 5644 constructor_bit_index = p->bit_index; 5645 constructor_elements = p->elements; 5646 constructor_constant = p->constant; 5647 constructor_simple = p->simple; 5648 constructor_erroneous = p->erroneous; 5649 constructor_incremental = p->incremental; 5650 constructor_designated = p->designated; 5651 constructor_pending_elts = p->pending_elts; 5652 constructor_depth = p->depth; 5653 if (!p->implicit) 5654 constructor_range_stack = p->range_stack; 5655 RESTORE_SPELLING_DEPTH (constructor_depth); 5656 5657 constructor_stack = p->next; 5658 free (p); 5659 5660 if (constructor == 0) 5661 { 5662 if (constructor_stack == 0) 5663 return error_mark_node; 5664 return NULL_TREE; 5665 } 5666 return constructor; 5667} 5668 5669/* Common handling for both array range and field name designators. 5670 ARRAY argument is non-zero for array ranges. Returns zero for success. */ 5671 5672static int 5673set_designator (array) 5674 int array; 5675{ 5676 tree subtype; 5677 enum tree_code subcode; 5678 5679 /* Don't die if an entire brace-pair level is superfluous 5680 in the containing level. */ 5681 if (constructor_type == 0) 5682 return 1; 5683 5684 /* If there were errors in this designator list already, bail out silently. */ 5685 if (designator_errorneous) 5686 return 1; 5687 5688 if (!designator_depth) 5689 { 5690 if (constructor_range_stack) 5691 abort (); 5692 5693 /* Designator list starts at the level of closest explicit 5694 braces. */ 5695 while (constructor_stack->implicit) 5696 process_init_element (pop_init_level (1)); 5697 constructor_designated = 1; 5698 return 0; 5699 } 5700 5701 if (constructor_no_implicit) 5702 { 5703 error_init ("initialization designators may not nest"); 5704 return 1; 5705 } 5706 5707 if (TREE_CODE (constructor_type) == RECORD_TYPE 5708 || TREE_CODE (constructor_type) == UNION_TYPE) 5709 { 5710 subtype = TREE_TYPE (constructor_fields); 5711 if (subtype != error_mark_node) 5712 subtype = TYPE_MAIN_VARIANT (subtype); 5713 } 5714 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5715 { 5716 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5717 } 5718 else 5719 abort (); 5720 5721 subcode = TREE_CODE (subtype); 5722 if (array && subcode != ARRAY_TYPE) 5723 { 5724 error_init ("array index in non-array initializer"); 5725 return 1; 5726 } 5727 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 5728 { 5729 error_init ("field name not in record or union initializer"); 5730 return 1; 5731 } 5732 5733 constructor_designated = 1; 5734 push_init_level (2); 5735 return 0; 5736} 5737 5738/* If there are range designators in designator list, push a new designator 5739 to constructor_range_stack. RANGE_END is end of such stack range or 5740 NULL_TREE if there is no range designator at this level. */ 5741 5742static void 5743push_range_stack (range_end) 5744 tree range_end; 5745{ 5746 struct constructor_range_stack *p; 5747 5748 p = (struct constructor_range_stack *) 5749 ggc_alloc (sizeof (struct constructor_range_stack)); 5750 p->prev = constructor_range_stack; 5751 p->next = 0; 5752 p->fields = constructor_fields; 5753 p->range_start = constructor_index; 5754 p->index = constructor_index; 5755 p->stack = constructor_stack; 5756 p->range_end = range_end; 5757 if (constructor_range_stack) 5758 constructor_range_stack->next = p; 5759 constructor_range_stack = p; 5760} 5761 5762/* Within an array initializer, specify the next index to be initialized. 5763 FIRST is that index. If LAST is nonzero, then initialize a range 5764 of indices, running from FIRST through LAST. */ 5765 5766void 5767set_init_index (first, last) 5768 tree first, last; 5769{ 5770 if (set_designator (1)) 5771 return; 5772 5773 designator_errorneous = 1; 5774 5775 while ((TREE_CODE (first) == NOP_EXPR 5776 || TREE_CODE (first) == CONVERT_EXPR 5777 || TREE_CODE (first) == NON_LVALUE_EXPR) 5778 && (TYPE_MODE (TREE_TYPE (first)) 5779 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0))))) 5780 first = TREE_OPERAND (first, 0); 5781 5782 if (last) 5783 while ((TREE_CODE (last) == NOP_EXPR 5784 || TREE_CODE (last) == CONVERT_EXPR 5785 || TREE_CODE (last) == NON_LVALUE_EXPR) 5786 && (TYPE_MODE (TREE_TYPE (last)) 5787 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0))))) 5788 last = TREE_OPERAND (last, 0); 5789 5790 if (TREE_CODE (first) != INTEGER_CST) 5791 error_init ("nonconstant array index in initializer"); 5792 else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 5793 error_init ("nonconstant array index in initializer"); 5794 else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 5795 error_init ("array index in non-array initializer"); 5796 else if (constructor_max_index 5797 && tree_int_cst_lt (constructor_max_index, first)) 5798 error_init ("array index in initializer exceeds array bounds"); 5799 else 5800 { 5801 constructor_index = convert (bitsizetype, first); 5802 5803 if (last) 5804 { 5805 if (tree_int_cst_equal (first, last)) 5806 last = 0; 5807 else if (tree_int_cst_lt (last, first)) 5808 { 5809 error_init ("empty index range in initializer"); 5810 last = 0; 5811 } 5812 else 5813 { 5814 last = convert (bitsizetype, last); 5815 if (constructor_max_index != 0 5816 && tree_int_cst_lt (constructor_max_index, last)) 5817 { 5818 error_init ("array index range in initializer exceeds array bounds"); 5819 last = 0; 5820 } 5821 } 5822 } 5823 5824 designator_depth++; 5825 designator_errorneous = 0; 5826 if (constructor_range_stack || last) 5827 push_range_stack (last); 5828 } 5829} 5830 5831/* Within a struct initializer, specify the next field to be initialized. */ 5832 5833void 5834set_init_label (fieldname) 5835 tree fieldname; 5836{ 5837 tree tail; 5838 5839 if (set_designator (0)) 5840 return; 5841 5842 designator_errorneous = 1; 5843 5844 if (TREE_CODE (constructor_type) != RECORD_TYPE 5845 && TREE_CODE (constructor_type) != UNION_TYPE) 5846 { 5847 error_init ("field name not in record or union initializer"); 5848 return; 5849 } 5850 5851 for (tail = TYPE_FIELDS (constructor_type); tail; 5852 tail = TREE_CHAIN (tail)) 5853 { 5854 if (DECL_NAME (tail) == fieldname) 5855 break; 5856 } 5857 5858 if (tail == 0) 5859 error ("unknown field `%s' specified in initializer", 5860 IDENTIFIER_POINTER (fieldname)); 5861 else 5862 { 5863 constructor_fields = tail; 5864 designator_depth++; 5865 designator_errorneous = 0; 5866 if (constructor_range_stack) 5867 push_range_stack (NULL_TREE); 5868 } 5869} 5870 5871/* Add a new initializer to the tree of pending initializers. PURPOSE 5872 identifies the initializer, either array index or field in a structure. 5873 VALUE is the value of that index or field. */ 5874 5875static void 5876add_pending_init (purpose, value) 5877 tree purpose, value; 5878{ 5879 struct init_node *p, **q, *r; 5880 5881 q = &constructor_pending_elts; 5882 p = 0; 5883 5884 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5885 { 5886 while (*q != 0) 5887 { 5888 p = *q; 5889 if (tree_int_cst_lt (purpose, p->purpose)) 5890 q = &p->left; 5891 else if (tree_int_cst_lt (p->purpose, purpose)) 5892 q = &p->right; 5893 else 5894 { 5895 if (TREE_SIDE_EFFECTS (p->value)) 5896 warning_init ("initialized field with side-effects overwritten"); 5897 p->value = value; 5898 return; 5899 } 5900 } 5901 } 5902 else 5903 { 5904 tree bitpos; 5905 5906 bitpos = bit_position (purpose); 5907 while (*q != NULL) 5908 { 5909 p = *q; 5910 if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 5911 q = &p->left; 5912 else if (p->purpose != purpose) 5913 q = &p->right; 5914 else 5915 { 5916 if (TREE_SIDE_EFFECTS (p->value)) 5917 warning_init ("initialized field with side-effects overwritten"); 5918 p->value = value; 5919 return; 5920 } 5921 } 5922 } 5923 5924 r = (struct init_node *) ggc_alloc (sizeof (struct init_node)); 5925 r->purpose = purpose; 5926 r->value = value; 5927 5928 *q = r; 5929 r->parent = p; 5930 r->left = 0; 5931 r->right = 0; 5932 r->balance = 0; 5933 5934 while (p) 5935 { 5936 struct init_node *s; 5937 5938 if (r == p->left) 5939 { 5940 if (p->balance == 0) 5941 p->balance = -1; 5942 else if (p->balance < 0) 5943 { 5944 if (r->balance < 0) 5945 { 5946 /* L rotation. */ 5947 p->left = r->right; 5948 if (p->left) 5949 p->left->parent = p; 5950 r->right = p; 5951 5952 p->balance = 0; 5953 r->balance = 0; 5954 5955 s = p->parent; 5956 p->parent = r; 5957 r->parent = s; 5958 if (s) 5959 { 5960 if (s->left == p) 5961 s->left = r; 5962 else 5963 s->right = r; 5964 } 5965 else 5966 constructor_pending_elts = r; 5967 } 5968 else 5969 { 5970 /* LR rotation. */ 5971 struct init_node *t = r->right; 5972 5973 r->right = t->left; 5974 if (r->right) 5975 r->right->parent = r; 5976 t->left = r; 5977 5978 p->left = t->right; 5979 if (p->left) 5980 p->left->parent = p; 5981 t->right = p; 5982 5983 p->balance = t->balance < 0; 5984 r->balance = -(t->balance > 0); 5985 t->balance = 0; 5986 5987 s = p->parent; 5988 p->parent = t; 5989 r->parent = t; 5990 t->parent = s; 5991 if (s) 5992 { 5993 if (s->left == p) 5994 s->left = t; 5995 else 5996 s->right = t; 5997 } 5998 else 5999 constructor_pending_elts = t; 6000 } 6001 break; 6002 } 6003 else 6004 { 6005 /* p->balance == +1; growth of left side balances the node. */ 6006 p->balance = 0; 6007 break; 6008 } 6009 } 6010 else /* r == p->right */ 6011 { 6012 if (p->balance == 0) 6013 /* Growth propagation from right side. */ 6014 p->balance++; 6015 else if (p->balance > 0) 6016 { 6017 if (r->balance > 0) 6018 { 6019 /* R rotation. */ 6020 p->right = r->left; 6021 if (p->right) 6022 p->right->parent = p; 6023 r->left = p; 6024 6025 p->balance = 0; 6026 r->balance = 0; 6027 6028 s = p->parent; 6029 p->parent = r; 6030 r->parent = s; 6031 if (s) 6032 { 6033 if (s->left == p) 6034 s->left = r; 6035 else 6036 s->right = r; 6037 } 6038 else 6039 constructor_pending_elts = r; 6040 } 6041 else /* r->balance == -1 */ 6042 { 6043 /* RL rotation */ 6044 struct init_node *t = r->left; 6045 6046 r->left = t->right; 6047 if (r->left) 6048 r->left->parent = r; 6049 t->right = r; 6050 6051 p->right = t->left; 6052 if (p->right) 6053 p->right->parent = p; 6054 t->left = p; 6055 6056 r->balance = (t->balance < 0); 6057 p->balance = -(t->balance > 0); 6058 t->balance = 0; 6059 6060 s = p->parent; 6061 p->parent = t; 6062 r->parent = t; 6063 t->parent = s; 6064 if (s) 6065 { 6066 if (s->left == p) 6067 s->left = t; 6068 else 6069 s->right = t; 6070 } 6071 else 6072 constructor_pending_elts = t; 6073 } 6074 break; 6075 } 6076 else 6077 { 6078 /* p->balance == -1; growth of right side balances the node. */ 6079 p->balance = 0; 6080 break; 6081 } 6082 } 6083 6084 r = p; 6085 p = p->parent; 6086 } 6087} 6088 6089/* Build AVL tree from a sorted chain. */ 6090 6091static void 6092set_nonincremental_init () 6093{ 6094 tree chain; 6095 6096 if (TREE_CODE (constructor_type) != RECORD_TYPE 6097 && TREE_CODE (constructor_type) != ARRAY_TYPE) 6098 return; 6099 6100 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain)) 6101 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain)); 6102 constructor_elements = 0; 6103 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6104 { 6105 constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 6106 /* Skip any nameless bit fields at the beginning. */ 6107 while (constructor_unfilled_fields != 0 6108 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6109 && DECL_NAME (constructor_unfilled_fields) == 0) 6110 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 6111 6112 } 6113 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6114 { 6115 if (TYPE_DOMAIN (constructor_type)) 6116 constructor_unfilled_index 6117 = convert (bitsizetype, 6118 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 6119 else 6120 constructor_unfilled_index = bitsize_zero_node; 6121 } 6122 constructor_incremental = 0; 6123} 6124 6125/* Build AVL tree from a string constant. */ 6126 6127static void 6128set_nonincremental_init_from_string (str) 6129 tree str; 6130{ 6131 tree value, purpose, type; 6132 HOST_WIDE_INT val[2]; 6133 const char *p, *end; 6134 int byte, wchar_bytes, charwidth, bitpos; 6135 6136 if (TREE_CODE (constructor_type) != ARRAY_TYPE) 6137 abort (); 6138 6139 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6140 == TYPE_PRECISION (char_type_node)) 6141 wchar_bytes = 1; 6142 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6143 == TYPE_PRECISION (wchar_type_node)) 6144 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6145 else 6146 abort (); 6147 6148 charwidth = TYPE_PRECISION (char_type_node); 6149 type = TREE_TYPE (constructor_type); 6150 p = TREE_STRING_POINTER (str); 6151 end = p + TREE_STRING_LENGTH (str); 6152 6153 for (purpose = bitsize_zero_node; 6154 p < end && !tree_int_cst_lt (constructor_max_index, purpose); 6155 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 6156 { 6157 if (wchar_bytes == 1) 6158 { 6159 val[1] = (unsigned char) *p++; 6160 val[0] = 0; 6161 } 6162 else 6163 { 6164 val[0] = 0; 6165 val[1] = 0; 6166 for (byte = 0; byte < wchar_bytes; byte++) 6167 { 6168 if (BYTES_BIG_ENDIAN) 6169 bitpos = (wchar_bytes - byte - 1) * charwidth; 6170 else 6171 bitpos = byte * charwidth; 6172 val[bitpos < HOST_BITS_PER_WIDE_INT] 6173 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 6174 << (bitpos % HOST_BITS_PER_WIDE_INT); 6175 } 6176 } 6177 6178 if (!TREE_UNSIGNED (type)) 6179 { 6180 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 6181 if (bitpos < HOST_BITS_PER_WIDE_INT) 6182 { 6183 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 6184 { 6185 val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 6186 val[0] = -1; 6187 } 6188 } 6189 else if (bitpos == HOST_BITS_PER_WIDE_INT) 6190 { 6191 if (val[1] < 0) 6192 val[0] = -1; 6193 } 6194 else if (val[0] & (((HOST_WIDE_INT) 1) 6195 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 6196 val[0] |= ((HOST_WIDE_INT) -1) 6197 << (bitpos - HOST_BITS_PER_WIDE_INT); 6198 } 6199 6200 value = build_int_2 (val[1], val[0]); 6201 TREE_TYPE (value) = type; 6202 add_pending_init (purpose, value); 6203 } 6204 6205 constructor_incremental = 0; 6206} 6207 6208/* Return value of FIELD in pending initializer or zero if the field was 6209 not initialized yet. */ 6210 6211static tree 6212find_init_member (field) 6213 tree field; 6214{ 6215 struct init_node *p; 6216 6217 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6218 { 6219 if (constructor_incremental 6220 && tree_int_cst_lt (field, constructor_unfilled_index)) 6221 set_nonincremental_init (); 6222 6223 p = constructor_pending_elts; 6224 while (p) 6225 { 6226 if (tree_int_cst_lt (field, p->purpose)) 6227 p = p->left; 6228 else if (tree_int_cst_lt (p->purpose, field)) 6229 p = p->right; 6230 else 6231 return p->value; 6232 } 6233 } 6234 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6235 { 6236 tree bitpos = bit_position (field); 6237 6238 if (constructor_incremental 6239 && (!constructor_unfilled_fields 6240 || tree_int_cst_lt (bitpos, 6241 bit_position (constructor_unfilled_fields)))) 6242 set_nonincremental_init (); 6243 6244 p = constructor_pending_elts; 6245 while (p) 6246 { 6247 if (field == p->purpose) 6248 return p->value; 6249 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 6250 p = p->left; 6251 else 6252 p = p->right; 6253 } 6254 } 6255 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6256 { 6257 if (constructor_elements 6258 && TREE_PURPOSE (constructor_elements) == field) 6259 return TREE_VALUE (constructor_elements); 6260 } 6261 return 0; 6262} 6263 6264/* "Output" the next constructor element. 6265 At top level, really output it to assembler code now. 6266 Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 6267 TYPE is the data type that the containing data type wants here. 6268 FIELD is the field (a FIELD_DECL) or the index that this element fills. 6269 6270 PENDING if non-nil means output pending elements that belong 6271 right after this element. (PENDING is normally 1; 6272 it is 0 while outputting pending elements, to avoid recursion.) */ 6273 6274static void 6275output_init_element (value, type, field, pending) 6276 tree value, type, field; 6277 int pending; 6278{ 6279 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE 6280 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6281 && !(TREE_CODE (value) == STRING_CST 6282 && TREE_CODE (type) == ARRAY_TYPE 6283 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE) 6284 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6285 TYPE_MAIN_VARIANT (type)))) 6286 value = default_conversion (value); 6287 6288 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 6289 && require_constant_value && !flag_isoc99 && pending) 6290 { 6291 /* As an extension, allow initializing objects with static storage 6292 duration with compound literals (which are then treated just as 6293 the brace enclosed list they contain). */ 6294 tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 6295 value = DECL_INITIAL (decl); 6296 } 6297 6298 if (value == error_mark_node) 6299 constructor_erroneous = 1; 6300 else if (!TREE_CONSTANT (value)) 6301 constructor_constant = 0; 6302 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0 6303 || ((TREE_CODE (constructor_type) == RECORD_TYPE 6304 || TREE_CODE (constructor_type) == UNION_TYPE) 6305 && DECL_C_BIT_FIELD (field) 6306 && TREE_CODE (value) != INTEGER_CST)) 6307 constructor_simple = 0; 6308 6309 if (require_constant_value && ! TREE_CONSTANT (value)) 6310 { 6311 error_init ("initializer element is not constant"); 6312 value = error_mark_node; 6313 } 6314 else if (require_constant_elements 6315 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0) 6316 pedwarn ("initializer element is not computable at load time"); 6317 6318 /* If this field is empty (and not at the end of structure), 6319 don't do anything other than checking the initializer. */ 6320 if (field 6321 && (TREE_TYPE (field) == error_mark_node 6322 || (COMPLETE_TYPE_P (TREE_TYPE (field)) 6323 && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 6324 && (TREE_CODE (constructor_type) == ARRAY_TYPE 6325 || TREE_CHAIN (field))))) 6326 return; 6327 6328 value = digest_init (type, value, require_constant_value, 6329 require_constant_elements); 6330 if (value == error_mark_node) 6331 { 6332 constructor_erroneous = 1; 6333 return; 6334 } 6335 6336 /* If this element doesn't come next in sequence, 6337 put it on constructor_pending_elts. */ 6338 if (TREE_CODE (constructor_type) == ARRAY_TYPE 6339 && (!constructor_incremental 6340 || !tree_int_cst_equal (field, constructor_unfilled_index))) 6341 { 6342 if (constructor_incremental 6343 && tree_int_cst_lt (field, constructor_unfilled_index)) 6344 set_nonincremental_init (); 6345 6346 add_pending_init (field, value); 6347 return; 6348 } 6349 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6350 && (!constructor_incremental 6351 || field != constructor_unfilled_fields)) 6352 { 6353 /* We do this for records but not for unions. In a union, 6354 no matter which field is specified, it can be initialized 6355 right away since it starts at the beginning of the union. */ 6356 if (constructor_incremental) 6357 { 6358 if (!constructor_unfilled_fields) 6359 set_nonincremental_init (); 6360 else 6361 { 6362 tree bitpos, unfillpos; 6363 6364 bitpos = bit_position (field); 6365 unfillpos = bit_position (constructor_unfilled_fields); 6366 6367 if (tree_int_cst_lt (bitpos, unfillpos)) 6368 set_nonincremental_init (); 6369 } 6370 } 6371 6372 add_pending_init (field, value); 6373 return; 6374 } 6375 else if (TREE_CODE (constructor_type) == UNION_TYPE 6376 && constructor_elements) 6377 { 6378 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements))) 6379 warning_init ("initialized field with side-effects overwritten"); 6380 6381 /* We can have just one union field set. */ 6382 constructor_elements = 0; 6383 } 6384 6385 /* Otherwise, output this element either to 6386 constructor_elements or to the assembler file. */ 6387 6388 if (field && TREE_CODE (field) == INTEGER_CST) 6389 field = copy_node (field); 6390 constructor_elements 6391 = tree_cons (field, value, constructor_elements); 6392 6393 /* Advance the variable that indicates sequential elements output. */ 6394 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6395 constructor_unfilled_index 6396 = size_binop (PLUS_EXPR, constructor_unfilled_index, 6397 bitsize_one_node); 6398 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6399 { 6400 constructor_unfilled_fields 6401 = TREE_CHAIN (constructor_unfilled_fields); 6402 6403 /* Skip any nameless bit fields. */ 6404 while (constructor_unfilled_fields != 0 6405 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6406 && DECL_NAME (constructor_unfilled_fields) == 0) 6407 constructor_unfilled_fields = 6408 TREE_CHAIN (constructor_unfilled_fields); 6409 } 6410 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6411 constructor_unfilled_fields = 0; 6412 6413 /* Now output any pending elements which have become next. */ 6414 if (pending) 6415 output_pending_init_elements (0); 6416} 6417 6418/* Output any pending elements which have become next. 6419 As we output elements, constructor_unfilled_{fields,index} 6420 advances, which may cause other elements to become next; 6421 if so, they too are output. 6422 6423 If ALL is 0, we return when there are 6424 no more pending elements to output now. 6425 6426 If ALL is 1, we output space as necessary so that 6427 we can output all the pending elements. */ 6428 6429static void 6430output_pending_init_elements (all) 6431 int all; 6432{ 6433 struct init_node *elt = constructor_pending_elts; 6434 tree next; 6435 6436 retry: 6437 6438 /* Look thru the whole pending tree. 6439 If we find an element that should be output now, 6440 output it. Otherwise, set NEXT to the element 6441 that comes first among those still pending. */ 6442 6443 next = 0; 6444 while (elt) 6445 { 6446 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6447 { 6448 if (tree_int_cst_equal (elt->purpose, 6449 constructor_unfilled_index)) 6450 output_init_element (elt->value, 6451 TREE_TYPE (constructor_type), 6452 constructor_unfilled_index, 0); 6453 else if (tree_int_cst_lt (constructor_unfilled_index, 6454 elt->purpose)) 6455 { 6456 /* Advance to the next smaller node. */ 6457 if (elt->left) 6458 elt = elt->left; 6459 else 6460 { 6461 /* We have reached the smallest node bigger than the 6462 current unfilled index. Fill the space first. */ 6463 next = elt->purpose; 6464 break; 6465 } 6466 } 6467 else 6468 { 6469 /* Advance to the next bigger node. */ 6470 if (elt->right) 6471 elt = elt->right; 6472 else 6473 { 6474 /* We have reached the biggest node in a subtree. Find 6475 the parent of it, which is the next bigger node. */ 6476 while (elt->parent && elt->parent->right == elt) 6477 elt = elt->parent; 6478 elt = elt->parent; 6479 if (elt && tree_int_cst_lt (constructor_unfilled_index, 6480 elt->purpose)) 6481 { 6482 next = elt->purpose; 6483 break; 6484 } 6485 } 6486 } 6487 } 6488 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6489 || TREE_CODE (constructor_type) == UNION_TYPE) 6490 { 6491 tree ctor_unfilled_bitpos, elt_bitpos; 6492 6493 /* If the current record is complete we are done. */ 6494 if (constructor_unfilled_fields == 0) 6495 break; 6496 6497 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 6498 elt_bitpos = bit_position (elt->purpose); 6499 /* We can't compare fields here because there might be empty 6500 fields in between. */ 6501 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 6502 { 6503 constructor_unfilled_fields = elt->purpose; 6504 output_init_element (elt->value, TREE_TYPE (elt->purpose), 6505 elt->purpose, 0); 6506 } 6507 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 6508 { 6509 /* Advance to the next smaller node. */ 6510 if (elt->left) 6511 elt = elt->left; 6512 else 6513 { 6514 /* We have reached the smallest node bigger than the 6515 current unfilled field. Fill the space first. */ 6516 next = elt->purpose; 6517 break; 6518 } 6519 } 6520 else 6521 { 6522 /* Advance to the next bigger node. */ 6523 if (elt->right) 6524 elt = elt->right; 6525 else 6526 { 6527 /* We have reached the biggest node in a subtree. Find 6528 the parent of it, which is the next bigger node. */ 6529 while (elt->parent && elt->parent->right == elt) 6530 elt = elt->parent; 6531 elt = elt->parent; 6532 if (elt 6533 && (tree_int_cst_lt (ctor_unfilled_bitpos, 6534 bit_position (elt->purpose)))) 6535 { 6536 next = elt->purpose; 6537 break; 6538 } 6539 } 6540 } 6541 } 6542 } 6543 6544 /* Ordinarily return, but not if we want to output all 6545 and there are elements left. */ 6546 if (! (all && next != 0)) 6547 return; 6548 6549 /* If it's not incremental, just skip over the gap, so that after 6550 jumping to retry we will output the next successive element. */ 6551 if (TREE_CODE (constructor_type) == RECORD_TYPE 6552 || TREE_CODE (constructor_type) == UNION_TYPE) 6553 constructor_unfilled_fields = next; 6554 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6555 constructor_unfilled_index = next; 6556 6557 /* ELT now points to the node in the pending tree with the next 6558 initializer to output. */ 6559 goto retry; 6560} 6561 6562/* Add one non-braced element to the current constructor level. 6563 This adjusts the current position within the constructor's type. 6564 This may also start or terminate implicit levels 6565 to handle a partly-braced initializer. 6566 6567 Once this has found the correct level for the new element, 6568 it calls output_init_element. */ 6569 6570void 6571process_init_element (value) 6572 tree value; 6573{ 6574 tree orig_value = value; 6575 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST; 6576 6577 designator_depth = 0; 6578 designator_errorneous = 0; 6579 6580 /* Handle superfluous braces around string cst as in 6581 char x[] = {"foo"}; */ 6582 if (string_flag 6583 && constructor_type 6584 && TREE_CODE (constructor_type) == ARRAY_TYPE 6585 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE 6586 && integer_zerop (constructor_unfilled_index)) 6587 { 6588 if (constructor_stack->replacement_value) 6589 error_init ("excess elements in char array initializer"); 6590 constructor_stack->replacement_value = value; 6591 return; 6592 } 6593 6594 if (constructor_stack->replacement_value != 0) 6595 { 6596 error_init ("excess elements in struct initializer"); 6597 return; 6598 } 6599 6600 /* Ignore elements of a brace group if it is entirely superfluous 6601 and has already been diagnosed. */ 6602 if (constructor_type == 0) 6603 return; 6604 6605 /* If we've exhausted any levels that didn't have braces, 6606 pop them now. */ 6607 while (constructor_stack->implicit) 6608 { 6609 if ((TREE_CODE (constructor_type) == RECORD_TYPE 6610 || TREE_CODE (constructor_type) == UNION_TYPE) 6611 && constructor_fields == 0) 6612 process_init_element (pop_init_level (1)); 6613 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 6614 && (constructor_max_index == 0 6615 || tree_int_cst_lt (constructor_max_index, 6616 constructor_index))) 6617 process_init_element (pop_init_level (1)); 6618 else 6619 break; 6620 } 6621 6622 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 6623 if (constructor_range_stack) 6624 { 6625 /* If value is a compound literal and we'll be just using its 6626 content, don't put it into a SAVE_EXPR. */ 6627 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR 6628 || !require_constant_value 6629 || flag_isoc99) 6630 value = save_expr (value); 6631 } 6632 6633 while (1) 6634 { 6635 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6636 { 6637 tree fieldtype; 6638 enum tree_code fieldcode; 6639 6640 if (constructor_fields == 0) 6641 { 6642 pedwarn_init ("excess elements in struct initializer"); 6643 break; 6644 } 6645 6646 fieldtype = TREE_TYPE (constructor_fields); 6647 if (fieldtype != error_mark_node) 6648 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6649 fieldcode = TREE_CODE (fieldtype); 6650 6651 /* Accept a string constant to initialize a subarray. */ 6652 if (value != 0 6653 && fieldcode == ARRAY_TYPE 6654 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE 6655 && string_flag) 6656 value = orig_value; 6657 /* Otherwise, if we have come to a subaggregate, 6658 and we don't have an element of its type, push into it. */ 6659 else if (value != 0 && !constructor_no_implicit 6660 && value != error_mark_node 6661 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype 6662 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6663 || fieldcode == UNION_TYPE)) 6664 { 6665 push_init_level (1); 6666 continue; 6667 } 6668 6669 if (value) 6670 { 6671 push_member_name (constructor_fields); 6672 output_init_element (value, fieldtype, constructor_fields, 1); 6673 RESTORE_SPELLING_DEPTH (constructor_depth); 6674 } 6675 else 6676 /* Do the bookkeeping for an element that was 6677 directly output as a constructor. */ 6678 { 6679 /* For a record, keep track of end position of last field. */ 6680 if (DECL_SIZE (constructor_fields)) 6681 constructor_bit_index 6682 = size_binop (PLUS_EXPR, 6683 bit_position (constructor_fields), 6684 DECL_SIZE (constructor_fields)); 6685 6686 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6687 /* Skip any nameless bit fields. */ 6688 while (constructor_unfilled_fields != 0 6689 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6690 && DECL_NAME (constructor_unfilled_fields) == 0) 6691 constructor_unfilled_fields = 6692 TREE_CHAIN (constructor_unfilled_fields); 6693 } 6694 6695 constructor_fields = TREE_CHAIN (constructor_fields); 6696 /* Skip any nameless bit fields at the beginning. */ 6697 while (constructor_fields != 0 6698 && DECL_C_BIT_FIELD (constructor_fields) 6699 && DECL_NAME (constructor_fields) == 0) 6700 constructor_fields = TREE_CHAIN (constructor_fields); 6701 } 6702 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6703 { 6704 tree fieldtype; 6705 enum tree_code fieldcode; 6706 6707 if (constructor_fields == 0) 6708 { 6709 pedwarn_init ("excess elements in union initializer"); 6710 break; 6711 } 6712 6713 fieldtype = TREE_TYPE (constructor_fields); 6714 if (fieldtype != error_mark_node) 6715 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6716 fieldcode = TREE_CODE (fieldtype); 6717 6718 /* Warn that traditional C rejects initialization of unions. 6719 We skip the warning if the value is zero. This is done 6720 under the assumption that the zero initializer in user 6721 code appears conditioned on e.g. __STDC__ to avoid 6722 "missing initializer" warnings and relies on default 6723 initialization to zero in the traditional C case. 6724 We also skip the warning if the initializer is designated, 6725 again on the assumption that this must be conditional on 6726 __STDC__ anyway (and we've already complained about the 6727 member-designator already). */ 6728 if (warn_traditional && !in_system_header && !constructor_designated 6729 && !(value && (integer_zerop (value) || real_zerop (value)))) 6730 warning ("traditional C rejects initialization of unions"); 6731 6732 /* Accept a string constant to initialize a subarray. */ 6733 if (value != 0 6734 && fieldcode == ARRAY_TYPE 6735 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE 6736 && string_flag) 6737 value = orig_value; 6738 /* Otherwise, if we have come to a subaggregate, 6739 and we don't have an element of its type, push into it. */ 6740 else if (value != 0 && !constructor_no_implicit 6741 && value != error_mark_node 6742 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype 6743 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6744 || fieldcode == UNION_TYPE)) 6745 { 6746 push_init_level (1); 6747 continue; 6748 } 6749 6750 if (value) 6751 { 6752 push_member_name (constructor_fields); 6753 output_init_element (value, fieldtype, constructor_fields, 1); 6754 RESTORE_SPELLING_DEPTH (constructor_depth); 6755 } 6756 else 6757 /* Do the bookkeeping for an element that was 6758 directly output as a constructor. */ 6759 { 6760 constructor_bit_index = DECL_SIZE (constructor_fields); 6761 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6762 } 6763 6764 constructor_fields = 0; 6765 } 6766 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6767 { 6768 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 6769 enum tree_code eltcode = TREE_CODE (elttype); 6770 6771 /* Accept a string constant to initialize a subarray. */ 6772 if (value != 0 6773 && eltcode == ARRAY_TYPE 6774 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE 6775 && string_flag) 6776 value = orig_value; 6777 /* Otherwise, if we have come to a subaggregate, 6778 and we don't have an element of its type, push into it. */ 6779 else if (value != 0 && !constructor_no_implicit 6780 && value != error_mark_node 6781 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype 6782 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 6783 || eltcode == UNION_TYPE)) 6784 { 6785 push_init_level (1); 6786 continue; 6787 } 6788 6789 if (constructor_max_index != 0 6790 && (tree_int_cst_lt (constructor_max_index, constructor_index) 6791 || integer_all_onesp (constructor_max_index))) 6792 { 6793 pedwarn_init ("excess elements in array initializer"); 6794 break; 6795 } 6796 6797 /* Now output the actual element. */ 6798 if (value) 6799 { 6800 push_array_bounds (tree_low_cst (constructor_index, 0)); 6801 output_init_element (value, elttype, constructor_index, 1); 6802 RESTORE_SPELLING_DEPTH (constructor_depth); 6803 } 6804 6805 constructor_index 6806 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 6807 6808 if (! value) 6809 /* If we are doing the bookkeeping for an element that was 6810 directly output as a constructor, we must update 6811 constructor_unfilled_index. */ 6812 constructor_unfilled_index = constructor_index; 6813 } 6814 6815 /* Handle the sole element allowed in a braced initializer 6816 for a scalar variable. */ 6817 else if (constructor_fields == 0) 6818 { 6819 pedwarn_init ("excess elements in scalar initializer"); 6820 break; 6821 } 6822 else 6823 { 6824 if (value) 6825 output_init_element (value, constructor_type, NULL_TREE, 1); 6826 constructor_fields = 0; 6827 } 6828 6829 /* Handle range initializers either at this level or anywhere higher 6830 in the designator stack. */ 6831 if (constructor_range_stack) 6832 { 6833 struct constructor_range_stack *p, *range_stack; 6834 int finish = 0; 6835 6836 range_stack = constructor_range_stack; 6837 constructor_range_stack = 0; 6838 while (constructor_stack != range_stack->stack) 6839 { 6840 if (!constructor_stack->implicit) 6841 abort (); 6842 process_init_element (pop_init_level (1)); 6843 } 6844 for (p = range_stack; 6845 !p->range_end || tree_int_cst_equal (p->index, p->range_end); 6846 p = p->prev) 6847 { 6848 if (!constructor_stack->implicit) 6849 abort (); 6850 process_init_element (pop_init_level (1)); 6851 } 6852 6853 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 6854 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 6855 finish = 1; 6856 6857 while (1) 6858 { 6859 constructor_index = p->index; 6860 constructor_fields = p->fields; 6861 if (finish && p->range_end && p->index == p->range_start) 6862 { 6863 finish = 0; 6864 p->prev = 0; 6865 } 6866 p = p->next; 6867 if (!p) 6868 break; 6869 push_init_level (2); 6870 p->stack = constructor_stack; 6871 if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 6872 p->index = p->range_start; 6873 } 6874 6875 if (!finish) 6876 constructor_range_stack = range_stack; 6877 continue; 6878 } 6879 6880 break; 6881 } 6882 6883 constructor_range_stack = 0; 6884} 6885 6886/* Build a simple asm-statement, from one string literal. */ 6887tree 6888simple_asm_stmt (expr) 6889 tree expr; 6890{ 6891 STRIP_NOPS (expr); 6892 6893 if (TREE_CODE (expr) == ADDR_EXPR) 6894 expr = TREE_OPERAND (expr, 0); 6895 6896 if (TREE_CODE (expr) == STRING_CST) 6897 { 6898 tree stmt; 6899 6900 if (TREE_CHAIN (expr)) 6901 expr = combine_strings (expr); 6902 stmt = add_stmt (build_stmt (ASM_STMT, NULL_TREE, expr, 6903 NULL_TREE, NULL_TREE, 6904 NULL_TREE)); 6905 ASM_INPUT_P (stmt) = 1; 6906 return stmt; 6907 } 6908 6909 error ("argument of `asm' is not a constant string"); 6910 return NULL_TREE; 6911} 6912 6913/* Build an asm-statement, whose components are a CV_QUALIFIER, a 6914 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */ 6915 6916tree 6917build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers) 6918 tree cv_qualifier; 6919 tree string; 6920 tree outputs; 6921 tree inputs; 6922 tree clobbers; 6923{ 6924 tree tail; 6925 6926 if (TREE_CHAIN (string)) 6927 string = combine_strings (string); 6928 if (TREE_CODE (string) != STRING_CST) 6929 { 6930 error ("asm template is not a string constant"); 6931 return NULL_TREE; 6932 } 6933 6934 if (cv_qualifier != NULL_TREE 6935 && cv_qualifier != ridpointers[(int) RID_VOLATILE]) 6936 { 6937 warning ("%s qualifier ignored on asm", 6938 IDENTIFIER_POINTER (cv_qualifier)); 6939 cv_qualifier = NULL_TREE; 6940 } 6941 6942 /* We can remove output conversions that change the type, 6943 but not the mode. */ 6944 for (tail = outputs; tail; tail = TREE_CHAIN (tail)) 6945 { 6946 tree output = TREE_VALUE (tail); 6947 6948 STRIP_NOPS (output); 6949 TREE_VALUE (tail) = output; 6950 6951 /* Allow conversions as LHS here. build_modify_expr as called below 6952 will do the right thing with them. */ 6953 while (TREE_CODE (output) == NOP_EXPR 6954 || TREE_CODE (output) == CONVERT_EXPR 6955 || TREE_CODE (output) == FLOAT_EXPR 6956 || TREE_CODE (output) == FIX_TRUNC_EXPR 6957 || TREE_CODE (output) == FIX_FLOOR_EXPR 6958 || TREE_CODE (output) == FIX_ROUND_EXPR 6959 || TREE_CODE (output) == FIX_CEIL_EXPR) 6960 output = TREE_OPERAND (output, 0); 6961 6962 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement"); 6963 } 6964 6965 /* Remove output conversions that change the type but not the mode. */ 6966 for (tail = outputs; tail; tail = TREE_CHAIN (tail)) 6967 { 6968 tree output = TREE_VALUE (tail); 6969 STRIP_NOPS (output); 6970 TREE_VALUE (tail) = output; 6971 } 6972 6973 /* Perform default conversions on array and function inputs. 6974 Don't do this for other types as it would screw up operands 6975 expected to be in memory. */ 6976 for (tail = inputs; tail; tail = TREE_CHAIN (tail)) 6977 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail)); 6978 6979 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string, 6980 outputs, inputs, clobbers)); 6981} 6982 6983/* Expand an ASM statement with operands, handling output operands 6984 that are not variables or INDIRECT_REFS by transforming such 6985 cases into cases that expand_asm_operands can handle. 6986 6987 Arguments are same as for expand_asm_operands. */ 6988 6989void 6990c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line) 6991 tree string, outputs, inputs, clobbers; 6992 int vol; 6993 const char *filename; 6994 int line; 6995{ 6996 int noutputs = list_length (outputs); 6997 int i; 6998 /* o[I] is the place that output number I should be written. */ 6999 tree *o = (tree *) alloca (noutputs * sizeof (tree)); 7000 tree tail; 7001 7002 /* Record the contents of OUTPUTS before it is modified. */ 7003 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) 7004 o[i] = TREE_VALUE (tail); 7005 7006 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of 7007 OUTPUTS some trees for where the values were actually stored. */ 7008 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line); 7009 7010 /* Copy all the intermediate outputs into the specified outputs. */ 7011 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) 7012 { 7013 if (o[i] != TREE_VALUE (tail)) 7014 { 7015 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)), 7016 NULL_RTX, VOIDmode, EXPAND_NORMAL); 7017 free_temp_slots (); 7018 7019 /* Restore the original value so that it's correct the next 7020 time we expand this function. */ 7021 TREE_VALUE (tail) = o[i]; 7022 } 7023 /* Detect modification of read-only values. 7024 (Otherwise done by build_modify_expr.) */ 7025 else 7026 { 7027 tree type = TREE_TYPE (o[i]); 7028 if (TREE_READONLY (o[i]) 7029 || TYPE_READONLY (type) 7030 || ((TREE_CODE (type) == RECORD_TYPE 7031 || TREE_CODE (type) == UNION_TYPE) 7032 && C_TYPE_FIELDS_READONLY (type))) 7033 readonly_warning (o[i], "modification by `asm'"); 7034 } 7035 } 7036 7037 /* Those MODIFY_EXPRs could do autoincrements. */ 7038 emit_queue (); 7039} 7040 7041/* Expand a C `return' statement. 7042 RETVAL is the expression for what to return, 7043 or a null pointer for `return;' with no value. */ 7044 7045tree 7046c_expand_return (retval) 7047 tree retval; 7048{ 7049 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)); 7050 7051 if (TREE_THIS_VOLATILE (current_function_decl)) 7052 warning ("function declared `noreturn' has a `return' statement"); 7053 7054 if (!retval) 7055 { 7056 current_function_returns_null = 1; 7057 if ((warn_return_type || flag_isoc99) 7058 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 7059 pedwarn_c99 ("`return' with no value, in function returning non-void"); 7060 } 7061 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 7062 { 7063 current_function_returns_null = 1; 7064 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 7065 pedwarn ("`return' with a value, in function returning void"); 7066 } 7067 else 7068 { 7069 tree t = convert_for_assignment (valtype, retval, _("return"), 7070 NULL_TREE, NULL_TREE, 0); 7071 tree res = DECL_RESULT (current_function_decl); 7072 tree inner; 7073 7074 if (t == error_mark_node) 7075 return NULL_TREE; 7076 7077 inner = t = convert (TREE_TYPE (res), t); 7078 7079 /* Strip any conversions, additions, and subtractions, and see if 7080 we are returning the address of a local variable. Warn if so. */ 7081 while (1) 7082 { 7083 switch (TREE_CODE (inner)) 7084 { 7085 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 7086 case PLUS_EXPR: 7087 inner = TREE_OPERAND (inner, 0); 7088 continue; 7089 7090 case MINUS_EXPR: 7091 /* If the second operand of the MINUS_EXPR has a pointer 7092 type (or is converted from it), this may be valid, so 7093 don't give a warning. */ 7094 { 7095 tree op1 = TREE_OPERAND (inner, 1); 7096 7097 while (! POINTER_TYPE_P (TREE_TYPE (op1)) 7098 && (TREE_CODE (op1) == NOP_EXPR 7099 || TREE_CODE (op1) == NON_LVALUE_EXPR 7100 || TREE_CODE (op1) == CONVERT_EXPR)) 7101 op1 = TREE_OPERAND (op1, 0); 7102 7103 if (POINTER_TYPE_P (TREE_TYPE (op1))) 7104 break; 7105 7106 inner = TREE_OPERAND (inner, 0); 7107 continue; 7108 } 7109 7110 case ADDR_EXPR: 7111 inner = TREE_OPERAND (inner, 0); 7112 7113 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r') 7114 inner = TREE_OPERAND (inner, 0); 7115 7116 if (TREE_CODE (inner) == VAR_DECL 7117 && ! DECL_EXTERNAL (inner) 7118 && ! TREE_STATIC (inner) 7119 && DECL_CONTEXT (inner) == current_function_decl) 7120 warning ("function returns address of local variable"); 7121 break; 7122 7123 default: 7124 break; 7125 } 7126 7127 break; 7128 } 7129 7130 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t); 7131 current_function_returns_value = 1; 7132 } 7133 7134 return add_stmt (build_return_stmt (retval)); 7135} 7136 7137struct c_switch { 7138 /* The SWITCH_STMT being built. */ 7139 tree switch_stmt; 7140 /* A splay-tree mapping the low element of a case range to the high 7141 element, or NULL_TREE if there is no high element. Used to 7142 determine whether or not a new case label duplicates an old case 7143 label. We need a tree, rather than simply a hash table, because 7144 of the GNU case range extension. */ 7145 splay_tree cases; 7146 /* The next node on the stack. */ 7147 struct c_switch *next; 7148}; 7149 7150/* A stack of the currently active switch statements. The innermost 7151 switch statement is on the top of the stack. There is no need to 7152 mark the stack for garbage collection because it is only active 7153 during the processing of the body of a function, and we never 7154 collect at that point. */ 7155 7156static struct c_switch *switch_stack; 7157 7158/* Start a C switch statement, testing expression EXP. Return the new 7159 SWITCH_STMT. */ 7160 7161tree 7162c_start_case (exp) 7163 tree exp; 7164{ 7165 enum tree_code code; 7166 tree type; 7167 struct c_switch *cs; 7168 7169 if (exp != error_mark_node) 7170 { 7171 code = TREE_CODE (TREE_TYPE (exp)); 7172 type = TREE_TYPE (exp); 7173 7174 if (! INTEGRAL_TYPE_P (type) 7175 && code != ERROR_MARK) 7176 { 7177 error ("switch quantity not an integer"); 7178 exp = integer_zero_node; 7179 } 7180 else 7181 { 7182 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); 7183 7184 if (warn_traditional && !in_system_header 7185 && (type == long_integer_type_node 7186 || type == long_unsigned_type_node)) 7187 warning ("`long' switch expression not converted to `int' in ISO C"); 7188 7189 exp = default_conversion (exp); 7190 type = TREE_TYPE (exp); 7191 } 7192 } 7193 7194 /* Add this new SWITCH_STMT to the stack. */ 7195 cs = (struct c_switch *) xmalloc (sizeof (*cs)); 7196 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, NULL_TREE); 7197 cs->cases = splay_tree_new (case_compare, NULL, NULL); 7198 cs->next = switch_stack; 7199 switch_stack = cs; 7200 7201 return add_stmt (switch_stack->switch_stmt); 7202} 7203 7204/* Process a case label. */ 7205 7206tree 7207do_case (low_value, high_value) 7208 tree low_value; 7209 tree high_value; 7210{ 7211 tree label = NULL_TREE; 7212 7213 if (switch_stack) 7214 { 7215 label = c_add_case_label (switch_stack->cases, 7216 SWITCH_COND (switch_stack->switch_stmt), 7217 low_value, high_value); 7218 if (label == error_mark_node) 7219 label = NULL_TREE; 7220 } 7221 else if (low_value) 7222 error ("case label not within a switch statement"); 7223 else 7224 error ("`default' label not within a switch statement"); 7225 7226 return label; 7227} 7228 7229/* Finish the switch statement. */ 7230 7231void 7232c_finish_case () 7233{ 7234 struct c_switch *cs = switch_stack; 7235 7236 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt)); 7237 7238 /* Pop the stack. */ 7239 switch_stack = switch_stack->next; 7240 splay_tree_delete (cs->cases); 7241 free (cs); 7242} 7243