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