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