c-typeck.c revision 119256
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 /* Build a VECTOR_CST from a *constant* vector constructor. If the 4763 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 4764 below and handle as a constructor. */ 4765 if (code == VECTOR_TYPE 4766 && comptypes (TREE_TYPE (inside_init), type) 4767 && TREE_CONSTANT (inside_init)) 4768 return build_vector (type, TREE_OPERAND (inside_init, 1)); 4769 4770 4771 /* Any type can be initialized 4772 from an expression of the same type, optionally with braces. */ 4773 4774 if (inside_init && TREE_TYPE (inside_init) != 0 4775 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4776 TYPE_MAIN_VARIANT (type)) 4777 || (code == ARRAY_TYPE 4778 && comptypes (TREE_TYPE (inside_init), type)) 4779 || (code == VECTOR_TYPE 4780 && comptypes (TREE_TYPE (inside_init), type)) 4781 || (code == POINTER_TYPE 4782 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 4783 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE) 4784 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4785 TREE_TYPE (type))))) 4786 { 4787 if (code == POINTER_TYPE) 4788 inside_init = default_function_array_conversion (inside_init); 4789 4790 if (require_constant && !flag_isoc99 4791 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4792 { 4793 /* As an extension, allow initializing objects with static storage 4794 duration with compound literals (which are then treated just as 4795 the brace enclosed list they contain). */ 4796 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 4797 inside_init = DECL_INITIAL (decl); 4798 } 4799 4800 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 4801 && TREE_CODE (inside_init) != CONSTRUCTOR) 4802 { 4803 error_init ("array initialized from non-constant array expression"); 4804 return error_mark_node; 4805 } 4806 4807 if (optimize && TREE_CODE (inside_init) == VAR_DECL) 4808 inside_init = decl_constant_value_for_broken_optimization (inside_init); 4809 4810 /* Compound expressions can only occur here if -pedantic or 4811 -pedantic-errors is specified. In the later case, we always want 4812 an error. In the former case, we simply want a warning. */ 4813 if (require_constant && pedantic 4814 && TREE_CODE (inside_init) == COMPOUND_EXPR) 4815 { 4816 inside_init 4817 = valid_compound_expr_initializer (inside_init, 4818 TREE_TYPE (inside_init)); 4819 if (inside_init == error_mark_node) 4820 error_init ("initializer element is not constant"); 4821 else 4822 pedwarn_init ("initializer element is not constant"); 4823 if (flag_pedantic_errors) 4824 inside_init = error_mark_node; 4825 } 4826 else if (require_constant 4827 && (!TREE_CONSTANT (inside_init) 4828 /* This test catches things like `7 / 0' which 4829 result in an expression for which TREE_CONSTANT 4830 is true, but which is not actually something 4831 that is a legal constant. We really should not 4832 be using this function, because it is a part of 4833 the back-end. Instead, the expression should 4834 already have been turned into ERROR_MARK_NODE. */ 4835 || !initializer_constant_valid_p (inside_init, 4836 TREE_TYPE (inside_init)))) 4837 { 4838 error_init ("initializer element is not constant"); 4839 inside_init = error_mark_node; 4840 } 4841 4842 return inside_init; 4843 } 4844 4845 /* Handle scalar types, including conversions. */ 4846 4847 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4848 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE) 4849 { 4850 /* Note that convert_for_assignment calls default_conversion 4851 for arrays and functions. We must not call it in the 4852 case where inside_init is a null pointer constant. */ 4853 inside_init 4854 = convert_for_assignment (type, init, _("initialization"), 4855 NULL_TREE, NULL_TREE, 0); 4856 4857 if (require_constant && ! TREE_CONSTANT (inside_init)) 4858 { 4859 error_init ("initializer element is not constant"); 4860 inside_init = error_mark_node; 4861 } 4862 else if (require_constant 4863 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0) 4864 { 4865 error_init ("initializer element is not computable at load time"); 4866 inside_init = error_mark_node; 4867 } 4868 4869 return inside_init; 4870 } 4871 4872 /* Come here only for records and arrays. */ 4873 4874 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 4875 { 4876 error_init ("variable-sized object may not be initialized"); 4877 return error_mark_node; 4878 } 4879 4880 error_init ("invalid initializer"); 4881 return error_mark_node; 4882} 4883 4884/* Handle initializers that use braces. */ 4885 4886/* Type of object we are accumulating a constructor for. 4887 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 4888static tree constructor_type; 4889 4890/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 4891 left to fill. */ 4892static tree constructor_fields; 4893 4894/* For an ARRAY_TYPE, this is the specified index 4895 at which to store the next element we get. */ 4896static tree constructor_index; 4897 4898/* For an ARRAY_TYPE, this is the maximum index. */ 4899static tree constructor_max_index; 4900 4901/* For a RECORD_TYPE, this is the first field not yet written out. */ 4902static tree constructor_unfilled_fields; 4903 4904/* For an ARRAY_TYPE, this is the index of the first element 4905 not yet written out. */ 4906static tree constructor_unfilled_index; 4907 4908/* In a RECORD_TYPE, the byte index of the next consecutive field. 4909 This is so we can generate gaps between fields, when appropriate. */ 4910static tree constructor_bit_index; 4911 4912/* If we are saving up the elements rather than allocating them, 4913 this is the list of elements so far (in reverse order, 4914 most recent first). */ 4915static tree constructor_elements; 4916 4917/* 1 if constructor should be incrementally stored into a constructor chain, 4918 0 if all the elements should be kept in AVL tree. */ 4919static int constructor_incremental; 4920 4921/* 1 if so far this constructor's elements are all compile-time constants. */ 4922static int constructor_constant; 4923 4924/* 1 if so far this constructor's elements are all valid address constants. */ 4925static int constructor_simple; 4926 4927/* 1 if this constructor is erroneous so far. */ 4928static int constructor_erroneous; 4929 4930/* 1 if have called defer_addressed_constants. */ 4931static int constructor_subconstants_deferred; 4932 4933/* Structure for managing pending initializer elements, organized as an 4934 AVL tree. */ 4935 4936struct init_node 4937{ 4938 struct init_node *left, *right; 4939 struct init_node *parent; 4940 int balance; 4941 tree purpose; 4942 tree value; 4943}; 4944 4945/* Tree of pending elements at this constructor level. 4946 These are elements encountered out of order 4947 which belong at places we haven't reached yet in actually 4948 writing the output. 4949 Will never hold tree nodes across GC runs. */ 4950static struct init_node *constructor_pending_elts; 4951 4952/* The SPELLING_DEPTH of this constructor. */ 4953static int constructor_depth; 4954 4955/* 0 if implicitly pushing constructor levels is allowed. */ 4956int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */ 4957 4958static int require_constant_value; 4959static int require_constant_elements; 4960 4961/* DECL node for which an initializer is being read. 4962 0 means we are reading a constructor expression 4963 such as (struct foo) {...}. */ 4964static tree constructor_decl; 4965 4966/* start_init saves the ASMSPEC arg here for really_start_incremental_init. */ 4967static const char *constructor_asmspec; 4968 4969/* Nonzero if this is an initializer for a top-level decl. */ 4970static int constructor_top_level; 4971 4972/* Nonzero if there were any member designators in this initializer. */ 4973static int constructor_designated; 4974 4975/* Nesting depth of designator list. */ 4976static int designator_depth; 4977 4978/* Nonzero if there were diagnosed errors in this designator list. */ 4979static int designator_errorneous; 4980 4981 4982/* This stack has a level for each implicit or explicit level of 4983 structuring in the initializer, including the outermost one. It 4984 saves the values of most of the variables above. */ 4985 4986struct constructor_range_stack; 4987 4988struct constructor_stack 4989{ 4990 struct constructor_stack *next; 4991 tree type; 4992 tree fields; 4993 tree index; 4994 tree max_index; 4995 tree unfilled_index; 4996 tree unfilled_fields; 4997 tree bit_index; 4998 tree elements; 4999 struct init_node *pending_elts; 5000 int offset; 5001 int depth; 5002 /* If nonzero, this value should replace the entire 5003 constructor at this level. */ 5004 tree replacement_value; 5005 struct constructor_range_stack *range_stack; 5006 char constant; 5007 char simple; 5008 char implicit; 5009 char erroneous; 5010 char outer; 5011 char incremental; 5012 char designated; 5013}; 5014 5015struct constructor_stack *constructor_stack; 5016 5017/* This stack represents designators from some range designator up to 5018 the last designator in the list. */ 5019 5020struct constructor_range_stack 5021{ 5022 struct constructor_range_stack *next, *prev; 5023 struct constructor_stack *stack; 5024 tree range_start; 5025 tree index; 5026 tree range_end; 5027 tree fields; 5028}; 5029 5030struct constructor_range_stack *constructor_range_stack; 5031 5032/* This stack records separate initializers that are nested. 5033 Nested initializers can't happen in ANSI C, but GNU C allows them 5034 in cases like { ... (struct foo) { ... } ... }. */ 5035 5036struct initializer_stack 5037{ 5038 struct initializer_stack *next; 5039 tree decl; 5040 const char *asmspec; 5041 struct constructor_stack *constructor_stack; 5042 struct constructor_range_stack *constructor_range_stack; 5043 tree elements; 5044 struct spelling *spelling; 5045 struct spelling *spelling_base; 5046 int spelling_size; 5047 char top_level; 5048 char require_constant_value; 5049 char require_constant_elements; 5050 char deferred; 5051}; 5052 5053struct initializer_stack *initializer_stack; 5054 5055/* Prepare to parse and output the initializer for variable DECL. */ 5056 5057void 5058start_init (decl, asmspec_tree, top_level) 5059 tree decl; 5060 tree asmspec_tree; 5061 int top_level; 5062{ 5063 const char *locus; 5064 struct initializer_stack *p 5065 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack)); 5066 const char *asmspec = 0; 5067 5068 if (asmspec_tree) 5069 asmspec = TREE_STRING_POINTER (asmspec_tree); 5070 5071 p->decl = constructor_decl; 5072 p->asmspec = constructor_asmspec; 5073 p->require_constant_value = require_constant_value; 5074 p->require_constant_elements = require_constant_elements; 5075 p->constructor_stack = constructor_stack; 5076 p->constructor_range_stack = constructor_range_stack; 5077 p->elements = constructor_elements; 5078 p->spelling = spelling; 5079 p->spelling_base = spelling_base; 5080 p->spelling_size = spelling_size; 5081 p->deferred = constructor_subconstants_deferred; 5082 p->top_level = constructor_top_level; 5083 p->next = initializer_stack; 5084 initializer_stack = p; 5085 5086 constructor_decl = decl; 5087 constructor_asmspec = asmspec; 5088 constructor_subconstants_deferred = 0; 5089 constructor_designated = 0; 5090 constructor_top_level = top_level; 5091 5092 if (decl != 0) 5093 { 5094 require_constant_value = TREE_STATIC (decl); 5095 require_constant_elements 5096 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 5097 /* For a scalar, you can always use any value to initialize, 5098 even within braces. */ 5099 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 5100 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 5101 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 5102 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 5103 locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 5104 } 5105 else 5106 { 5107 require_constant_value = 0; 5108 require_constant_elements = 0; 5109 locus = "(anonymous)"; 5110 } 5111 5112 constructor_stack = 0; 5113 constructor_range_stack = 0; 5114 5115 missing_braces_mentioned = 0; 5116 5117 spelling_base = 0; 5118 spelling_size = 0; 5119 RESTORE_SPELLING_DEPTH (0); 5120 5121 if (locus) 5122 push_string (locus); 5123} 5124 5125void 5126finish_init () 5127{ 5128 struct initializer_stack *p = initializer_stack; 5129 5130 /* Output subconstants (string constants, usually) 5131 that were referenced within this initializer and saved up. 5132 Must do this if and only if we called defer_addressed_constants. */ 5133 if (constructor_subconstants_deferred) 5134 output_deferred_addressed_constants (); 5135 5136 /* Free the whole constructor stack of this initializer. */ 5137 while (constructor_stack) 5138 { 5139 struct constructor_stack *q = constructor_stack; 5140 constructor_stack = q->next; 5141 free (q); 5142 } 5143 5144 if (constructor_range_stack) 5145 abort (); 5146 5147 /* Pop back to the data of the outer initializer (if any). */ 5148 constructor_decl = p->decl; 5149 constructor_asmspec = p->asmspec; 5150 require_constant_value = p->require_constant_value; 5151 require_constant_elements = p->require_constant_elements; 5152 constructor_stack = p->constructor_stack; 5153 constructor_range_stack = p->constructor_range_stack; 5154 constructor_elements = p->elements; 5155 spelling = p->spelling; 5156 spelling_base = p->spelling_base; 5157 spelling_size = p->spelling_size; 5158 constructor_subconstants_deferred = p->deferred; 5159 constructor_top_level = p->top_level; 5160 initializer_stack = p->next; 5161 free (p); 5162} 5163 5164/* Call here when we see the initializer is surrounded by braces. 5165 This is instead of a call to push_init_level; 5166 it is matched by a call to pop_init_level. 5167 5168 TYPE is the type to initialize, for a constructor expression. 5169 For an initializer for a decl, TYPE is zero. */ 5170 5171void 5172really_start_incremental_init (type) 5173 tree type; 5174{ 5175 struct constructor_stack *p 5176 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack)); 5177 5178 if (type == 0) 5179 type = TREE_TYPE (constructor_decl); 5180 5181 p->type = constructor_type; 5182 p->fields = constructor_fields; 5183 p->index = constructor_index; 5184 p->max_index = constructor_max_index; 5185 p->unfilled_index = constructor_unfilled_index; 5186 p->unfilled_fields = constructor_unfilled_fields; 5187 p->bit_index = constructor_bit_index; 5188 p->elements = constructor_elements; 5189 p->constant = constructor_constant; 5190 p->simple = constructor_simple; 5191 p->erroneous = constructor_erroneous; 5192 p->pending_elts = constructor_pending_elts; 5193 p->depth = constructor_depth; 5194 p->replacement_value = 0; 5195 p->implicit = 0; 5196 p->range_stack = 0; 5197 p->outer = 0; 5198 p->incremental = constructor_incremental; 5199 p->designated = constructor_designated; 5200 p->next = 0; 5201 constructor_stack = p; 5202 5203 constructor_constant = 1; 5204 constructor_simple = 1; 5205 constructor_depth = SPELLING_DEPTH (); 5206 constructor_elements = 0; 5207 constructor_pending_elts = 0; 5208 constructor_type = type; 5209 constructor_incremental = 1; 5210 constructor_designated = 0; 5211 designator_depth = 0; 5212 designator_errorneous = 0; 5213 5214 if (TREE_CODE (constructor_type) == RECORD_TYPE 5215 || TREE_CODE (constructor_type) == UNION_TYPE) 5216 { 5217 constructor_fields = TYPE_FIELDS (constructor_type); 5218 /* Skip any nameless bit fields at the beginning. */ 5219 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5220 && DECL_NAME (constructor_fields) == 0) 5221 constructor_fields = TREE_CHAIN (constructor_fields); 5222 5223 constructor_unfilled_fields = constructor_fields; 5224 constructor_bit_index = bitsize_zero_node; 5225 } 5226 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5227 { 5228 if (TYPE_DOMAIN (constructor_type)) 5229 { 5230 constructor_max_index 5231 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5232 5233 /* Detect non-empty initializations of zero-length arrays. */ 5234 if (constructor_max_index == NULL_TREE 5235 && TYPE_SIZE (constructor_type)) 5236 constructor_max_index = build_int_2 (-1, -1); 5237 5238 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5239 to initialize VLAs will cause a proper error; avoid tree 5240 checking errors as well by setting a safe value. */ 5241 if (constructor_max_index 5242 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5243 constructor_max_index = build_int_2 (-1, -1); 5244 5245 constructor_index 5246 = convert (bitsizetype, 5247 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5248 } 5249 else 5250 constructor_index = bitsize_zero_node; 5251 5252 constructor_unfilled_index = constructor_index; 5253 } 5254 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 5255 { 5256 /* Vectors are like simple fixed-size arrays. */ 5257 constructor_max_index = 5258 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0); 5259 constructor_index = convert (bitsizetype, bitsize_zero_node); 5260 constructor_unfilled_index = constructor_index; 5261 } 5262 else 5263 { 5264 /* Handle the case of int x = {5}; */ 5265 constructor_fields = constructor_type; 5266 constructor_unfilled_fields = constructor_type; 5267 } 5268} 5269 5270/* Push down into a subobject, for initialization. 5271 If this is for an explicit set of braces, IMPLICIT is 0. 5272 If it is because the next element belongs at a lower level, 5273 IMPLICIT is 1 (or 2 if the push is because of designator list). */ 5274 5275void 5276push_init_level (implicit) 5277 int implicit; 5278{ 5279 struct constructor_stack *p; 5280 tree value = NULL_TREE; 5281 5282 /* If we've exhausted any levels that didn't have braces, 5283 pop them now. */ 5284 while (constructor_stack->implicit) 5285 { 5286 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5287 || TREE_CODE (constructor_type) == UNION_TYPE) 5288 && constructor_fields == 0) 5289 process_init_element (pop_init_level (1)); 5290 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5291 && constructor_max_index 5292 && tree_int_cst_lt (constructor_max_index, constructor_index)) 5293 process_init_element (pop_init_level (1)); 5294 else 5295 break; 5296 } 5297 5298 /* Unless this is an explicit brace, we need to preserve previous 5299 content if any. */ 5300 if (implicit) 5301 { 5302 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5303 || TREE_CODE (constructor_type) == UNION_TYPE) 5304 && constructor_fields) 5305 value = find_init_member (constructor_fields); 5306 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5307 value = find_init_member (constructor_index); 5308 } 5309 5310 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack)); 5311 p->type = constructor_type; 5312 p->fields = constructor_fields; 5313 p->index = constructor_index; 5314 p->max_index = constructor_max_index; 5315 p->unfilled_index = constructor_unfilled_index; 5316 p->unfilled_fields = constructor_unfilled_fields; 5317 p->bit_index = constructor_bit_index; 5318 p->elements = constructor_elements; 5319 p->constant = constructor_constant; 5320 p->simple = constructor_simple; 5321 p->erroneous = constructor_erroneous; 5322 p->pending_elts = constructor_pending_elts; 5323 p->depth = constructor_depth; 5324 p->replacement_value = 0; 5325 p->implicit = implicit; 5326 p->outer = 0; 5327 p->incremental = constructor_incremental; 5328 p->designated = constructor_designated; 5329 p->next = constructor_stack; 5330 p->range_stack = 0; 5331 constructor_stack = p; 5332 5333 constructor_constant = 1; 5334 constructor_simple = 1; 5335 constructor_depth = SPELLING_DEPTH (); 5336 constructor_elements = 0; 5337 constructor_incremental = 1; 5338 constructor_designated = 0; 5339 constructor_pending_elts = 0; 5340 if (!implicit) 5341 { 5342 p->range_stack = constructor_range_stack; 5343 constructor_range_stack = 0; 5344 designator_depth = 0; 5345 designator_errorneous = 0; 5346 } 5347 5348 /* Don't die if an entire brace-pair level is superfluous 5349 in the containing level. */ 5350 if (constructor_type == 0) 5351 ; 5352 else if (TREE_CODE (constructor_type) == RECORD_TYPE 5353 || TREE_CODE (constructor_type) == UNION_TYPE) 5354 { 5355 /* Don't die if there are extra init elts at the end. */ 5356 if (constructor_fields == 0) 5357 constructor_type = 0; 5358 else 5359 { 5360 constructor_type = TREE_TYPE (constructor_fields); 5361 push_member_name (constructor_fields); 5362 constructor_depth++; 5363 } 5364 } 5365 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5366 { 5367 constructor_type = TREE_TYPE (constructor_type); 5368 push_array_bounds (tree_low_cst (constructor_index, 0)); 5369 constructor_depth++; 5370 } 5371 5372 if (constructor_type == 0) 5373 { 5374 error_init ("extra brace group at end of initializer"); 5375 constructor_fields = 0; 5376 constructor_unfilled_fields = 0; 5377 return; 5378 } 5379 5380 if (value && TREE_CODE (value) == CONSTRUCTOR) 5381 { 5382 constructor_constant = TREE_CONSTANT (value); 5383 constructor_simple = TREE_STATIC (value); 5384 constructor_elements = TREE_OPERAND (value, 1); 5385 if (constructor_elements 5386 && (TREE_CODE (constructor_type) == RECORD_TYPE 5387 || TREE_CODE (constructor_type) == ARRAY_TYPE)) 5388 set_nonincremental_init (); 5389 } 5390 5391 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 5392 { 5393 missing_braces_mentioned = 1; 5394 warning_init ("missing braces around initializer"); 5395 } 5396 5397 if (TREE_CODE (constructor_type) == RECORD_TYPE 5398 || TREE_CODE (constructor_type) == UNION_TYPE) 5399 { 5400 constructor_fields = TYPE_FIELDS (constructor_type); 5401 /* Skip any nameless bit fields at the beginning. */ 5402 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5403 && DECL_NAME (constructor_fields) == 0) 5404 constructor_fields = TREE_CHAIN (constructor_fields); 5405 5406 constructor_unfilled_fields = constructor_fields; 5407 constructor_bit_index = bitsize_zero_node; 5408 } 5409 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 5410 { 5411 /* Vectors are like simple fixed-size arrays. */ 5412 constructor_max_index = 5413 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0); 5414 constructor_index = convert (bitsizetype, integer_zero_node); 5415 constructor_unfilled_index = constructor_index; 5416 } 5417 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5418 { 5419 if (TYPE_DOMAIN (constructor_type)) 5420 { 5421 constructor_max_index 5422 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5423 5424 /* Detect non-empty initializations of zero-length arrays. */ 5425 if (constructor_max_index == NULL_TREE 5426 && TYPE_SIZE (constructor_type)) 5427 constructor_max_index = build_int_2 (-1, -1); 5428 5429 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5430 to initialize VLAs will cause a proper error; avoid tree 5431 checking errors as well by setting a safe value. */ 5432 if (constructor_max_index 5433 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5434 constructor_max_index = build_int_2 (-1, -1); 5435 5436 constructor_index 5437 = convert (bitsizetype, 5438 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5439 } 5440 else 5441 constructor_index = bitsize_zero_node; 5442 5443 constructor_unfilled_index = constructor_index; 5444 if (value && TREE_CODE (value) == STRING_CST) 5445 { 5446 /* We need to split the char/wchar array into individual 5447 characters, so that we don't have to special case it 5448 everywhere. */ 5449 set_nonincremental_init_from_string (value); 5450 } 5451 } 5452 else 5453 { 5454 warning_init ("braces around scalar initializer"); 5455 constructor_fields = constructor_type; 5456 constructor_unfilled_fields = constructor_type; 5457 } 5458} 5459 5460/* At the end of an implicit or explicit brace level, 5461 finish up that level of constructor. 5462 If we were outputting the elements as they are read, return 0 5463 from inner levels (process_init_element ignores that), 5464 but return error_mark_node from the outermost level 5465 (that's what we want to put in DECL_INITIAL). 5466 Otherwise, return a CONSTRUCTOR expression. */ 5467 5468tree 5469pop_init_level (implicit) 5470 int implicit; 5471{ 5472 struct constructor_stack *p; 5473 tree constructor = 0; 5474 5475 if (implicit == 0) 5476 { 5477 /* When we come to an explicit close brace, 5478 pop any inner levels that didn't have explicit braces. */ 5479 while (constructor_stack->implicit) 5480 process_init_element (pop_init_level (1)); 5481 5482 if (constructor_range_stack) 5483 abort (); 5484 } 5485 5486 p = constructor_stack; 5487 5488 /* Error for initializing a flexible array member, or a zero-length 5489 array member in an inappropriate context. */ 5490 if (constructor_type && constructor_fields 5491 && TREE_CODE (constructor_type) == ARRAY_TYPE 5492 && TYPE_DOMAIN (constructor_type) 5493 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 5494 { 5495 /* Silently discard empty initializations. The parser will 5496 already have pedwarned for empty brackets. */ 5497 if (integer_zerop (constructor_unfilled_index)) 5498 constructor_type = NULL_TREE; 5499 else if (! TYPE_SIZE (constructor_type)) 5500 { 5501 if (constructor_depth > 2) 5502 error_init ("initialization of flexible array member in a nested context"); 5503 else if (pedantic) 5504 pedwarn_init ("initialization of a flexible array member"); 5505 5506 /* We have already issued an error message for the existence 5507 of a flexible array member not at the end of the structure. 5508 Discard the initializer so that we do not abort later. */ 5509 if (TREE_CHAIN (constructor_fields) != NULL_TREE) 5510 constructor_type = NULL_TREE; 5511 } 5512 else 5513 /* Zero-length arrays are no longer special, so we should no longer 5514 get here. */ 5515 abort (); 5516 } 5517 5518 /* Warn when some struct elements are implicitly initialized to zero. */ 5519 if (extra_warnings 5520 && constructor_type 5521 && TREE_CODE (constructor_type) == RECORD_TYPE 5522 && constructor_unfilled_fields) 5523 { 5524 /* Do not warn for flexible array members or zero-length arrays. */ 5525 while (constructor_unfilled_fields 5526 && (! DECL_SIZE (constructor_unfilled_fields) 5527 || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 5528 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5529 5530 /* Do not warn if this level of the initializer uses member 5531 designators; it is likely to be deliberate. */ 5532 if (constructor_unfilled_fields && !constructor_designated) 5533 { 5534 push_member_name (constructor_unfilled_fields); 5535 warning_init ("missing initializer"); 5536 RESTORE_SPELLING_DEPTH (constructor_depth); 5537 } 5538 } 5539 5540 /* Now output all pending elements. */ 5541 constructor_incremental = 1; 5542 output_pending_init_elements (1); 5543 5544 /* Pad out the end of the structure. */ 5545 if (p->replacement_value) 5546 /* If this closes a superfluous brace pair, 5547 just pass out the element between them. */ 5548 constructor = p->replacement_value; 5549 else if (constructor_type == 0) 5550 ; 5551 else if (TREE_CODE (constructor_type) != RECORD_TYPE 5552 && TREE_CODE (constructor_type) != UNION_TYPE 5553 && TREE_CODE (constructor_type) != ARRAY_TYPE 5554 && TREE_CODE (constructor_type) != VECTOR_TYPE) 5555 { 5556 /* A nonincremental scalar initializer--just return 5557 the element, after verifying there is just one. */ 5558 if (constructor_elements == 0) 5559 { 5560 if (!constructor_erroneous) 5561 error_init ("empty scalar initializer"); 5562 constructor = error_mark_node; 5563 } 5564 else if (TREE_CHAIN (constructor_elements) != 0) 5565 { 5566 error_init ("extra elements in scalar initializer"); 5567 constructor = TREE_VALUE (constructor_elements); 5568 } 5569 else 5570 constructor = TREE_VALUE (constructor_elements); 5571 } 5572 else 5573 { 5574 if (constructor_erroneous) 5575 constructor = error_mark_node; 5576 else 5577 { 5578 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE, 5579 nreverse (constructor_elements)); 5580 if (constructor_constant) 5581 TREE_CONSTANT (constructor) = 1; 5582 if (constructor_constant && constructor_simple) 5583 TREE_STATIC (constructor) = 1; 5584 } 5585 } 5586 5587 constructor_type = p->type; 5588 constructor_fields = p->fields; 5589 constructor_index = p->index; 5590 constructor_max_index = p->max_index; 5591 constructor_unfilled_index = p->unfilled_index; 5592 constructor_unfilled_fields = p->unfilled_fields; 5593 constructor_bit_index = p->bit_index; 5594 constructor_elements = p->elements; 5595 constructor_constant = p->constant; 5596 constructor_simple = p->simple; 5597 constructor_erroneous = p->erroneous; 5598 constructor_incremental = p->incremental; 5599 constructor_designated = p->designated; 5600 constructor_pending_elts = p->pending_elts; 5601 constructor_depth = p->depth; 5602 if (!p->implicit) 5603 constructor_range_stack = p->range_stack; 5604 RESTORE_SPELLING_DEPTH (constructor_depth); 5605 5606 constructor_stack = p->next; 5607 free (p); 5608 5609 if (constructor == 0) 5610 { 5611 if (constructor_stack == 0) 5612 return error_mark_node; 5613 return NULL_TREE; 5614 } 5615 return constructor; 5616} 5617 5618/* Common handling for both array range and field name designators. 5619 ARRAY argument is nonzero for array ranges. Returns zero for success. */ 5620 5621static int 5622set_designator (array) 5623 int array; 5624{ 5625 tree subtype; 5626 enum tree_code subcode; 5627 5628 /* Don't die if an entire brace-pair level is superfluous 5629 in the containing level. */ 5630 if (constructor_type == 0) 5631 return 1; 5632 5633 /* If there were errors in this designator list already, bail out silently. */ 5634 if (designator_errorneous) 5635 return 1; 5636 5637 if (!designator_depth) 5638 { 5639 if (constructor_range_stack) 5640 abort (); 5641 5642 /* Designator list starts at the level of closest explicit 5643 braces. */ 5644 while (constructor_stack->implicit) 5645 process_init_element (pop_init_level (1)); 5646 constructor_designated = 1; 5647 return 0; 5648 } 5649 5650 if (constructor_no_implicit) 5651 { 5652 error_init ("initialization designators may not nest"); 5653 return 1; 5654 } 5655 5656 if (TREE_CODE (constructor_type) == RECORD_TYPE 5657 || TREE_CODE (constructor_type) == UNION_TYPE) 5658 { 5659 subtype = TREE_TYPE (constructor_fields); 5660 if (subtype != error_mark_node) 5661 subtype = TYPE_MAIN_VARIANT (subtype); 5662 } 5663 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5664 { 5665 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5666 } 5667 else 5668 abort (); 5669 5670 subcode = TREE_CODE (subtype); 5671 if (array && subcode != ARRAY_TYPE) 5672 { 5673 error_init ("array index in non-array initializer"); 5674 return 1; 5675 } 5676 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 5677 { 5678 error_init ("field name not in record or union initializer"); 5679 return 1; 5680 } 5681 5682 constructor_designated = 1; 5683 push_init_level (2); 5684 return 0; 5685} 5686 5687/* If there are range designators in designator list, push a new designator 5688 to constructor_range_stack. RANGE_END is end of such stack range or 5689 NULL_TREE if there is no range designator at this level. */ 5690 5691static void 5692push_range_stack (range_end) 5693 tree range_end; 5694{ 5695 struct constructor_range_stack *p; 5696 5697 p = (struct constructor_range_stack *) 5698 ggc_alloc (sizeof (struct constructor_range_stack)); 5699 p->prev = constructor_range_stack; 5700 p->next = 0; 5701 p->fields = constructor_fields; 5702 p->range_start = constructor_index; 5703 p->index = constructor_index; 5704 p->stack = constructor_stack; 5705 p->range_end = range_end; 5706 if (constructor_range_stack) 5707 constructor_range_stack->next = p; 5708 constructor_range_stack = p; 5709} 5710 5711/* Within an array initializer, specify the next index to be initialized. 5712 FIRST is that index. If LAST is nonzero, then initialize a range 5713 of indices, running from FIRST through LAST. */ 5714 5715void 5716set_init_index (first, last) 5717 tree first, last; 5718{ 5719 if (set_designator (1)) 5720 return; 5721 5722 designator_errorneous = 1; 5723 5724 while ((TREE_CODE (first) == NOP_EXPR 5725 || TREE_CODE (first) == CONVERT_EXPR 5726 || TREE_CODE (first) == NON_LVALUE_EXPR) 5727 && (TYPE_MODE (TREE_TYPE (first)) 5728 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0))))) 5729 first = TREE_OPERAND (first, 0); 5730 5731 if (last) 5732 while ((TREE_CODE (last) == NOP_EXPR 5733 || TREE_CODE (last) == CONVERT_EXPR 5734 || TREE_CODE (last) == NON_LVALUE_EXPR) 5735 && (TYPE_MODE (TREE_TYPE (last)) 5736 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0))))) 5737 last = TREE_OPERAND (last, 0); 5738 5739 if (TREE_CODE (first) != INTEGER_CST) 5740 error_init ("nonconstant array index in initializer"); 5741 else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 5742 error_init ("nonconstant array index in initializer"); 5743 else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 5744 error_init ("array index in non-array initializer"); 5745 else if (constructor_max_index 5746 && tree_int_cst_lt (constructor_max_index, first)) 5747 error_init ("array index in initializer exceeds array bounds"); 5748 else 5749 { 5750 constructor_index = convert (bitsizetype, first); 5751 5752 if (last) 5753 { 5754 if (tree_int_cst_equal (first, last)) 5755 last = 0; 5756 else if (tree_int_cst_lt (last, first)) 5757 { 5758 error_init ("empty index range in initializer"); 5759 last = 0; 5760 } 5761 else 5762 { 5763 last = convert (bitsizetype, last); 5764 if (constructor_max_index != 0 5765 && tree_int_cst_lt (constructor_max_index, last)) 5766 { 5767 error_init ("array index range in initializer exceeds array bounds"); 5768 last = 0; 5769 } 5770 } 5771 } 5772 5773 designator_depth++; 5774 designator_errorneous = 0; 5775 if (constructor_range_stack || last) 5776 push_range_stack (last); 5777 } 5778} 5779 5780/* Within a struct initializer, specify the next field to be initialized. */ 5781 5782void 5783set_init_label (fieldname) 5784 tree fieldname; 5785{ 5786 tree tail; 5787 5788 if (set_designator (0)) 5789 return; 5790 5791 designator_errorneous = 1; 5792 5793 if (TREE_CODE (constructor_type) != RECORD_TYPE 5794 && TREE_CODE (constructor_type) != UNION_TYPE) 5795 { 5796 error_init ("field name not in record or union initializer"); 5797 return; 5798 } 5799 5800 for (tail = TYPE_FIELDS (constructor_type); tail; 5801 tail = TREE_CHAIN (tail)) 5802 { 5803 if (DECL_NAME (tail) == fieldname) 5804 break; 5805 } 5806 5807 if (tail == 0) 5808 error ("unknown field `%s' specified in initializer", 5809 IDENTIFIER_POINTER (fieldname)); 5810 else 5811 { 5812 constructor_fields = tail; 5813 designator_depth++; 5814 designator_errorneous = 0; 5815 if (constructor_range_stack) 5816 push_range_stack (NULL_TREE); 5817 } 5818} 5819 5820/* Add a new initializer to the tree of pending initializers. PURPOSE 5821 identifies the initializer, either array index or field in a structure. 5822 VALUE is the value of that index or field. */ 5823 5824static void 5825add_pending_init (purpose, value) 5826 tree purpose, value; 5827{ 5828 struct init_node *p, **q, *r; 5829 5830 q = &constructor_pending_elts; 5831 p = 0; 5832 5833 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5834 { 5835 while (*q != 0) 5836 { 5837 p = *q; 5838 if (tree_int_cst_lt (purpose, p->purpose)) 5839 q = &p->left; 5840 else if (tree_int_cst_lt (p->purpose, purpose)) 5841 q = &p->right; 5842 else 5843 { 5844 if (TREE_SIDE_EFFECTS (p->value)) 5845 warning_init ("initialized field with side-effects overwritten"); 5846 p->value = value; 5847 return; 5848 } 5849 } 5850 } 5851 else 5852 { 5853 tree bitpos; 5854 5855 bitpos = bit_position (purpose); 5856 while (*q != NULL) 5857 { 5858 p = *q; 5859 if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 5860 q = &p->left; 5861 else if (p->purpose != purpose) 5862 q = &p->right; 5863 else 5864 { 5865 if (TREE_SIDE_EFFECTS (p->value)) 5866 warning_init ("initialized field with side-effects overwritten"); 5867 p->value = value; 5868 return; 5869 } 5870 } 5871 } 5872 5873 r = (struct init_node *) ggc_alloc (sizeof (struct init_node)); 5874 r->purpose = purpose; 5875 r->value = value; 5876 5877 *q = r; 5878 r->parent = p; 5879 r->left = 0; 5880 r->right = 0; 5881 r->balance = 0; 5882 5883 while (p) 5884 { 5885 struct init_node *s; 5886 5887 if (r == p->left) 5888 { 5889 if (p->balance == 0) 5890 p->balance = -1; 5891 else if (p->balance < 0) 5892 { 5893 if (r->balance < 0) 5894 { 5895 /* L rotation. */ 5896 p->left = r->right; 5897 if (p->left) 5898 p->left->parent = p; 5899 r->right = p; 5900 5901 p->balance = 0; 5902 r->balance = 0; 5903 5904 s = p->parent; 5905 p->parent = r; 5906 r->parent = s; 5907 if (s) 5908 { 5909 if (s->left == p) 5910 s->left = r; 5911 else 5912 s->right = r; 5913 } 5914 else 5915 constructor_pending_elts = r; 5916 } 5917 else 5918 { 5919 /* LR rotation. */ 5920 struct init_node *t = r->right; 5921 5922 r->right = t->left; 5923 if (r->right) 5924 r->right->parent = r; 5925 t->left = r; 5926 5927 p->left = t->right; 5928 if (p->left) 5929 p->left->parent = p; 5930 t->right = p; 5931 5932 p->balance = t->balance < 0; 5933 r->balance = -(t->balance > 0); 5934 t->balance = 0; 5935 5936 s = p->parent; 5937 p->parent = t; 5938 r->parent = t; 5939 t->parent = s; 5940 if (s) 5941 { 5942 if (s->left == p) 5943 s->left = t; 5944 else 5945 s->right = t; 5946 } 5947 else 5948 constructor_pending_elts = t; 5949 } 5950 break; 5951 } 5952 else 5953 { 5954 /* p->balance == +1; growth of left side balances the node. */ 5955 p->balance = 0; 5956 break; 5957 } 5958 } 5959 else /* r == p->right */ 5960 { 5961 if (p->balance == 0) 5962 /* Growth propagation from right side. */ 5963 p->balance++; 5964 else if (p->balance > 0) 5965 { 5966 if (r->balance > 0) 5967 { 5968 /* R rotation. */ 5969 p->right = r->left; 5970 if (p->right) 5971 p->right->parent = p; 5972 r->left = p; 5973 5974 p->balance = 0; 5975 r->balance = 0; 5976 5977 s = p->parent; 5978 p->parent = r; 5979 r->parent = s; 5980 if (s) 5981 { 5982 if (s->left == p) 5983 s->left = r; 5984 else 5985 s->right = r; 5986 } 5987 else 5988 constructor_pending_elts = r; 5989 } 5990 else /* r->balance == -1 */ 5991 { 5992 /* RL rotation */ 5993 struct init_node *t = r->left; 5994 5995 r->left = t->right; 5996 if (r->left) 5997 r->left->parent = r; 5998 t->right = r; 5999 6000 p->right = t->left; 6001 if (p->right) 6002 p->right->parent = p; 6003 t->left = p; 6004 6005 r->balance = (t->balance < 0); 6006 p->balance = -(t->balance > 0); 6007 t->balance = 0; 6008 6009 s = p->parent; 6010 p->parent = t; 6011 r->parent = t; 6012 t->parent = s; 6013 if (s) 6014 { 6015 if (s->left == p) 6016 s->left = t; 6017 else 6018 s->right = t; 6019 } 6020 else 6021 constructor_pending_elts = t; 6022 } 6023 break; 6024 } 6025 else 6026 { 6027 /* p->balance == -1; growth of right side balances the node. */ 6028 p->balance = 0; 6029 break; 6030 } 6031 } 6032 6033 r = p; 6034 p = p->parent; 6035 } 6036} 6037 6038/* Build AVL tree from a sorted chain. */ 6039 6040static void 6041set_nonincremental_init () 6042{ 6043 tree chain; 6044 6045 if (TREE_CODE (constructor_type) != RECORD_TYPE 6046 && TREE_CODE (constructor_type) != ARRAY_TYPE) 6047 return; 6048 6049 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain)) 6050 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain)); 6051 constructor_elements = 0; 6052 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6053 { 6054 constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 6055 /* Skip any nameless bit fields at the beginning. */ 6056 while (constructor_unfilled_fields != 0 6057 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6058 && DECL_NAME (constructor_unfilled_fields) == 0) 6059 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 6060 6061 } 6062 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6063 { 6064 if (TYPE_DOMAIN (constructor_type)) 6065 constructor_unfilled_index 6066 = convert (bitsizetype, 6067 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 6068 else 6069 constructor_unfilled_index = bitsize_zero_node; 6070 } 6071 constructor_incremental = 0; 6072} 6073 6074/* Build AVL tree from a string constant. */ 6075 6076static void 6077set_nonincremental_init_from_string (str) 6078 tree str; 6079{ 6080 tree value, purpose, type; 6081 HOST_WIDE_INT val[2]; 6082 const char *p, *end; 6083 int byte, wchar_bytes, charwidth, bitpos; 6084 6085 if (TREE_CODE (constructor_type) != ARRAY_TYPE) 6086 abort (); 6087 6088 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6089 == TYPE_PRECISION (char_type_node)) 6090 wchar_bytes = 1; 6091 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6092 == TYPE_PRECISION (wchar_type_node)) 6093 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6094 else 6095 abort (); 6096 6097 charwidth = TYPE_PRECISION (char_type_node); 6098 type = TREE_TYPE (constructor_type); 6099 p = TREE_STRING_POINTER (str); 6100 end = p + TREE_STRING_LENGTH (str); 6101 6102 for (purpose = bitsize_zero_node; 6103 p < end && !tree_int_cst_lt (constructor_max_index, purpose); 6104 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 6105 { 6106 if (wchar_bytes == 1) 6107 { 6108 val[1] = (unsigned char) *p++; 6109 val[0] = 0; 6110 } 6111 else 6112 { 6113 val[0] = 0; 6114 val[1] = 0; 6115 for (byte = 0; byte < wchar_bytes; byte++) 6116 { 6117 if (BYTES_BIG_ENDIAN) 6118 bitpos = (wchar_bytes - byte - 1) * charwidth; 6119 else 6120 bitpos = byte * charwidth; 6121 val[bitpos < HOST_BITS_PER_WIDE_INT] 6122 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 6123 << (bitpos % HOST_BITS_PER_WIDE_INT); 6124 } 6125 } 6126 6127 if (!TREE_UNSIGNED (type)) 6128 { 6129 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 6130 if (bitpos < HOST_BITS_PER_WIDE_INT) 6131 { 6132 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 6133 { 6134 val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 6135 val[0] = -1; 6136 } 6137 } 6138 else if (bitpos == HOST_BITS_PER_WIDE_INT) 6139 { 6140 if (val[1] < 0) 6141 val[0] = -1; 6142 } 6143 else if (val[0] & (((HOST_WIDE_INT) 1) 6144 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 6145 val[0] |= ((HOST_WIDE_INT) -1) 6146 << (bitpos - HOST_BITS_PER_WIDE_INT); 6147 } 6148 6149 value = build_int_2 (val[1], val[0]); 6150 TREE_TYPE (value) = type; 6151 add_pending_init (purpose, value); 6152 } 6153 6154 constructor_incremental = 0; 6155} 6156 6157/* Return value of FIELD in pending initializer or zero if the field was 6158 not initialized yet. */ 6159 6160static tree 6161find_init_member (field) 6162 tree field; 6163{ 6164 struct init_node *p; 6165 6166 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6167 { 6168 if (constructor_incremental 6169 && tree_int_cst_lt (field, constructor_unfilled_index)) 6170 set_nonincremental_init (); 6171 6172 p = constructor_pending_elts; 6173 while (p) 6174 { 6175 if (tree_int_cst_lt (field, p->purpose)) 6176 p = p->left; 6177 else if (tree_int_cst_lt (p->purpose, field)) 6178 p = p->right; 6179 else 6180 return p->value; 6181 } 6182 } 6183 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6184 { 6185 tree bitpos = bit_position (field); 6186 6187 if (constructor_incremental 6188 && (!constructor_unfilled_fields 6189 || tree_int_cst_lt (bitpos, 6190 bit_position (constructor_unfilled_fields)))) 6191 set_nonincremental_init (); 6192 6193 p = constructor_pending_elts; 6194 while (p) 6195 { 6196 if (field == p->purpose) 6197 return p->value; 6198 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 6199 p = p->left; 6200 else 6201 p = p->right; 6202 } 6203 } 6204 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6205 { 6206 if (constructor_elements 6207 && TREE_PURPOSE (constructor_elements) == field) 6208 return TREE_VALUE (constructor_elements); 6209 } 6210 return 0; 6211} 6212 6213/* "Output" the next constructor element. 6214 At top level, really output it to assembler code now. 6215 Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 6216 TYPE is the data type that the containing data type wants here. 6217 FIELD is the field (a FIELD_DECL) or the index that this element fills. 6218 6219 PENDING if non-nil means output pending elements that belong 6220 right after this element. (PENDING is normally 1; 6221 it is 0 while outputting pending elements, to avoid recursion.) */ 6222 6223static void 6224output_init_element (value, type, field, pending) 6225 tree value, type, field; 6226 int pending; 6227{ 6228 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE 6229 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6230 && !(TREE_CODE (value) == STRING_CST 6231 && TREE_CODE (type) == ARRAY_TYPE 6232 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE) 6233 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6234 TYPE_MAIN_VARIANT (type)))) 6235 value = default_conversion (value); 6236 6237 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 6238 && require_constant_value && !flag_isoc99 && pending) 6239 { 6240 /* As an extension, allow initializing objects with static storage 6241 duration with compound literals (which are then treated just as 6242 the brace enclosed list they contain). */ 6243 tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 6244 value = DECL_INITIAL (decl); 6245 } 6246 6247 if (value == error_mark_node) 6248 constructor_erroneous = 1; 6249 else if (!TREE_CONSTANT (value)) 6250 constructor_constant = 0; 6251 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0 6252 || ((TREE_CODE (constructor_type) == RECORD_TYPE 6253 || TREE_CODE (constructor_type) == UNION_TYPE) 6254 && DECL_C_BIT_FIELD (field) 6255 && TREE_CODE (value) != INTEGER_CST)) 6256 constructor_simple = 0; 6257 6258 if (require_constant_value && ! TREE_CONSTANT (value)) 6259 { 6260 error_init ("initializer element is not constant"); 6261 value = error_mark_node; 6262 } 6263 else if (require_constant_elements 6264 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0) 6265 pedwarn ("initializer element is not computable at load time"); 6266 6267 /* If this field is empty (and not at the end of structure), 6268 don't do anything other than checking the initializer. */ 6269 if (field 6270 && (TREE_TYPE (field) == error_mark_node 6271 || (COMPLETE_TYPE_P (TREE_TYPE (field)) 6272 && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 6273 && (TREE_CODE (constructor_type) == ARRAY_TYPE 6274 || TREE_CHAIN (field))))) 6275 return; 6276 6277 value = digest_init (type, value, require_constant_value); 6278 if (value == error_mark_node) 6279 { 6280 constructor_erroneous = 1; 6281 return; 6282 } 6283 6284 /* If this element doesn't come next in sequence, 6285 put it on constructor_pending_elts. */ 6286 if (TREE_CODE (constructor_type) == ARRAY_TYPE 6287 && (!constructor_incremental 6288 || !tree_int_cst_equal (field, constructor_unfilled_index))) 6289 { 6290 if (constructor_incremental 6291 && tree_int_cst_lt (field, constructor_unfilled_index)) 6292 set_nonincremental_init (); 6293 6294 add_pending_init (field, value); 6295 return; 6296 } 6297 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6298 && (!constructor_incremental 6299 || field != constructor_unfilled_fields)) 6300 { 6301 /* We do this for records but not for unions. In a union, 6302 no matter which field is specified, it can be initialized 6303 right away since it starts at the beginning of the union. */ 6304 if (constructor_incremental) 6305 { 6306 if (!constructor_unfilled_fields) 6307 set_nonincremental_init (); 6308 else 6309 { 6310 tree bitpos, unfillpos; 6311 6312 bitpos = bit_position (field); 6313 unfillpos = bit_position (constructor_unfilled_fields); 6314 6315 if (tree_int_cst_lt (bitpos, unfillpos)) 6316 set_nonincremental_init (); 6317 } 6318 } 6319 6320 add_pending_init (field, value); 6321 return; 6322 } 6323 else if (TREE_CODE (constructor_type) == UNION_TYPE 6324 && constructor_elements) 6325 { 6326 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements))) 6327 warning_init ("initialized field with side-effects overwritten"); 6328 6329 /* We can have just one union field set. */ 6330 constructor_elements = 0; 6331 } 6332 6333 /* Otherwise, output this element either to 6334 constructor_elements or to the assembler file. */ 6335 6336 if (field && TREE_CODE (field) == INTEGER_CST) 6337 field = copy_node (field); 6338 constructor_elements 6339 = tree_cons (field, value, constructor_elements); 6340 6341 /* Advance the variable that indicates sequential elements output. */ 6342 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6343 constructor_unfilled_index 6344 = size_binop (PLUS_EXPR, constructor_unfilled_index, 6345 bitsize_one_node); 6346 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6347 { 6348 constructor_unfilled_fields 6349 = TREE_CHAIN (constructor_unfilled_fields); 6350 6351 /* Skip any nameless bit fields. */ 6352 while (constructor_unfilled_fields != 0 6353 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6354 && DECL_NAME (constructor_unfilled_fields) == 0) 6355 constructor_unfilled_fields = 6356 TREE_CHAIN (constructor_unfilled_fields); 6357 } 6358 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6359 constructor_unfilled_fields = 0; 6360 6361 /* Now output any pending elements which have become next. */ 6362 if (pending) 6363 output_pending_init_elements (0); 6364} 6365 6366/* Output any pending elements which have become next. 6367 As we output elements, constructor_unfilled_{fields,index} 6368 advances, which may cause other elements to become next; 6369 if so, they too are output. 6370 6371 If ALL is 0, we return when there are 6372 no more pending elements to output now. 6373 6374 If ALL is 1, we output space as necessary so that 6375 we can output all the pending elements. */ 6376 6377static void 6378output_pending_init_elements (all) 6379 int all; 6380{ 6381 struct init_node *elt = constructor_pending_elts; 6382 tree next; 6383 6384 retry: 6385 6386 /* Look thru the whole pending tree. 6387 If we find an element that should be output now, 6388 output it. Otherwise, set NEXT to the element 6389 that comes first among those still pending. */ 6390 6391 next = 0; 6392 while (elt) 6393 { 6394 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6395 { 6396 if (tree_int_cst_equal (elt->purpose, 6397 constructor_unfilled_index)) 6398 output_init_element (elt->value, 6399 TREE_TYPE (constructor_type), 6400 constructor_unfilled_index, 0); 6401 else if (tree_int_cst_lt (constructor_unfilled_index, 6402 elt->purpose)) 6403 { 6404 /* Advance to the next smaller node. */ 6405 if (elt->left) 6406 elt = elt->left; 6407 else 6408 { 6409 /* We have reached the smallest node bigger than the 6410 current unfilled index. Fill the space first. */ 6411 next = elt->purpose; 6412 break; 6413 } 6414 } 6415 else 6416 { 6417 /* Advance to the next bigger node. */ 6418 if (elt->right) 6419 elt = elt->right; 6420 else 6421 { 6422 /* We have reached the biggest node in a subtree. Find 6423 the parent of it, which is the next bigger node. */ 6424 while (elt->parent && elt->parent->right == elt) 6425 elt = elt->parent; 6426 elt = elt->parent; 6427 if (elt && tree_int_cst_lt (constructor_unfilled_index, 6428 elt->purpose)) 6429 { 6430 next = elt->purpose; 6431 break; 6432 } 6433 } 6434 } 6435 } 6436 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6437 || TREE_CODE (constructor_type) == UNION_TYPE) 6438 { 6439 tree ctor_unfilled_bitpos, elt_bitpos; 6440 6441 /* If the current record is complete we are done. */ 6442 if (constructor_unfilled_fields == 0) 6443 break; 6444 6445 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 6446 elt_bitpos = bit_position (elt->purpose); 6447 /* We can't compare fields here because there might be empty 6448 fields in between. */ 6449 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 6450 { 6451 constructor_unfilled_fields = elt->purpose; 6452 output_init_element (elt->value, TREE_TYPE (elt->purpose), 6453 elt->purpose, 0); 6454 } 6455 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 6456 { 6457 /* Advance to the next smaller node. */ 6458 if (elt->left) 6459 elt = elt->left; 6460 else 6461 { 6462 /* We have reached the smallest node bigger than the 6463 current unfilled field. Fill the space first. */ 6464 next = elt->purpose; 6465 break; 6466 } 6467 } 6468 else 6469 { 6470 /* Advance to the next bigger node. */ 6471 if (elt->right) 6472 elt = elt->right; 6473 else 6474 { 6475 /* We have reached the biggest node in a subtree. Find 6476 the parent of it, which is the next bigger node. */ 6477 while (elt->parent && elt->parent->right == elt) 6478 elt = elt->parent; 6479 elt = elt->parent; 6480 if (elt 6481 && (tree_int_cst_lt (ctor_unfilled_bitpos, 6482 bit_position (elt->purpose)))) 6483 { 6484 next = elt->purpose; 6485 break; 6486 } 6487 } 6488 } 6489 } 6490 } 6491 6492 /* Ordinarily return, but not if we want to output all 6493 and there are elements left. */ 6494 if (! (all && next != 0)) 6495 return; 6496 6497 /* If it's not incremental, just skip over the gap, so that after 6498 jumping to retry we will output the next successive element. */ 6499 if (TREE_CODE (constructor_type) == RECORD_TYPE 6500 || TREE_CODE (constructor_type) == UNION_TYPE) 6501 constructor_unfilled_fields = next; 6502 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6503 constructor_unfilled_index = next; 6504 6505 /* ELT now points to the node in the pending tree with the next 6506 initializer to output. */ 6507 goto retry; 6508} 6509 6510/* Add one non-braced element to the current constructor level. 6511 This adjusts the current position within the constructor's type. 6512 This may also start or terminate implicit levels 6513 to handle a partly-braced initializer. 6514 6515 Once this has found the correct level for the new element, 6516 it calls output_init_element. */ 6517 6518void 6519process_init_element (value) 6520 tree value; 6521{ 6522 tree orig_value = value; 6523 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST; 6524 6525 designator_depth = 0; 6526 designator_errorneous = 0; 6527 6528 /* Handle superfluous braces around string cst as in 6529 char x[] = {"foo"}; */ 6530 if (string_flag 6531 && constructor_type 6532 && TREE_CODE (constructor_type) == ARRAY_TYPE 6533 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE 6534 && integer_zerop (constructor_unfilled_index)) 6535 { 6536 if (constructor_stack->replacement_value) 6537 error_init ("excess elements in char array initializer"); 6538 constructor_stack->replacement_value = value; 6539 return; 6540 } 6541 6542 if (constructor_stack->replacement_value != 0) 6543 { 6544 error_init ("excess elements in struct initializer"); 6545 return; 6546 } 6547 6548 /* Ignore elements of a brace group if it is entirely superfluous 6549 and has already been diagnosed. */ 6550 if (constructor_type == 0) 6551 return; 6552 6553 /* If we've exhausted any levels that didn't have braces, 6554 pop them now. */ 6555 while (constructor_stack->implicit) 6556 { 6557 if ((TREE_CODE (constructor_type) == RECORD_TYPE 6558 || TREE_CODE (constructor_type) == UNION_TYPE) 6559 && constructor_fields == 0) 6560 process_init_element (pop_init_level (1)); 6561 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 6562 && (constructor_max_index == 0 6563 || tree_int_cst_lt (constructor_max_index, 6564 constructor_index))) 6565 process_init_element (pop_init_level (1)); 6566 else 6567 break; 6568 } 6569 6570 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 6571 if (constructor_range_stack) 6572 { 6573 /* If value is a compound literal and we'll be just using its 6574 content, don't put it into a SAVE_EXPR. */ 6575 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR 6576 || !require_constant_value 6577 || flag_isoc99) 6578 value = save_expr (value); 6579 } 6580 6581 while (1) 6582 { 6583 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6584 { 6585 tree fieldtype; 6586 enum tree_code fieldcode; 6587 6588 if (constructor_fields == 0) 6589 { 6590 pedwarn_init ("excess elements in struct initializer"); 6591 break; 6592 } 6593 6594 fieldtype = TREE_TYPE (constructor_fields); 6595 if (fieldtype != error_mark_node) 6596 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6597 fieldcode = TREE_CODE (fieldtype); 6598 6599 /* Error for non-static initialization of a flexible array member. */ 6600 if (fieldcode == ARRAY_TYPE 6601 && !require_constant_value 6602 && TYPE_SIZE (fieldtype) == NULL_TREE 6603 && TREE_CHAIN (constructor_fields) == NULL_TREE) 6604 { 6605 error_init ("non-static initialization of a flexible array member"); 6606 break; 6607 } 6608 6609 /* Accept a string constant to initialize a subarray. */ 6610 if (value != 0 6611 && fieldcode == ARRAY_TYPE 6612 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE 6613 && string_flag) 6614 value = orig_value; 6615 /* Otherwise, if we have come to a subaggregate, 6616 and we don't have an element of its type, push into it. */ 6617 else if (value != 0 && !constructor_no_implicit 6618 && value != error_mark_node 6619 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype 6620 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6621 || fieldcode == UNION_TYPE)) 6622 { 6623 push_init_level (1); 6624 continue; 6625 } 6626 6627 if (value) 6628 { 6629 push_member_name (constructor_fields); 6630 output_init_element (value, fieldtype, constructor_fields, 1); 6631 RESTORE_SPELLING_DEPTH (constructor_depth); 6632 } 6633 else 6634 /* Do the bookkeeping for an element that was 6635 directly output as a constructor. */ 6636 { 6637 /* For a record, keep track of end position of last field. */ 6638 if (DECL_SIZE (constructor_fields)) 6639 constructor_bit_index 6640 = size_binop (PLUS_EXPR, 6641 bit_position (constructor_fields), 6642 DECL_SIZE (constructor_fields)); 6643 6644 /* If the current field was the first one not yet written out, 6645 it isn't now, so update. */ 6646 if (constructor_unfilled_fields == constructor_fields) 6647 { 6648 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6649 /* Skip any nameless bit fields. */ 6650 while (constructor_unfilled_fields != 0 6651 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6652 && DECL_NAME (constructor_unfilled_fields) == 0) 6653 constructor_unfilled_fields = 6654 TREE_CHAIN (constructor_unfilled_fields); 6655 } 6656 } 6657 6658 constructor_fields = TREE_CHAIN (constructor_fields); 6659 /* Skip any nameless bit fields at the beginning. */ 6660 while (constructor_fields != 0 6661 && DECL_C_BIT_FIELD (constructor_fields) 6662 && DECL_NAME (constructor_fields) == 0) 6663 constructor_fields = TREE_CHAIN (constructor_fields); 6664 } 6665 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6666 { 6667 tree fieldtype; 6668 enum tree_code fieldcode; 6669 6670 if (constructor_fields == 0) 6671 { 6672 pedwarn_init ("excess elements in union initializer"); 6673 break; 6674 } 6675 6676 fieldtype = TREE_TYPE (constructor_fields); 6677 if (fieldtype != error_mark_node) 6678 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6679 fieldcode = TREE_CODE (fieldtype); 6680 6681 /* Warn that traditional C rejects initialization of unions. 6682 We skip the warning if the value is zero. This is done 6683 under the assumption that the zero initializer in user 6684 code appears conditioned on e.g. __STDC__ to avoid 6685 "missing initializer" warnings and relies on default 6686 initialization to zero in the traditional C case. 6687 We also skip the warning if the initializer is designated, 6688 again on the assumption that this must be conditional on 6689 __STDC__ anyway (and we've already complained about the 6690 member-designator already). */ 6691 if (warn_traditional && !in_system_header && !constructor_designated 6692 && !(value && (integer_zerop (value) || real_zerop (value)))) 6693 warning ("traditional C rejects initialization of unions"); 6694 6695 /* Accept a string constant to initialize a subarray. */ 6696 if (value != 0 6697 && fieldcode == ARRAY_TYPE 6698 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE 6699 && string_flag) 6700 value = orig_value; 6701 /* Otherwise, if we have come to a subaggregate, 6702 and we don't have an element of its type, push into it. */ 6703 else if (value != 0 && !constructor_no_implicit 6704 && value != error_mark_node 6705 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype 6706 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6707 || fieldcode == UNION_TYPE)) 6708 { 6709 push_init_level (1); 6710 continue; 6711 } 6712 6713 if (value) 6714 { 6715 push_member_name (constructor_fields); 6716 output_init_element (value, fieldtype, constructor_fields, 1); 6717 RESTORE_SPELLING_DEPTH (constructor_depth); 6718 } 6719 else 6720 /* Do the bookkeeping for an element that was 6721 directly output as a constructor. */ 6722 { 6723 constructor_bit_index = DECL_SIZE (constructor_fields); 6724 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6725 } 6726 6727 constructor_fields = 0; 6728 } 6729 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6730 { 6731 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 6732 enum tree_code eltcode = TREE_CODE (elttype); 6733 6734 /* Accept a string constant to initialize a subarray. */ 6735 if (value != 0 6736 && eltcode == ARRAY_TYPE 6737 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE 6738 && string_flag) 6739 value = orig_value; 6740 /* Otherwise, if we have come to a subaggregate, 6741 and we don't have an element of its type, push into it. */ 6742 else if (value != 0 && !constructor_no_implicit 6743 && value != error_mark_node 6744 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype 6745 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 6746 || eltcode == UNION_TYPE)) 6747 { 6748 push_init_level (1); 6749 continue; 6750 } 6751 6752 if (constructor_max_index != 0 6753 && (tree_int_cst_lt (constructor_max_index, constructor_index) 6754 || integer_all_onesp (constructor_max_index))) 6755 { 6756 pedwarn_init ("excess elements in array initializer"); 6757 break; 6758 } 6759 6760 /* Now output the actual element. */ 6761 if (value) 6762 { 6763 push_array_bounds (tree_low_cst (constructor_index, 0)); 6764 output_init_element (value, elttype, constructor_index, 1); 6765 RESTORE_SPELLING_DEPTH (constructor_depth); 6766 } 6767 6768 constructor_index 6769 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 6770 6771 if (! value) 6772 /* If we are doing the bookkeeping for an element that was 6773 directly output as a constructor, we must update 6774 constructor_unfilled_index. */ 6775 constructor_unfilled_index = constructor_index; 6776 } 6777 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 6778 { 6779 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 6780 6781 /* Do a basic check of initializer size. Note that vectors 6782 always have a fixed size derived from their type. */ 6783 if (tree_int_cst_lt (constructor_max_index, constructor_index)) 6784 { 6785 pedwarn_init ("excess elements in vector initializer"); 6786 break; 6787 } 6788 6789 /* Now output the actual element. */ 6790 if (value) 6791 output_init_element (value, elttype, constructor_index, 1); 6792 6793 constructor_index 6794 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 6795 6796 if (! value) 6797 /* If we are doing the bookkeeping for an element that was 6798 directly output as a constructor, we must update 6799 constructor_unfilled_index. */ 6800 constructor_unfilled_index = constructor_index; 6801 } 6802 6803 /* Handle the sole element allowed in a braced initializer 6804 for a scalar variable. */ 6805 else if (constructor_fields == 0) 6806 { 6807 pedwarn_init ("excess elements in scalar initializer"); 6808 break; 6809 } 6810 else 6811 { 6812 if (value) 6813 output_init_element (value, constructor_type, NULL_TREE, 1); 6814 constructor_fields = 0; 6815 } 6816 6817 /* Handle range initializers either at this level or anywhere higher 6818 in the designator stack. */ 6819 if (constructor_range_stack) 6820 { 6821 struct constructor_range_stack *p, *range_stack; 6822 int finish = 0; 6823 6824 range_stack = constructor_range_stack; 6825 constructor_range_stack = 0; 6826 while (constructor_stack != range_stack->stack) 6827 { 6828 if (!constructor_stack->implicit) 6829 abort (); 6830 process_init_element (pop_init_level (1)); 6831 } 6832 for (p = range_stack; 6833 !p->range_end || tree_int_cst_equal (p->index, p->range_end); 6834 p = p->prev) 6835 { 6836 if (!constructor_stack->implicit) 6837 abort (); 6838 process_init_element (pop_init_level (1)); 6839 } 6840 6841 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 6842 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 6843 finish = 1; 6844 6845 while (1) 6846 { 6847 constructor_index = p->index; 6848 constructor_fields = p->fields; 6849 if (finish && p->range_end && p->index == p->range_start) 6850 { 6851 finish = 0; 6852 p->prev = 0; 6853 } 6854 p = p->next; 6855 if (!p) 6856 break; 6857 push_init_level (2); 6858 p->stack = constructor_stack; 6859 if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 6860 p->index = p->range_start; 6861 } 6862 6863 if (!finish) 6864 constructor_range_stack = range_stack; 6865 continue; 6866 } 6867 6868 break; 6869 } 6870 6871 constructor_range_stack = 0; 6872} 6873 6874/* Build a simple asm-statement, from one string literal. */ 6875tree 6876simple_asm_stmt (expr) 6877 tree expr; 6878{ 6879 STRIP_NOPS (expr); 6880 6881 if (TREE_CODE (expr) == ADDR_EXPR) 6882 expr = TREE_OPERAND (expr, 0); 6883 6884 if (TREE_CODE (expr) == STRING_CST) 6885 { 6886 tree stmt; 6887 6888 /* Simple asm statements are treated as volatile. */ 6889 stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE], 6890 expr, NULL_TREE, NULL_TREE, NULL_TREE)); 6891 ASM_INPUT_P (stmt) = 1; 6892 return stmt; 6893 } 6894 6895 error ("argument of `asm' is not a constant string"); 6896 return NULL_TREE; 6897} 6898 6899/* Build an asm-statement, whose components are a CV_QUALIFIER, a 6900 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */ 6901 6902tree 6903build_asm_stmt (cv_qualifier, string, outputs, inputs, clobbers) 6904 tree cv_qualifier; 6905 tree string; 6906 tree outputs; 6907 tree inputs; 6908 tree clobbers; 6909{ 6910 tree tail; 6911 6912 if (TREE_CODE (string) != STRING_CST) 6913 { 6914 error ("asm template is not a string constant"); 6915 return NULL_TREE; 6916 } 6917 6918 if (cv_qualifier != NULL_TREE 6919 && cv_qualifier != ridpointers[(int) RID_VOLATILE]) 6920 { 6921 warning ("%s qualifier ignored on asm", 6922 IDENTIFIER_POINTER (cv_qualifier)); 6923 cv_qualifier = NULL_TREE; 6924 } 6925 6926 /* We can remove output conversions that change the type, 6927 but not the mode. */ 6928 for (tail = outputs; tail; tail = TREE_CHAIN (tail)) 6929 { 6930 tree output = TREE_VALUE (tail); 6931 6932 STRIP_NOPS (output); 6933 TREE_VALUE (tail) = output; 6934 6935 /* Allow conversions as LHS here. build_modify_expr as called below 6936 will do the right thing with them. */ 6937 while (TREE_CODE (output) == NOP_EXPR 6938 || TREE_CODE (output) == CONVERT_EXPR 6939 || TREE_CODE (output) == FLOAT_EXPR 6940 || TREE_CODE (output) == FIX_TRUNC_EXPR 6941 || TREE_CODE (output) == FIX_FLOOR_EXPR 6942 || TREE_CODE (output) == FIX_ROUND_EXPR 6943 || TREE_CODE (output) == FIX_CEIL_EXPR) 6944 output = TREE_OPERAND (output, 0); 6945 6946 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement"); 6947 } 6948 6949 /* Remove output conversions that change the type but not the mode. */ 6950 for (tail = outputs; tail; tail = TREE_CHAIN (tail)) 6951 { 6952 tree output = TREE_VALUE (tail); 6953 STRIP_NOPS (output); 6954 TREE_VALUE (tail) = output; 6955 } 6956 6957 /* Perform default conversions on array and function inputs. 6958 Don't do this for other types as it would screw up operands 6959 expected to be in memory. */ 6960 for (tail = inputs; tail; tail = TREE_CHAIN (tail)) 6961 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail)); 6962 6963 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string, 6964 outputs, inputs, clobbers)); 6965} 6966 6967/* Expand an ASM statement with operands, handling output operands 6968 that are not variables or INDIRECT_REFS by transforming such 6969 cases into cases that expand_asm_operands can handle. 6970 6971 Arguments are same as for expand_asm_operands. */ 6972 6973void 6974c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line) 6975 tree string, outputs, inputs, clobbers; 6976 int vol; 6977 const char *filename; 6978 int line; 6979{ 6980 int noutputs = list_length (outputs); 6981 int i; 6982 /* o[I] is the place that output number I should be written. */ 6983 tree *o = (tree *) alloca (noutputs * sizeof (tree)); 6984 tree tail; 6985 6986 /* Record the contents of OUTPUTS before it is modified. */ 6987 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) 6988 { 6989 o[i] = TREE_VALUE (tail); 6990 if (o[i] == error_mark_node) 6991 return; 6992 } 6993 6994 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of 6995 OUTPUTS some trees for where the values were actually stored. */ 6996 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line); 6997 6998 /* Copy all the intermediate outputs into the specified outputs. */ 6999 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) 7000 { 7001 if (o[i] != TREE_VALUE (tail)) 7002 { 7003 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)), 7004 NULL_RTX, VOIDmode, EXPAND_NORMAL); 7005 free_temp_slots (); 7006 7007 /* Restore the original value so that it's correct the next 7008 time we expand this function. */ 7009 TREE_VALUE (tail) = o[i]; 7010 } 7011 /* Detect modification of read-only values. 7012 (Otherwise done by build_modify_expr.) */ 7013 else 7014 { 7015 tree type = TREE_TYPE (o[i]); 7016 if (TREE_READONLY (o[i]) 7017 || TYPE_READONLY (type) 7018 || ((TREE_CODE (type) == RECORD_TYPE 7019 || TREE_CODE (type) == UNION_TYPE) 7020 && C_TYPE_FIELDS_READONLY (type))) 7021 readonly_warning (o[i], "modification by `asm'"); 7022 } 7023 } 7024 7025 /* Those MODIFY_EXPRs could do autoincrements. */ 7026 emit_queue (); 7027} 7028 7029/* Expand a C `return' statement. 7030 RETVAL is the expression for what to return, 7031 or a null pointer for `return;' with no value. */ 7032 7033tree 7034c_expand_return (retval) 7035 tree retval; 7036{ 7037 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)); 7038 7039 if (TREE_THIS_VOLATILE (current_function_decl)) 7040 warning ("function declared `noreturn' has a `return' statement"); 7041 7042 if (!retval) 7043 { 7044 current_function_returns_null = 1; 7045 if ((warn_return_type || flag_isoc99) 7046 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 7047 pedwarn_c99 ("`return' with no value, in function returning non-void"); 7048 } 7049 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 7050 { 7051 current_function_returns_null = 1; 7052 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 7053 pedwarn ("`return' with a value, in function returning void"); 7054 } 7055 else 7056 { 7057 tree t = convert_for_assignment (valtype, retval, _("return"), 7058 NULL_TREE, NULL_TREE, 0); 7059 tree res = DECL_RESULT (current_function_decl); 7060 tree inner; 7061 7062 current_function_returns_value = 1; 7063 if (t == error_mark_node) 7064 return NULL_TREE; 7065 7066 inner = t = convert (TREE_TYPE (res), t); 7067 7068 /* Strip any conversions, additions, and subtractions, and see if 7069 we are returning the address of a local variable. Warn if so. */ 7070 while (1) 7071 { 7072 switch (TREE_CODE (inner)) 7073 { 7074 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 7075 case PLUS_EXPR: 7076 inner = TREE_OPERAND (inner, 0); 7077 continue; 7078 7079 case MINUS_EXPR: 7080 /* If the second operand of the MINUS_EXPR has a pointer 7081 type (or is converted from it), this may be valid, so 7082 don't give a warning. */ 7083 { 7084 tree op1 = TREE_OPERAND (inner, 1); 7085 7086 while (! POINTER_TYPE_P (TREE_TYPE (op1)) 7087 && (TREE_CODE (op1) == NOP_EXPR 7088 || TREE_CODE (op1) == NON_LVALUE_EXPR 7089 || TREE_CODE (op1) == CONVERT_EXPR)) 7090 op1 = TREE_OPERAND (op1, 0); 7091 7092 if (POINTER_TYPE_P (TREE_TYPE (op1))) 7093 break; 7094 7095 inner = TREE_OPERAND (inner, 0); 7096 continue; 7097 } 7098 7099 case ADDR_EXPR: 7100 inner = TREE_OPERAND (inner, 0); 7101 7102 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r') 7103 inner = TREE_OPERAND (inner, 0); 7104 7105 if (TREE_CODE (inner) == VAR_DECL 7106 && ! DECL_EXTERNAL (inner) 7107 && ! TREE_STATIC (inner) 7108 && DECL_CONTEXT (inner) == current_function_decl) 7109 warning ("function returns address of local variable"); 7110 break; 7111 7112 default: 7113 break; 7114 } 7115 7116 break; 7117 } 7118 7119 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t); 7120 } 7121 7122 return add_stmt (build_return_stmt (retval)); 7123} 7124 7125struct c_switch { 7126 /* The SWITCH_STMT being built. */ 7127 tree switch_stmt; 7128 /* A splay-tree mapping the low element of a case range to the high 7129 element, or NULL_TREE if there is no high element. Used to 7130 determine whether or not a new case label duplicates an old case 7131 label. We need a tree, rather than simply a hash table, because 7132 of the GNU case range extension. */ 7133 splay_tree cases; 7134 /* The next node on the stack. */ 7135 struct c_switch *next; 7136}; 7137 7138/* A stack of the currently active switch statements. The innermost 7139 switch statement is on the top of the stack. There is no need to 7140 mark the stack for garbage collection because it is only active 7141 during the processing of the body of a function, and we never 7142 collect at that point. */ 7143 7144static struct c_switch *switch_stack; 7145 7146/* Start a C switch statement, testing expression EXP. Return the new 7147 SWITCH_STMT. */ 7148 7149tree 7150c_start_case (exp) 7151 tree exp; 7152{ 7153 enum tree_code code; 7154 tree type, orig_type = error_mark_node; 7155 struct c_switch *cs; 7156 7157 if (exp != error_mark_node) 7158 { 7159 code = TREE_CODE (TREE_TYPE (exp)); 7160 orig_type = TREE_TYPE (exp); 7161 7162 if (! INTEGRAL_TYPE_P (orig_type) 7163 && code != ERROR_MARK) 7164 { 7165 error ("switch quantity not an integer"); 7166 exp = integer_zero_node; 7167 } 7168 else 7169 { 7170 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); 7171 7172 if (warn_traditional && !in_system_header 7173 && (type == long_integer_type_node 7174 || type == long_unsigned_type_node)) 7175 warning ("`long' switch expression not converted to `int' in ISO C"); 7176 7177 exp = default_conversion (exp); 7178 type = TREE_TYPE (exp); 7179 } 7180 } 7181 7182 /* Add this new SWITCH_STMT to the stack. */ 7183 cs = (struct c_switch *) xmalloc (sizeof (*cs)); 7184 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type); 7185 cs->cases = splay_tree_new (case_compare, NULL, NULL); 7186 cs->next = switch_stack; 7187 switch_stack = cs; 7188 7189 return add_stmt (switch_stack->switch_stmt); 7190} 7191 7192/* Process a case label. */ 7193 7194tree 7195do_case (low_value, high_value) 7196 tree low_value; 7197 tree high_value; 7198{ 7199 tree label = NULL_TREE; 7200 7201 if (switch_stack) 7202 { 7203 label = c_add_case_label (switch_stack->cases, 7204 SWITCH_COND (switch_stack->switch_stmt), 7205 low_value, high_value); 7206 if (label == error_mark_node) 7207 label = NULL_TREE; 7208 } 7209 else if (low_value) 7210 error ("case label not within a switch statement"); 7211 else 7212 error ("`default' label not within a switch statement"); 7213 7214 return label; 7215} 7216 7217/* Finish the switch statement. */ 7218 7219void 7220c_finish_case () 7221{ 7222 struct c_switch *cs = switch_stack; 7223 7224 RECHAIN_STMTS (cs->switch_stmt, SWITCH_BODY (cs->switch_stmt)); 7225 7226 /* Pop the stack. */ 7227 switch_stack = switch_stack->next; 7228 splay_tree_delete (cs->cases); 7229 free (cs); 7230} 7231