1/* Build expressions with type checking for C compiler. 2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4 Free Software Foundation, Inc. 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ 22 23 24/* This file is part of the C front end. 25 It contains routines to build C expressions given their operands, 26 including computing the types of the result, C-specific error checks, 27 and some optimization. */ 28 29#include "config.h" 30#include "system.h" 31#include "coretypes.h" 32#include "tm.h" 33#include "rtl.h" 34#include "tree.h" 35#include "langhooks.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#include "tree-iterator.h" 46#include "tree-gimple.h" 47#include "tree-flow.h" 48 49/* Possible cases of implicit bad conversions. Used to select 50 diagnostic messages in convert_for_assignment. */ 51enum impl_conv { 52 ic_argpass, 53 ic_argpass_nonproto, 54 ic_assign, 55 ic_init, 56 ic_return 57}; 58 59/* The level of nesting inside "__alignof__". */ 60int in_alignof; 61 62/* The level of nesting inside "sizeof". */ 63int in_sizeof; 64 65/* The level of nesting inside "typeof". */ 66int in_typeof; 67 68struct c_label_context_se *label_context_stack_se; 69struct c_label_context_vm *label_context_stack_vm; 70 71/* Nonzero if we've already printed a "missing braces around initializer" 72 message within this initializer. */ 73static int missing_braces_mentioned; 74 75static int require_constant_value; 76static int require_constant_elements; 77 78/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 79static bool types_are_block_compatible (tree lhptee, tree rhptee); 80static tree build_block_call (tree, tree, tree); 81/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 82static bool null_pointer_constant_p (tree); 83static tree qualify_type (tree, tree); 84static int tagged_types_tu_compatible_p (tree, tree); 85static int comp_target_types (tree, tree); 86static int function_types_compatible_p (tree, tree); 87static int type_lists_compatible_p (tree, tree); 88static tree decl_constant_value_for_broken_optimization (tree); 89static tree lookup_field (tree, tree); 90static tree convert_arguments (tree, tree, tree, tree); 91static tree pointer_diff (tree, tree); 92static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree, 93 int); 94static tree valid_compound_expr_initializer (tree, tree); 95static void push_string (const char *); 96static void push_member_name (tree); 97static int spelling_length (void); 98static char *print_spelling (char *); 99static void warning_init (const char *); 100static tree digest_init (tree, tree, bool, int); 101static void output_init_element (tree, bool, tree, tree, int); 102static void output_pending_init_elements (int); 103static int set_designator (int); 104static void push_range_stack (tree); 105static void add_pending_init (tree, tree); 106static void set_nonincremental_init (void); 107static void set_nonincremental_init_from_string (tree); 108static tree find_init_member (tree); 109static void readonly_error (tree, enum lvalue_use); 110static int lvalue_or_else (tree, enum lvalue_use); 111static int lvalue_p (tree); 112static void record_maybe_used_decl (tree); 113static int comptypes_internal (tree, tree); 114 115/* Return true if EXP is a null pointer constant, false otherwise. */ 116 117static bool 118null_pointer_constant_p (tree expr) 119{ 120 /* This should really operate on c_expr structures, but they aren't 121 yet available everywhere required. */ 122 tree type = TREE_TYPE (expr); 123 return (TREE_CODE (expr) == INTEGER_CST 124 && !TREE_CONSTANT_OVERFLOW (expr) 125 && integer_zerop (expr) 126 && (INTEGRAL_TYPE_P (type) 127 || (TREE_CODE (type) == POINTER_TYPE 128 && VOID_TYPE_P (TREE_TYPE (type)) 129 && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))); 130} 131/* This is a cache to hold if two types are compatible or not. */ 132 133struct tagged_tu_seen_cache { 134 const struct tagged_tu_seen_cache * next; 135 tree t1; 136 tree t2; 137 /* The return value of tagged_types_tu_compatible_p if we had seen 138 these two types already. */ 139 int val; 140}; 141 142static const struct tagged_tu_seen_cache * tagged_tu_seen_base; 143static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *); 144 145/* Do `exp = require_complete_type (exp);' to make sure exp 146 does not have an incomplete type. (That includes void types.) */ 147 148tree 149require_complete_type (tree value) 150{ 151 tree type = TREE_TYPE (value); 152 153 if (value == error_mark_node || type == error_mark_node) 154 return error_mark_node; 155 156 /* First, detect a valid value with a complete type. */ 157 if (COMPLETE_TYPE_P (type)) 158 return value; 159 160 c_incomplete_type_error (value, type); 161 return error_mark_node; 162} 163 164/* Print an error message for invalid use of an incomplete type. 165 VALUE is the expression that was used (or 0 if that isn't known) 166 and TYPE is the type that was invalid. */ 167 168void 169c_incomplete_type_error (tree value, tree type) 170{ 171 const char *type_code_string; 172 173 /* Avoid duplicate error message. */ 174 if (TREE_CODE (type) == ERROR_MARK) 175 return; 176 177 if (value != 0 && (TREE_CODE (value) == VAR_DECL 178 || TREE_CODE (value) == PARM_DECL)) 179 error ("%qD has an incomplete type", value); 180 else 181 { 182 retry: 183 /* We must print an error message. Be clever about what it says. */ 184 185 switch (TREE_CODE (type)) 186 { 187 case RECORD_TYPE: 188 type_code_string = "struct"; 189 break; 190 191 case UNION_TYPE: 192 type_code_string = "union"; 193 break; 194 195 case ENUMERAL_TYPE: 196 type_code_string = "enum"; 197 break; 198 199 case VOID_TYPE: 200 error ("invalid use of void expression"); 201 return; 202 203 case ARRAY_TYPE: 204 if (TYPE_DOMAIN (type)) 205 { 206 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL) 207 { 208 error ("invalid use of flexible array member"); 209 return; 210 } 211 type = TREE_TYPE (type); 212 goto retry; 213 } 214 error ("invalid use of array with unspecified bounds"); 215 return; 216 217 default: 218 gcc_unreachable (); 219 } 220 221 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 222 error ("invalid use of undefined type %<%s %E%>", 223 type_code_string, TYPE_NAME (type)); 224 else 225 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 226 error ("invalid use of incomplete typedef %qD", TYPE_NAME (type)); 227 } 228} 229 230/* Given a type, apply default promotions wrt unnamed function 231 arguments and return the new type. */ 232 233tree 234c_type_promotes_to (tree type) 235{ 236 if (TYPE_MAIN_VARIANT (type) == float_type_node) 237 return double_type_node; 238 239 if (c_promoting_integer_type_p (type)) 240 { 241 /* Preserve unsignedness if not really getting any wider. */ 242 if (TYPE_UNSIGNED (type) 243 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))) 244 return unsigned_type_node; 245 return integer_type_node; 246 } 247 248 return type; 249} 250 251/* Return a variant of TYPE which has all the type qualifiers of LIKE 252 as well as those of TYPE. */ 253 254static tree 255qualify_type (tree type, tree like) 256{ 257 return c_build_qualified_type (type, 258 TYPE_QUALS (type) | TYPE_QUALS (like)); 259} 260 261/* Return true iff the given tree T is a variable length array. */ 262 263bool 264c_vla_type_p (tree t) 265{ 266 if (TREE_CODE (t) == ARRAY_TYPE 267 && C_TYPE_VARIABLE_SIZE (t)) 268 return true; 269 return false; 270} 271 272/* Return the composite type of two compatible types. 273 274 We assume that comptypes has already been done and returned 275 nonzero; if that isn't so, this may crash. In particular, we 276 assume that qualifiers match. */ 277 278tree 279composite_type (tree t1, tree t2) 280{ 281 enum tree_code code1; 282 enum tree_code code2; 283 tree attributes; 284 285 /* Save time if the two types are the same. */ 286 287 if (t1 == t2) return t1; 288 289 /* If one type is nonsense, use the other. */ 290 if (t1 == error_mark_node) 291 return t2; 292 if (t2 == error_mark_node) 293 return t1; 294 295 code1 = TREE_CODE (t1); 296 code2 = TREE_CODE (t2); 297 298 /* Merge the attributes. */ 299 attributes = targetm.merge_type_attributes (t1, t2); 300 301 /* If one is an enumerated type and the other is the compatible 302 integer type, the composite type might be either of the two 303 (DR#013 question 3). For consistency, use the enumerated type as 304 the composite type. */ 305 306 if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE) 307 return t1; 308 if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE) 309 return t2; 310 311 gcc_assert (code1 == code2); 312 313 switch (code1) 314 { 315 case POINTER_TYPE: 316 /* For two pointers, do this recursively on the target type. */ 317 { 318 tree pointed_to_1 = TREE_TYPE (t1); 319 tree pointed_to_2 = TREE_TYPE (t2); 320 tree target = composite_type (pointed_to_1, pointed_to_2); 321 t1 = build_pointer_type (target); 322 t1 = build_type_attribute_variant (t1, attributes); 323 return qualify_type (t1, t2); 324 } 325 326 case ARRAY_TYPE: 327 { 328 tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 329 int quals; 330 tree unqual_elt; 331 tree d1 = TYPE_DOMAIN (t1); 332 tree d2 = TYPE_DOMAIN (t2); 333 bool d1_variable, d2_variable; 334 bool d1_zero, d2_zero; 335 336 /* We should not have any type quals on arrays at all. */ 337 gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2)); 338 339 d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1); 340 d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2); 341 342 d1_variable = (!d1_zero 343 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 344 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 345 d2_variable = (!d2_zero 346 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 347 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 348 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 349 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 350 351 /* Save space: see if the result is identical to one of the args. */ 352 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1) 353 && (d2_variable || d2_zero || !d1_variable)) 354 return build_type_attribute_variant (t1, attributes); 355 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2) 356 && (d1_variable || d1_zero || !d2_variable)) 357 return build_type_attribute_variant (t2, attributes); 358 359 if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 360 return build_type_attribute_variant (t1, attributes); 361 if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 362 return build_type_attribute_variant (t2, attributes); 363 364 /* Merge the element types, and have a size if either arg has 365 one. We may have qualifiers on the element types. To set 366 up TYPE_MAIN_VARIANT correctly, we need to form the 367 composite of the unqualified types and add the qualifiers 368 back at the end. */ 369 quals = TYPE_QUALS (strip_array_types (elt)); 370 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED); 371 t1 = build_array_type (unqual_elt, 372 TYPE_DOMAIN ((TYPE_DOMAIN (t1) 373 && (d2_variable 374 || d2_zero 375 || !d1_variable)) 376 ? t1 377 : t2)); 378 t1 = c_build_qualified_type (t1, quals); 379 return build_type_attribute_variant (t1, attributes); 380 } 381 382 case ENUMERAL_TYPE: 383 case RECORD_TYPE: 384 case UNION_TYPE: 385 if (attributes != NULL) 386 { 387 /* Try harder not to create a new aggregate type. */ 388 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes)) 389 return t1; 390 if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes)) 391 return t2; 392 } 393 return build_type_attribute_variant (t1, attributes); 394 395 case FUNCTION_TYPE: 396 /* Function types: prefer the one that specified arg types. 397 If both do, merge the arg types. Also merge the return types. */ 398 { 399 tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 400 tree p1 = TYPE_ARG_TYPES (t1); 401 tree p2 = TYPE_ARG_TYPES (t2); 402 int len; 403 tree newargs, n; 404 int i; 405 406 /* Save space: see if the result is identical to one of the args. */ 407 if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2)) 408 return build_type_attribute_variant (t1, attributes); 409 if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1)) 410 return build_type_attribute_variant (t2, attributes); 411 412 /* Simple way if one arg fails to specify argument types. */ 413 if (TYPE_ARG_TYPES (t1) == 0) 414 { 415 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2)); 416 t1 = build_type_attribute_variant (t1, attributes); 417 return qualify_type (t1, t2); 418 } 419 if (TYPE_ARG_TYPES (t2) == 0) 420 { 421 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1)); 422 t1 = build_type_attribute_variant (t1, attributes); 423 return qualify_type (t1, t2); 424 } 425 426 /* If both args specify argument types, we must merge the two 427 lists, argument by argument. */ 428 /* Tell global_bindings_p to return false so that variable_size 429 doesn't die on VLAs in parameter types. */ 430 c_override_global_bindings_to_false = true; 431 432 len = list_length (p1); 433 newargs = 0; 434 435 for (i = 0; i < len; i++) 436 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 437 438 n = newargs; 439 440 for (; p1; 441 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) 442 { 443 /* A null type means arg type is not specified. 444 Take whatever the other function type has. */ 445 if (TREE_VALUE (p1) == 0) 446 { 447 TREE_VALUE (n) = TREE_VALUE (p2); 448 goto parm_done; 449 } 450 if (TREE_VALUE (p2) == 0) 451 { 452 TREE_VALUE (n) = TREE_VALUE (p1); 453 goto parm_done; 454 } 455 456 /* Given wait (union {union wait *u; int *i} *) 457 and wait (union wait *), 458 prefer union wait * as type of parm. */ 459 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE 460 && TREE_VALUE (p1) != TREE_VALUE (p2)) 461 { 462 tree memb; 463 tree mv2 = TREE_VALUE (p2); 464 if (mv2 && mv2 != error_mark_node 465 && TREE_CODE (mv2) != ARRAY_TYPE) 466 mv2 = TYPE_MAIN_VARIANT (mv2); 467 for (memb = TYPE_FIELDS (TREE_VALUE (p1)); 468 memb; memb = TREE_CHAIN (memb)) 469 { 470 tree mv3 = TREE_TYPE (memb); 471 if (mv3 && mv3 != error_mark_node 472 && TREE_CODE (mv3) != ARRAY_TYPE) 473 mv3 = TYPE_MAIN_VARIANT (mv3); 474 if (comptypes (mv3, mv2)) 475 { 476 TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 477 TREE_VALUE (p2)); 478 if (pedantic) 479 pedwarn ("function types not truly compatible in ISO C"); 480 goto parm_done; 481 } 482 } 483 } 484 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE 485 && TREE_VALUE (p2) != TREE_VALUE (p1)) 486 { 487 tree memb; 488 tree mv1 = TREE_VALUE (p1); 489 if (mv1 && mv1 != error_mark_node 490 && TREE_CODE (mv1) != ARRAY_TYPE) 491 mv1 = TYPE_MAIN_VARIANT (mv1); 492 for (memb = TYPE_FIELDS (TREE_VALUE (p2)); 493 memb; memb = TREE_CHAIN (memb)) 494 { 495 tree mv3 = TREE_TYPE (memb); 496 if (mv3 && mv3 != error_mark_node 497 && TREE_CODE (mv3) != ARRAY_TYPE) 498 mv3 = TYPE_MAIN_VARIANT (mv3); 499 if (comptypes (mv3, mv1)) 500 { 501 TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 502 TREE_VALUE (p1)); 503 if (pedantic) 504 pedwarn ("function types not truly compatible in ISO C"); 505 goto parm_done; 506 } 507 } 508 } 509 TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2)); 510 parm_done: ; 511 } 512 513 c_override_global_bindings_to_false = false; 514 t1 = build_function_type (valtype, newargs); 515 t1 = qualify_type (t1, t2); 516 /* ... falls through ... */ 517 } 518 519 default: 520 return build_type_attribute_variant (t1, attributes); 521 } 522 523} 524 525/* Return the type of a conditional expression between pointers to 526 possibly differently qualified versions of compatible types. 527 528 We assume that comp_target_types has already been done and returned 529 nonzero; if that isn't so, this may crash. */ 530 531static tree 532common_pointer_type (tree t1, tree t2) 533{ 534 tree attributes; 535 tree pointed_to_1, mv1; 536 tree pointed_to_2, mv2; 537 tree target; 538 539 /* Save time if the two types are the same. */ 540 541 if (t1 == t2) return t1; 542 543 /* If one type is nonsense, use the other. */ 544 if (t1 == error_mark_node) 545 return t2; 546 if (t2 == error_mark_node) 547 return t1; 548 549 /* APPLE LOCAL begin blocks 6065211 */ 550 gcc_assert ((TREE_CODE (t1) == POINTER_TYPE 551 && TREE_CODE (t2) == POINTER_TYPE) 552 || (TREE_CODE (t1) == BLOCK_POINTER_TYPE 553 && TREE_CODE (t2) == BLOCK_POINTER_TYPE)); 554 /* APPLE LOCAL end blocks 6065211 */ 555 556 /* Merge the attributes. */ 557 attributes = targetm.merge_type_attributes (t1, t2); 558 559 /* Find the composite type of the target types, and combine the 560 qualifiers of the two types' targets. Do not lose qualifiers on 561 array element types by taking the TYPE_MAIN_VARIANT. */ 562 mv1 = pointed_to_1 = TREE_TYPE (t1); 563 mv2 = pointed_to_2 = TREE_TYPE (t2); 564 if (TREE_CODE (mv1) != ARRAY_TYPE) 565 mv1 = TYPE_MAIN_VARIANT (pointed_to_1); 566 if (TREE_CODE (mv2) != ARRAY_TYPE) 567 mv2 = TYPE_MAIN_VARIANT (pointed_to_2); 568 target = composite_type (mv1, mv2); 569 /* APPLE LOCAL begin blocks 6065211 */ 570 t1 = c_build_qualified_type (target, 571 TYPE_QUALS (pointed_to_1) | 572 TYPE_QUALS (pointed_to_2)); 573 if (TREE_CODE (t2) == BLOCK_POINTER_TYPE) 574 t1 = build_block_pointer_type (t1); 575 else 576 t1 = build_pointer_type (t1); 577 /* APPLE LOCAL end blocks 6065211 */ 578 return build_type_attribute_variant (t1, attributes); 579} 580 581/* Return the common type for two arithmetic types under the usual 582 arithmetic conversions. The default conversions have already been 583 applied, and enumerated types converted to their compatible integer 584 types. The resulting type is unqualified and has no attributes. 585 586 This is the type for the result of most arithmetic operations 587 if the operands have the given two types. */ 588 589static tree 590c_common_type (tree t1, tree t2) 591{ 592 enum tree_code code1; 593 enum tree_code code2; 594 595 /* If one type is nonsense, use the other. */ 596 if (t1 == error_mark_node) 597 return t2; 598 if (t2 == error_mark_node) 599 return t1; 600 601 if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED) 602 t1 = TYPE_MAIN_VARIANT (t1); 603 604 if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED) 605 t2 = TYPE_MAIN_VARIANT (t2); 606 607 if (TYPE_ATTRIBUTES (t1) != NULL_TREE) 608 t1 = build_type_attribute_variant (t1, NULL_TREE); 609 610 if (TYPE_ATTRIBUTES (t2) != NULL_TREE) 611 t2 = build_type_attribute_variant (t2, NULL_TREE); 612 613 /* Save time if the two types are the same. */ 614 615 if (t1 == t2) return t1; 616 617 code1 = TREE_CODE (t1); 618 code2 = TREE_CODE (t2); 619 620 gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE 621 || code1 == REAL_TYPE || code1 == INTEGER_TYPE); 622 gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE 623 || code2 == REAL_TYPE || code2 == INTEGER_TYPE); 624 625 /* When one operand is a decimal float type, the other operand cannot be 626 a generic float type or a complex type. We also disallow vector types 627 here. */ 628 if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2)) 629 && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2))) 630 { 631 if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE) 632 { 633 error ("can%'t mix operands of decimal float and vector types"); 634 return error_mark_node; 635 } 636 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 637 { 638 error ("can%'t mix operands of decimal float and complex types"); 639 return error_mark_node; 640 } 641 if (code1 == REAL_TYPE && code2 == REAL_TYPE) 642 { 643 error ("can%'t mix operands of decimal float and other float types"); 644 return error_mark_node; 645 } 646 } 647 648 /* If one type is a vector type, return that type. (How the usual 649 arithmetic conversions apply to the vector types extension is not 650 precisely specified.) */ 651 if (code1 == VECTOR_TYPE) 652 return t1; 653 654 if (code2 == VECTOR_TYPE) 655 return t2; 656 657 /* If one type is complex, form the common type of the non-complex 658 components, then make that complex. Use T1 or T2 if it is the 659 required type. */ 660 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 661 { 662 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 663 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 664 tree subtype = c_common_type (subtype1, subtype2); 665 666 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 667 return t1; 668 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 669 return t2; 670 else 671 return build_complex_type (subtype); 672 } 673 674 /* If only one is real, use it as the result. */ 675 676 if (code1 == REAL_TYPE && code2 != REAL_TYPE) 677 return t1; 678 679 if (code2 == REAL_TYPE && code1 != REAL_TYPE) 680 return t2; 681 682 /* If both are real and either are decimal floating point types, use 683 the decimal floating point type with the greater precision. */ 684 685 if (code1 == REAL_TYPE && code2 == REAL_TYPE) 686 { 687 if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node 688 || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node) 689 return dfloat128_type_node; 690 else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node 691 || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node) 692 return dfloat64_type_node; 693 else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node 694 || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node) 695 return dfloat32_type_node; 696 } 697 698 /* Both real or both integers; use the one with greater precision. */ 699 700 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 701 return t1; 702 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 703 return t2; 704 705 /* Same precision. Prefer long longs to longs to ints when the 706 same precision, following the C99 rules on integer type rank 707 (which are equivalent to the C90 rules for C90 types). */ 708 709 if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node 710 || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node) 711 return long_long_unsigned_type_node; 712 713 if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node 714 || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node) 715 { 716 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 717 return long_long_unsigned_type_node; 718 else 719 return long_long_integer_type_node; 720 } 721 722 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node 723 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) 724 return long_unsigned_type_node; 725 726 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node 727 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) 728 { 729 /* But preserve unsignedness from the other type, 730 since long cannot hold all the values of an unsigned int. */ 731 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 732 return long_unsigned_type_node; 733 else 734 return long_integer_type_node; 735 } 736 737 /* Likewise, prefer long double to double even if same size. */ 738 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node 739 || TYPE_MAIN_VARIANT (t2) == long_double_type_node) 740 return long_double_type_node; 741 742 /* Otherwise prefer the unsigned one. */ 743 744 if (TYPE_UNSIGNED (t1)) 745 return t1; 746 else 747 return t2; 748} 749 750/* Wrapper around c_common_type that is used by c-common.c and other 751 front end optimizations that remove promotions. ENUMERAL_TYPEs 752 are allowed here and are converted to their compatible integer types. 753 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or 754 preferably a non-Boolean type as the common type. */ 755tree 756common_type (tree t1, tree t2) 757{ 758 if (TREE_CODE (t1) == ENUMERAL_TYPE) 759 t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); 760 if (TREE_CODE (t2) == ENUMERAL_TYPE) 761 t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); 762 763 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */ 764 if (TREE_CODE (t1) == BOOLEAN_TYPE 765 && TREE_CODE (t2) == BOOLEAN_TYPE) 766 return boolean_type_node; 767 768 /* If either type is BOOLEAN_TYPE, then return the other. */ 769 if (TREE_CODE (t1) == BOOLEAN_TYPE) 770 return t2; 771 if (TREE_CODE (t2) == BOOLEAN_TYPE) 772 return t1; 773 774 return c_common_type (t1, t2); 775} 776 777/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 778 or various other operations. Return 2 if they are compatible 779 but a warning may be needed if you use them together. */ 780 781int 782comptypes (tree type1, tree type2) 783{ 784 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base; 785 int val; 786 787 val = comptypes_internal (type1, type2); 788 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1); 789 790 return val; 791} 792 793/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 794 or various other operations. Return 2 if they are compatible 795 but a warning may be needed if you use them together. This 796 differs from comptypes, in that we don't free the seen types. */ 797 798static int 799comptypes_internal (tree type1, tree type2) 800{ 801 tree t1 = type1; 802 tree t2 = type2; 803 int attrval, val; 804 805 /* Suppress errors caused by previously reported errors. */ 806 807 if (t1 == t2 || !t1 || !t2 808 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK) 809 return 1; 810 811 /* If either type is the internal version of sizetype, return the 812 language version. */ 813 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 814 && TYPE_ORIG_SIZE_TYPE (t1)) 815 t1 = TYPE_ORIG_SIZE_TYPE (t1); 816 817 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 818 && TYPE_ORIG_SIZE_TYPE (t2)) 819 t2 = TYPE_ORIG_SIZE_TYPE (t2); 820 821 822 /* Enumerated types are compatible with integer types, but this is 823 not transitive: two enumerated types in the same translation unit 824 are compatible with each other only if they are the same type. */ 825 826 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE) 827 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1)); 828 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE) 829 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2)); 830 831 if (t1 == t2) 832 return 1; 833 834 /* Different classes of types can't be compatible. */ 835 836 if (TREE_CODE (t1) != TREE_CODE (t2)) 837 return 0; 838 839 /* Qualifiers must match. C99 6.7.3p9 */ 840 841 if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 842 return 0; 843 844 /* Allow for two different type nodes which have essentially the same 845 definition. Note that we already checked for equality of the type 846 qualifiers (just above). */ 847 848 if (TREE_CODE (t1) != ARRAY_TYPE 849 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 850 return 1; 851 852 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 853 if (!(attrval = targetm.comp_type_attributes (t1, t2))) 854 return 0; 855 856 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 857 val = 0; 858 859 switch (TREE_CODE (t1)) 860 { 861 /* APPLE LOCAL begin radar 5795493 */ 862 case BLOCK_POINTER_TYPE: 863 val = (TREE_CODE (t2) == BLOCK_POINTER_TYPE) && 864 types_are_block_compatible (TREE_TYPE (t1), TREE_TYPE (t2)); 865 break; 866 867 /* APPLE LOCAL end radar 5795493 */ 868 case POINTER_TYPE: 869 /* Do not remove mode or aliasing information. */ 870 if (TYPE_MODE (t1) != TYPE_MODE (t2) 871 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)) 872 break; 873 val = (TREE_TYPE (t1) == TREE_TYPE (t2) 874 ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))); 875 break; 876 877 case FUNCTION_TYPE: 878 val = function_types_compatible_p (t1, t2); 879 break; 880 881 case ARRAY_TYPE: 882 { 883 tree d1 = TYPE_DOMAIN (t1); 884 tree d2 = TYPE_DOMAIN (t2); 885 bool d1_variable, d2_variable; 886 bool d1_zero, d2_zero; 887 val = 1; 888 889 /* Target types must match incl. qualifiers. */ 890 if (TREE_TYPE (t1) != TREE_TYPE (t2) 891 && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)))) 892 return 0; 893 894 /* Sizes must match unless one is missing or variable. */ 895 if (d1 == 0 || d2 == 0 || d1 == d2) 896 break; 897 898 d1_zero = !TYPE_MAX_VALUE (d1); 899 d2_zero = !TYPE_MAX_VALUE (d2); 900 901 d1_variable = (!d1_zero 902 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 903 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 904 d2_variable = (!d2_zero 905 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 906 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 907 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 908 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 909 910 if (d1_variable || d2_variable) 911 break; 912 if (d1_zero && d2_zero) 913 break; 914 if (d1_zero || d2_zero 915 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)) 916 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2))) 917 val = 0; 918 919 break; 920 } 921 922 case ENUMERAL_TYPE: 923 case RECORD_TYPE: 924 case UNION_TYPE: 925 if (val != 1 && !same_translation_unit_p (t1, t2)) 926 { 927 tree a1 = TYPE_ATTRIBUTES (t1); 928 tree a2 = TYPE_ATTRIBUTES (t2); 929 930 if (! attribute_list_contained (a1, a2) 931 && ! attribute_list_contained (a2, a1)) 932 break; 933 934 if (attrval != 2) 935 return tagged_types_tu_compatible_p (t1, t2); 936 val = tagged_types_tu_compatible_p (t1, t2); 937 } 938 break; 939 940 case VECTOR_TYPE: 941 val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 942 && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)); 943 break; 944 945 default: 946 break; 947 } 948 return attrval == 2 && val == 1 ? 2 : val; 949} 950 951/* Return 1 if TTL and TTR are pointers to types that are equivalent, 952 ignoring their qualifiers. */ 953 954static int 955comp_target_types (tree ttl, tree ttr) 956{ 957 int val; 958 tree mvl, mvr; 959 960 /* APPLE LOCAL begin blocks 6065211 */ 961 if (TREE_CODE (ttl) == BLOCK_POINTER_TYPE 962 && TREE_CODE (ttr) == BLOCK_POINTER_TYPE) 963 return types_are_block_compatible (TREE_TYPE (ttl), 964 TREE_TYPE (ttr)); 965 if (TREE_CODE (ttl) != TREE_CODE (ttr)) 966 return 0; 967 /* APPLE LOCAL end blocks 6065211 */ 968 969 /* Do not lose qualifiers on element types of array types that are 970 pointer targets by taking their TYPE_MAIN_VARIANT. */ 971 mvl = TREE_TYPE (ttl); 972 mvr = TREE_TYPE (ttr); 973 if (TREE_CODE (mvl) != ARRAY_TYPE) 974 mvl = TYPE_MAIN_VARIANT (mvl); 975 if (TREE_CODE (mvr) != ARRAY_TYPE) 976 mvr = TYPE_MAIN_VARIANT (mvr); 977 val = comptypes (mvl, mvr); 978 979 if (val == 2 && pedantic) 980 pedwarn ("types are not quite compatible"); 981 return val; 982} 983 984/* Subroutines of `comptypes'. */ 985 986/* Determine whether two trees derive from the same translation unit. 987 If the CONTEXT chain ends in a null, that tree's context is still 988 being parsed, so if two trees have context chains ending in null, 989 they're in the same translation unit. */ 990int 991same_translation_unit_p (tree t1, tree t2) 992{ 993 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL) 994 switch (TREE_CODE_CLASS (TREE_CODE (t1))) 995 { 996 case tcc_declaration: 997 t1 = DECL_CONTEXT (t1); break; 998 case tcc_type: 999 t1 = TYPE_CONTEXT (t1); break; 1000 case tcc_exceptional: 1001 t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */ 1002 default: gcc_unreachable (); 1003 } 1004 1005 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL) 1006 switch (TREE_CODE_CLASS (TREE_CODE (t2))) 1007 { 1008 case tcc_declaration: 1009 t2 = DECL_CONTEXT (t2); break; 1010 case tcc_type: 1011 t2 = TYPE_CONTEXT (t2); break; 1012 case tcc_exceptional: 1013 t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */ 1014 default: gcc_unreachable (); 1015 } 1016 1017 return t1 == t2; 1018} 1019 1020/* Allocate the seen two types, assuming that they are compatible. */ 1021 1022static struct tagged_tu_seen_cache * 1023alloc_tagged_tu_seen_cache (tree t1, tree t2) 1024{ 1025 struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache); 1026 tu->next = tagged_tu_seen_base; 1027 tu->t1 = t1; 1028 tu->t2 = t2; 1029 1030 tagged_tu_seen_base = tu; 1031 1032 /* The C standard says that two structures in different translation 1033 units are compatible with each other only if the types of their 1034 fields are compatible (among other things). We assume that they 1035 are compatible until proven otherwise when building the cache. 1036 An example where this can occur is: 1037 struct a 1038 { 1039 struct a *next; 1040 }; 1041 If we are comparing this against a similar struct in another TU, 1042 and did not assume they were compatible, we end up with an infinite 1043 loop. */ 1044 tu->val = 1; 1045 return tu; 1046} 1047 1048/* Free the seen types until we get to TU_TIL. */ 1049 1050static void 1051free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til) 1052{ 1053 const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base; 1054 while (tu != tu_til) 1055 { 1056 struct tagged_tu_seen_cache *tu1 = (struct tagged_tu_seen_cache*)tu; 1057 tu = tu1->next; 1058 free (tu1); 1059 } 1060 tagged_tu_seen_base = tu_til; 1061} 1062 1063/* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are 1064 compatible. If the two types are not the same (which has been 1065 checked earlier), this can only happen when multiple translation 1066 units are being compiled. See C99 6.2.7 paragraph 1 for the exact 1067 rules. */ 1068 1069static int 1070tagged_types_tu_compatible_p (tree t1, tree t2) 1071{ 1072 tree s1, s2; 1073 bool needs_warning = false; 1074 1075 /* We have to verify that the tags of the types are the same. This 1076 is harder than it looks because this may be a typedef, so we have 1077 to go look at the original type. It may even be a typedef of a 1078 typedef... 1079 In the case of compiler-created builtin structs the TYPE_DECL 1080 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */ 1081 while (TYPE_NAME (t1) 1082 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL 1083 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1))) 1084 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1)); 1085 1086 while (TYPE_NAME (t2) 1087 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL 1088 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2))) 1089 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2)); 1090 1091 /* C90 didn't have the requirement that the two tags be the same. */ 1092 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2)) 1093 return 0; 1094 1095 /* C90 didn't say what happened if one or both of the types were 1096 incomplete; we choose to follow C99 rules here, which is that they 1097 are compatible. */ 1098 if (TYPE_SIZE (t1) == NULL 1099 || TYPE_SIZE (t2) == NULL) 1100 return 1; 1101 1102 { 1103 const struct tagged_tu_seen_cache * tts_i; 1104 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next) 1105 if (tts_i->t1 == t1 && tts_i->t2 == t2) 1106 return tts_i->val; 1107 } 1108 1109 switch (TREE_CODE (t1)) 1110 { 1111 case ENUMERAL_TYPE: 1112 { 1113 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1114 /* Speed up the case where the type values are in the same order. */ 1115 tree tv1 = TYPE_VALUES (t1); 1116 tree tv2 = TYPE_VALUES (t2); 1117 1118 if (tv1 == tv2) 1119 { 1120 return 1; 1121 } 1122 1123 for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2)) 1124 { 1125 if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2)) 1126 break; 1127 if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1) 1128 { 1129 tu->val = 0; 1130 return 0; 1131 } 1132 } 1133 1134 if (tv1 == NULL_TREE && tv2 == NULL_TREE) 1135 { 1136 return 1; 1137 } 1138 if (tv1 == NULL_TREE || tv2 == NULL_TREE) 1139 { 1140 tu->val = 0; 1141 return 0; 1142 } 1143 1144 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2))) 1145 { 1146 tu->val = 0; 1147 return 0; 1148 } 1149 1150 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1)) 1151 { 1152 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2)); 1153 if (s2 == NULL 1154 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1) 1155 { 1156 tu->val = 0; 1157 return 0; 1158 } 1159 } 1160 return 1; 1161 } 1162 1163 case UNION_TYPE: 1164 { 1165 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1166 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2))) 1167 { 1168 tu->val = 0; 1169 return 0; 1170 } 1171 1172 /* Speed up the common case where the fields are in the same order. */ 1173 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2; 1174 s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1175 { 1176 int result; 1177 1178 1179 if (DECL_NAME (s1) == NULL 1180 || DECL_NAME (s1) != DECL_NAME (s2)) 1181 break; 1182 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1183 if (result == 0) 1184 { 1185 tu->val = 0; 1186 return 0; 1187 } 1188 if (result == 2) 1189 needs_warning = true; 1190 1191 if (TREE_CODE (s1) == FIELD_DECL 1192 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1193 DECL_FIELD_BIT_OFFSET (s2)) != 1) 1194 { 1195 tu->val = 0; 1196 return 0; 1197 } 1198 } 1199 if (!s1 && !s2) 1200 { 1201 tu->val = needs_warning ? 2 : 1; 1202 return tu->val; 1203 } 1204 1205 for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1)) 1206 { 1207 bool ok = false; 1208 1209 if (DECL_NAME (s1) != NULL) 1210 for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2)) 1211 if (DECL_NAME (s1) == DECL_NAME (s2)) 1212 { 1213 int result; 1214 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1215 if (result == 0) 1216 { 1217 tu->val = 0; 1218 return 0; 1219 } 1220 if (result == 2) 1221 needs_warning = true; 1222 1223 if (TREE_CODE (s1) == FIELD_DECL 1224 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1225 DECL_FIELD_BIT_OFFSET (s2)) != 1) 1226 break; 1227 1228 ok = true; 1229 break; 1230 } 1231 if (!ok) 1232 { 1233 tu->val = 0; 1234 return 0; 1235 } 1236 } 1237 tu->val = needs_warning ? 2 : 10; 1238 return tu->val; 1239 } 1240 1241 case RECORD_TYPE: 1242 { 1243 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1244 1245 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); 1246 s1 && s2; 1247 s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1248 { 1249 int result; 1250 if (TREE_CODE (s1) != TREE_CODE (s2) 1251 || DECL_NAME (s1) != DECL_NAME (s2)) 1252 break; 1253 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1254 if (result == 0) 1255 break; 1256 if (result == 2) 1257 needs_warning = true; 1258 1259 if (TREE_CODE (s1) == FIELD_DECL 1260 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1261 DECL_FIELD_BIT_OFFSET (s2)) != 1) 1262 break; 1263 } 1264 if (s1 && s2) 1265 tu->val = 0; 1266 else 1267 tu->val = needs_warning ? 2 : 1; 1268 return tu->val; 1269 } 1270 1271 default: 1272 gcc_unreachable (); 1273 } 1274} 1275 1276/* Return 1 if two function types F1 and F2 are compatible. 1277 If either type specifies no argument types, 1278 the other must specify a fixed number of self-promoting arg types. 1279 Otherwise, if one type specifies only the number of arguments, 1280 the other must specify that number of self-promoting arg types. 1281 Otherwise, the argument types must match. */ 1282 1283static int 1284function_types_compatible_p (tree f1, tree f2) 1285{ 1286 tree args1, args2; 1287 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 1288 int val = 1; 1289 int val1; 1290 tree ret1, ret2; 1291 1292 ret1 = TREE_TYPE (f1); 1293 ret2 = TREE_TYPE (f2); 1294 1295 /* 'volatile' qualifiers on a function's return type used to mean 1296 the function is noreturn. */ 1297 if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2)) 1298 pedwarn ("function return types not compatible due to %<volatile%>"); 1299 if (TYPE_VOLATILE (ret1)) 1300 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1), 1301 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE); 1302 if (TYPE_VOLATILE (ret2)) 1303 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2), 1304 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE); 1305 val = comptypes_internal (ret1, ret2); 1306 if (val == 0) 1307 return 0; 1308 1309 args1 = TYPE_ARG_TYPES (f1); 1310 args2 = TYPE_ARG_TYPES (f2); 1311 1312 /* An unspecified parmlist matches any specified parmlist 1313 whose argument types don't need default promotions. */ 1314 1315 if (args1 == 0) 1316 { 1317 if (!self_promoting_args_p (args2)) 1318 return 0; 1319 /* If one of these types comes from a non-prototype fn definition, 1320 compare that with the other type's arglist. 1321 If they don't match, ask for a warning (but no error). */ 1322 if (TYPE_ACTUAL_ARG_TYPES (f1) 1323 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1))) 1324 val = 2; 1325 return val; 1326 } 1327 if (args2 == 0) 1328 { 1329 if (!self_promoting_args_p (args1)) 1330 return 0; 1331 if (TYPE_ACTUAL_ARG_TYPES (f2) 1332 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2))) 1333 val = 2; 1334 return val; 1335 } 1336 1337 /* Both types have argument lists: compare them and propagate results. */ 1338 val1 = type_lists_compatible_p (args1, args2); 1339 return val1 != 1 ? val1 : val; 1340} 1341 1342/* Check two lists of types for compatibility, 1343 returning 0 for incompatible, 1 for compatible, 1344 or 2 for compatible with warning. */ 1345 1346static int 1347type_lists_compatible_p (tree args1, tree args2) 1348{ 1349 /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 1350 int val = 1; 1351 int newval = 0; 1352 1353 while (1) 1354 { 1355 tree a1, mv1, a2, mv2; 1356 if (args1 == 0 && args2 == 0) 1357 return val; 1358 /* If one list is shorter than the other, 1359 they fail to match. */ 1360 if (args1 == 0 || args2 == 0) 1361 return 0; 1362 mv1 = a1 = TREE_VALUE (args1); 1363 mv2 = a2 = TREE_VALUE (args2); 1364 if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE) 1365 mv1 = TYPE_MAIN_VARIANT (mv1); 1366 if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE) 1367 mv2 = TYPE_MAIN_VARIANT (mv2); 1368 /* A null pointer instead of a type 1369 means there is supposed to be an argument 1370 but nothing is specified about what type it has. 1371 So match anything that self-promotes. */ 1372 if (a1 == 0) 1373 { 1374 if (c_type_promotes_to (a2) != a2) 1375 return 0; 1376 } 1377 else if (a2 == 0) 1378 { 1379 if (c_type_promotes_to (a1) != a1) 1380 return 0; 1381 } 1382 /* If one of the lists has an error marker, ignore this arg. */ 1383 else if (TREE_CODE (a1) == ERROR_MARK 1384 || TREE_CODE (a2) == ERROR_MARK) 1385 ; 1386 else if (!(newval = comptypes_internal (mv1, mv2))) 1387 { 1388 /* Allow wait (union {union wait *u; int *i} *) 1389 and wait (union wait *) to be compatible. */ 1390 if (TREE_CODE (a1) == UNION_TYPE 1391 && (TYPE_NAME (a1) == 0 1392 || TYPE_TRANSPARENT_UNION (a1)) 1393 && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST 1394 && tree_int_cst_equal (TYPE_SIZE (a1), 1395 TYPE_SIZE (a2))) 1396 { 1397 tree memb; 1398 for (memb = TYPE_FIELDS (a1); 1399 memb; memb = TREE_CHAIN (memb)) 1400 { 1401 tree mv3 = TREE_TYPE (memb); 1402 if (mv3 && mv3 != error_mark_node 1403 && TREE_CODE (mv3) != ARRAY_TYPE) 1404 mv3 = TYPE_MAIN_VARIANT (mv3); 1405 if (comptypes_internal (mv3, mv2)) 1406 break; 1407 } 1408 if (memb == 0) 1409 return 0; 1410 } 1411 else if (TREE_CODE (a2) == UNION_TYPE 1412 && (TYPE_NAME (a2) == 0 1413 || TYPE_TRANSPARENT_UNION (a2)) 1414 && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST 1415 && tree_int_cst_equal (TYPE_SIZE (a2), 1416 TYPE_SIZE (a1))) 1417 { 1418 tree memb; 1419 for (memb = TYPE_FIELDS (a2); 1420 memb; memb = TREE_CHAIN (memb)) 1421 { 1422 tree mv3 = TREE_TYPE (memb); 1423 if (mv3 && mv3 != error_mark_node 1424 && TREE_CODE (mv3) != ARRAY_TYPE) 1425 mv3 = TYPE_MAIN_VARIANT (mv3); 1426 if (comptypes_internal (mv3, mv1)) 1427 break; 1428 } 1429 if (memb == 0) 1430 return 0; 1431 } 1432 else 1433 return 0; 1434 } 1435 1436 /* comptypes said ok, but record if it said to warn. */ 1437 if (newval > val) 1438 val = newval; 1439 1440 args1 = TREE_CHAIN (args1); 1441 args2 = TREE_CHAIN (args2); 1442 } 1443} 1444 1445/* Compute the size to increment a pointer by. */ 1446 1447static tree 1448c_size_in_bytes (tree type) 1449{ 1450 enum tree_code code = TREE_CODE (type); 1451 1452 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 1453 return size_one_node; 1454 1455 if (!COMPLETE_OR_VOID_TYPE_P (type)) 1456 { 1457 error ("arithmetic on pointer to an incomplete type"); 1458 return size_one_node; 1459 } 1460 1461 /* Convert in case a char is more than one unit. */ 1462 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 1463 size_int (TYPE_PRECISION (char_type_node) 1464 / BITS_PER_UNIT)); 1465} 1466 1467/* Return either DECL or its known constant value (if it has one). */ 1468 1469tree 1470decl_constant_value (tree decl) 1471{ 1472 if (/* Don't change a variable array bound or initial value to a constant 1473 in a place where a variable is invalid. Note that DECL_INITIAL 1474 isn't valid for a PARM_DECL. */ 1475 current_function_decl != 0 1476 && TREE_CODE (decl) != PARM_DECL 1477 && !TREE_THIS_VOLATILE (decl) 1478 && TREE_READONLY (decl) 1479 && DECL_INITIAL (decl) != 0 1480 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK 1481 /* This is invalid if initial value is not constant. 1482 If it has either a function call, a memory reference, 1483 or a variable, then re-evaluating it could give different results. */ 1484 && TREE_CONSTANT (DECL_INITIAL (decl)) 1485 /* Check for cases where this is sub-optimal, even though valid. */ 1486 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR) 1487 return DECL_INITIAL (decl); 1488 return decl; 1489} 1490 1491/* Return either DECL or its known constant value (if it has one), but 1492 return DECL if pedantic or DECL has mode BLKmode. This is for 1493 bug-compatibility with the old behavior of decl_constant_value 1494 (before GCC 3.0); every use of this function is a bug and it should 1495 be removed before GCC 3.1. It is not appropriate to use pedantic 1496 in a way that affects optimization, and BLKmode is probably not the 1497 right test for avoiding misoptimizations either. */ 1498 1499static tree 1500decl_constant_value_for_broken_optimization (tree decl) 1501{ 1502 tree ret; 1503 1504 if (pedantic || DECL_MODE (decl) == BLKmode) 1505 return decl; 1506 1507 ret = decl_constant_value (decl); 1508 /* Avoid unwanted tree sharing between the initializer and current 1509 function's body where the tree can be modified e.g. by the 1510 gimplifier. */ 1511 if (ret != decl && TREE_STATIC (decl)) 1512 ret = unshare_expr (ret); 1513 return ret; 1514} 1515 1516/* Convert the array expression EXP to a pointer. */ 1517/* APPLE LOCAL radar 6212722 */ 1518tree 1519array_to_pointer_conversion (tree exp) 1520{ 1521 tree orig_exp = exp; 1522 tree type = TREE_TYPE (exp); 1523 tree adr; 1524 tree restype = TREE_TYPE (type); 1525 tree ptrtype; 1526 1527 gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 1528 1529 STRIP_TYPE_NOPS (exp); 1530 1531 if (TREE_NO_WARNING (orig_exp)) 1532 TREE_NO_WARNING (exp) = 1; 1533 1534 ptrtype = build_pointer_type (restype); 1535 1536 if (TREE_CODE (exp) == INDIRECT_REF) 1537 return convert (ptrtype, TREE_OPERAND (exp, 0)); 1538 1539 if (TREE_CODE (exp) == VAR_DECL) 1540 { 1541 /* We are making an ADDR_EXPR of ptrtype. This is a valid 1542 ADDR_EXPR because it's the best way of representing what 1543 happens in C when we take the address of an array and place 1544 it in a pointer to the element type. */ 1545 adr = build1 (ADDR_EXPR, ptrtype, exp); 1546 if (!c_mark_addressable (exp)) 1547 return error_mark_node; 1548 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ 1549 return adr; 1550 } 1551 1552 /* This way is better for a COMPONENT_REF since it can 1553 simplify the offset for a component. */ 1554 adr = build_unary_op (ADDR_EXPR, exp, 1); 1555 return convert (ptrtype, adr); 1556} 1557 1558/* Convert the function expression EXP to a pointer. */ 1559/* APPLE LOCAL radar 6212722 */ 1560tree 1561function_to_pointer_conversion (tree exp) 1562{ 1563 tree orig_exp = exp; 1564 1565 gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE); 1566 1567 STRIP_TYPE_NOPS (exp); 1568 1569 if (TREE_NO_WARNING (orig_exp)) 1570 TREE_NO_WARNING (exp) = 1; 1571 1572 return build_unary_op (ADDR_EXPR, exp, 0); 1573} 1574 1575/* Perform the default conversion of arrays and functions to pointers. 1576 Return the result of converting EXP. For any other expression, just 1577 return EXP after removing NOPs. */ 1578 1579struct c_expr 1580default_function_array_conversion (struct c_expr exp) 1581{ 1582 tree orig_exp = exp.value; 1583 tree type = TREE_TYPE (exp.value); 1584 enum tree_code code = TREE_CODE (type); 1585 1586 switch (code) 1587 { 1588 case ARRAY_TYPE: 1589 { 1590 bool not_lvalue = false; 1591 bool lvalue_array_p; 1592 1593 while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR 1594 || TREE_CODE (exp.value) == NOP_EXPR 1595 || TREE_CODE (exp.value) == CONVERT_EXPR) 1596 && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type) 1597 { 1598 if (TREE_CODE (exp.value) == NON_LVALUE_EXPR) 1599 not_lvalue = true; 1600 exp.value = TREE_OPERAND (exp.value, 0); 1601 } 1602 1603 if (TREE_NO_WARNING (orig_exp)) 1604 TREE_NO_WARNING (exp.value) = 1; 1605 1606 lvalue_array_p = !not_lvalue && lvalue_p (exp.value); 1607 if (!flag_isoc99 && !lvalue_array_p) 1608 { 1609 /* Before C99, non-lvalue arrays do not decay to pointers. 1610 Normally, using such an array would be invalid; but it can 1611 be used correctly inside sizeof or as a statement expression. 1612 Thus, do not give an error here; an error will result later. */ 1613 return exp; 1614 } 1615 1616 exp.value = array_to_pointer_conversion (exp.value); 1617 } 1618 break; 1619 case FUNCTION_TYPE: 1620 exp.value = function_to_pointer_conversion (exp.value); 1621 break; 1622 default: 1623 STRIP_TYPE_NOPS (exp.value); 1624 if (TREE_NO_WARNING (orig_exp)) 1625 TREE_NO_WARNING (exp.value) = 1; 1626 break; 1627 } 1628 1629 return exp; 1630} 1631 1632 1633/* EXP is an expression of integer type. Apply the integer promotions 1634 to it and return the promoted value. */ 1635 1636tree 1637perform_integral_promotions (tree exp) 1638{ 1639 tree type = TREE_TYPE (exp); 1640 enum tree_code code = TREE_CODE (type); 1641 1642 gcc_assert (INTEGRAL_TYPE_P (type)); 1643 1644 /* Normally convert enums to int, 1645 but convert wide enums to something wider. */ 1646 if (code == ENUMERAL_TYPE) 1647 { 1648 type = c_common_type_for_size (MAX (TYPE_PRECISION (type), 1649 TYPE_PRECISION (integer_type_node)), 1650 ((TYPE_PRECISION (type) 1651 >= TYPE_PRECISION (integer_type_node)) 1652 && TYPE_UNSIGNED (type))); 1653 1654 return convert (type, exp); 1655 } 1656 1657 /* ??? This should no longer be needed now bit-fields have their 1658 proper types. */ 1659 if (TREE_CODE (exp) == COMPONENT_REF 1660 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) 1661 /* If it's thinner than an int, promote it like a 1662 c_promoting_integer_type_p, otherwise leave it alone. */ 1663 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), 1664 TYPE_PRECISION (integer_type_node))) 1665 return convert (integer_type_node, exp); 1666 1667 if (c_promoting_integer_type_p (type)) 1668 { 1669 /* Preserve unsignedness if not really getting any wider. */ 1670 if (TYPE_UNSIGNED (type) 1671 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 1672 return convert (unsigned_type_node, exp); 1673 1674 return convert (integer_type_node, exp); 1675 } 1676 1677 return exp; 1678} 1679 1680 1681/* Perform default promotions for C data used in expressions. 1682 Enumeral types or short or char are converted to int. 1683 In addition, manifest constants symbols are replaced by their values. */ 1684 1685tree 1686default_conversion (tree exp) 1687{ 1688 tree orig_exp; 1689 tree type = TREE_TYPE (exp); 1690 enum tree_code code = TREE_CODE (type); 1691 1692 /* Functions and arrays have been converted during parsing. */ 1693 gcc_assert (code != FUNCTION_TYPE); 1694 if (code == ARRAY_TYPE) 1695 return exp; 1696 1697 /* Constants can be used directly unless they're not loadable. */ 1698 if (TREE_CODE (exp) == CONST_DECL) 1699 exp = DECL_INITIAL (exp); 1700 1701 /* Replace a nonvolatile const static variable with its value unless 1702 it is an array, in which case we must be sure that taking the 1703 address of the array produces consistent results. */ 1704 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) 1705 { 1706 exp = decl_constant_value_for_broken_optimization (exp); 1707 type = TREE_TYPE (exp); 1708 } 1709 1710 /* Strip no-op conversions. */ 1711 orig_exp = exp; 1712 STRIP_TYPE_NOPS (exp); 1713 1714 if (TREE_NO_WARNING (orig_exp)) 1715 TREE_NO_WARNING (exp) = 1; 1716 1717 if (INTEGRAL_TYPE_P (type)) 1718 return perform_integral_promotions (exp); 1719 1720 if (code == VOID_TYPE) 1721 { 1722 error ("void value not ignored as it ought to be"); 1723 return error_mark_node; 1724 } 1725 return exp; 1726} 1727 1728/* Look up COMPONENT in a structure or union DECL. 1729 1730 If the component name is not found, returns NULL_TREE. Otherwise, 1731 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL 1732 stepping down the chain to the component, which is in the last 1733 TREE_VALUE of the list. Normally the list is of length one, but if 1734 the component is embedded within (nested) anonymous structures or 1735 unions, the list steps down the chain to the component. */ 1736 1737static tree 1738lookup_field (tree decl, tree component) 1739{ 1740 tree type = TREE_TYPE (decl); 1741 tree field; 1742 1743 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers 1744 to the field elements. Use a binary search on this array to quickly 1745 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC 1746 will always be set for structures which have many elements. */ 1747 1748 if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s) 1749 { 1750 int bot, top, half; 1751 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0]; 1752 1753 field = TYPE_FIELDS (type); 1754 bot = 0; 1755 top = TYPE_LANG_SPECIFIC (type)->s->len; 1756 while (top - bot > 1) 1757 { 1758 half = (top - bot + 1) >> 1; 1759 field = field_array[bot+half]; 1760 1761 if (DECL_NAME (field) == NULL_TREE) 1762 { 1763 /* Step through all anon unions in linear fashion. */ 1764 while (DECL_NAME (field_array[bot]) == NULL_TREE) 1765 { 1766 field = field_array[bot++]; 1767 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 1768 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 1769 { 1770 tree anon = lookup_field (field, component); 1771 1772 if (anon) 1773 return tree_cons (NULL_TREE, field, anon); 1774 } 1775 } 1776 1777 /* Entire record is only anon unions. */ 1778 if (bot > top) 1779 return NULL_TREE; 1780 1781 /* Restart the binary search, with new lower bound. */ 1782 continue; 1783 } 1784 1785 if (DECL_NAME (field) == component) 1786 break; 1787 if (DECL_NAME (field) < component) 1788 bot += half; 1789 else 1790 top = bot + half; 1791 } 1792 1793 if (DECL_NAME (field_array[bot]) == component) 1794 field = field_array[bot]; 1795 else if (DECL_NAME (field) != component) 1796 return NULL_TREE; 1797 } 1798 else 1799 { 1800 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1801 { 1802 if (DECL_NAME (field) == NULL_TREE 1803 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 1804 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)) 1805 { 1806 tree anon = lookup_field (field, component); 1807 1808 if (anon) 1809 return tree_cons (NULL_TREE, field, anon); 1810 } 1811 1812 if (DECL_NAME (field) == component) 1813 break; 1814 } 1815 1816 if (field == NULL_TREE) 1817 return NULL_TREE; 1818 } 1819 1820 return tree_cons (NULL_TREE, field, NULL_TREE); 1821} 1822 1823/* Make an expression to refer to the COMPONENT field of 1824 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */ 1825 1826tree 1827build_component_ref (tree datum, tree component) 1828{ 1829 tree type = TREE_TYPE (datum); 1830 enum tree_code code = TREE_CODE (type); 1831 tree field = NULL; 1832 tree ref; 1833 1834 if (!objc_is_public (datum, component)) 1835 return error_mark_node; 1836 1837 /* APPLE LOCAL begin C* property (Radar 4436866) */ 1838 /* APPLE LOCAL radar 5285911 */ 1839 if ((ref = objc_build_property_reference_expr (datum, component))) 1840 return ref; 1841 /* APPLE LOCAL end C* property (Radar 4436866) */ 1842 1843 /* See if there is a field or component with name COMPONENT. */ 1844 1845 if (code == RECORD_TYPE || code == UNION_TYPE) 1846 { 1847 if (!COMPLETE_TYPE_P (type)) 1848 { 1849 c_incomplete_type_error (NULL_TREE, type); 1850 return error_mark_node; 1851 } 1852 1853 field = lookup_field (datum, component); 1854 1855 if (!field) 1856 { 1857 error ("%qT has no member named %qE", type, component); 1858 return error_mark_node; 1859 } 1860 1861 /* Chain the COMPONENT_REFs if necessary down to the FIELD. 1862 This might be better solved in future the way the C++ front 1863 end does it - by giving the anonymous entities each a 1864 separate name and type, and then have build_component_ref 1865 recursively call itself. We can't do that here. */ 1866 do 1867 { 1868 tree subdatum = TREE_VALUE (field); 1869 int quals; 1870 tree subtype; 1871 1872 if (TREE_TYPE (subdatum) == error_mark_node) 1873 return error_mark_node; 1874 1875 quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum))); 1876 quals |= TYPE_QUALS (TREE_TYPE (datum)); 1877 subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals); 1878 1879 ref = build3 (COMPONENT_REF, subtype, datum, subdatum, 1880 NULL_TREE); 1881 /* APPLE LOCAL radar 4697411 */ 1882 objc_volatilize_component_ref (ref, TREE_TYPE (subdatum)); 1883 if (TREE_READONLY (datum) || TREE_READONLY (subdatum)) 1884 TREE_READONLY (ref) = 1; 1885 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum)) 1886 TREE_THIS_VOLATILE (ref) = 1; 1887 1888 if (TREE_DEPRECATED (subdatum)) 1889 warn_deprecated_use (subdatum); 1890 1891 /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 1892 if (TREE_UNAVAILABLE (subdatum)) 1893 error_unavailable_use (subdatum); 1894 /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 1895 1896 datum = ref; 1897 1898 field = TREE_CHAIN (field); 1899 } 1900 while (field); 1901 1902 return ref; 1903 } 1904 else if (code != ERROR_MARK) 1905 error ("request for member %qE in something not a structure or union", 1906 component); 1907 1908 return error_mark_node; 1909} 1910 1911/* Given an expression PTR for a pointer, return an expression 1912 for the value pointed to. 1913 ERRORSTRING is the name of the operator to appear in error messages. */ 1914 1915tree 1916build_indirect_ref (tree ptr, const char *errorstring) 1917{ 1918 tree pointer = default_conversion (ptr); 1919 tree type = TREE_TYPE (pointer); 1920 1921 if (TREE_CODE (type) == POINTER_TYPE) 1922 { 1923 if (TREE_CODE (pointer) == CONVERT_EXPR 1924 || TREE_CODE (pointer) == NOP_EXPR 1925 || TREE_CODE (pointer) == VIEW_CONVERT_EXPR) 1926 { 1927 /* If a warning is issued, mark it to avoid duplicates from 1928 the backend. This only needs to be done at 1929 warn_strict_aliasing > 2. */ 1930 if (warn_strict_aliasing > 2) 1931 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)), 1932 type, TREE_OPERAND (pointer, 0))) 1933 TREE_NO_WARNING (pointer) = 1; 1934 } 1935 1936 if (TREE_CODE (pointer) == ADDR_EXPR 1937 && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 1938 == TREE_TYPE (type))) 1939 return TREE_OPERAND (pointer, 0); 1940 else 1941 { 1942 tree t = TREE_TYPE (type); 1943 tree ref; 1944 1945 ref = build1 (INDIRECT_REF, t, pointer); 1946 1947 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 1948 { 1949 error ("dereferencing pointer to incomplete type"); 1950 return error_mark_node; 1951 } 1952 if (VOID_TYPE_P (t) && skip_evaluation == 0) 1953 warning (0, "dereferencing %<void *%> pointer"); 1954 1955 /* We *must* set TREE_READONLY when dereferencing a pointer to const, 1956 so that we get the proper error message if the result is used 1957 to assign to. Also, &* is supposed to be a no-op. 1958 And ANSI C seems to specify that the type of the result 1959 should be the const type. */ 1960 /* A de-reference of a pointer to const is not a const. It is valid 1961 to change it via some other pointer. */ 1962 TREE_READONLY (ref) = TYPE_READONLY (t); 1963 TREE_SIDE_EFFECTS (ref) 1964 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 1965 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 1966 return ref; 1967 } 1968 } 1969 else if (TREE_CODE (pointer) != ERROR_MARK) 1970 error ("invalid type argument of %qs (have %qT)", errorstring, type); 1971 return error_mark_node; 1972} 1973 1974/* This handles expressions of the form "a[i]", which denotes 1975 an array reference. 1976 1977 This is logically equivalent in C to *(a+i), but we may do it differently. 1978 If A is a variable or a member, we generate a primitive ARRAY_REF. 1979 This avoids forcing the array out of registers, and can work on 1980 arrays that are not lvalues (for example, members of structures returned 1981 by functions). */ 1982 1983tree 1984build_array_ref (tree array, tree index) 1985{ 1986 bool swapped = false; 1987 if (TREE_TYPE (array) == error_mark_node 1988 || TREE_TYPE (index) == error_mark_node) 1989 return error_mark_node; 1990 1991 if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1992 && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 1993 { 1994 tree temp; 1995 if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1996 && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 1997 { 1998 error ("subscripted value is neither array nor pointer"); 1999 return error_mark_node; 2000 } 2001 temp = array; 2002 array = index; 2003 index = temp; 2004 swapped = true; 2005 } 2006 2007 if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 2008 { 2009 error ("array subscript is not an integer"); 2010 return error_mark_node; 2011 } 2012 2013 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 2014 { 2015 error ("subscripted value is pointer to function"); 2016 return error_mark_node; 2017 } 2018 2019 /* ??? Existing practice has been to warn only when the char 2020 index is syntactically the index, not for char[array]. */ 2021 if (!swapped) 2022 warn_array_subscript_with_type_char (index); 2023 2024 /* Apply default promotions *after* noticing character types. */ 2025 index = default_conversion (index); 2026 2027 gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 2028 2029 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 2030 { 2031 tree rval, type; 2032 2033 /* An array that is indexed by a non-constant 2034 cannot be stored in a register; we must be able to do 2035 address arithmetic on its address. 2036 Likewise an array of elements of variable size. */ 2037 if (TREE_CODE (index) != INTEGER_CST 2038 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 2039 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 2040 { 2041 if (!c_mark_addressable (array)) 2042 return error_mark_node; 2043 } 2044 /* An array that is indexed by a constant value which is not within 2045 the array bounds cannot be stored in a register either; because we 2046 would get a crash in store_bit_field/extract_bit_field when trying 2047 to access a non-existent part of the register. */ 2048 if (TREE_CODE (index) == INTEGER_CST 2049 && TYPE_DOMAIN (TREE_TYPE (array)) 2050 && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 2051 { 2052 if (!c_mark_addressable (array)) 2053 return error_mark_node; 2054 } 2055 2056 if (pedantic) 2057 { 2058 tree foo = array; 2059 while (TREE_CODE (foo) == COMPONENT_REF) 2060 foo = TREE_OPERAND (foo, 0); 2061 if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2062 pedwarn ("ISO C forbids subscripting %<register%> array"); 2063 else if (!flag_isoc99 && !lvalue_p (foo)) 2064 pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 2065 } 2066 2067 type = TREE_TYPE (TREE_TYPE (array)); 2068 if (TREE_CODE (type) != ARRAY_TYPE) 2069 type = TYPE_MAIN_VARIANT (type); 2070 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 2071 /* Array ref is const/volatile if the array elements are 2072 or if the array is. */ 2073 TREE_READONLY (rval) 2074 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 2075 | TREE_READONLY (array)); 2076 TREE_SIDE_EFFECTS (rval) 2077 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 2078 | TREE_SIDE_EFFECTS (array)); 2079 TREE_THIS_VOLATILE (rval) 2080 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 2081 /* This was added by rms on 16 Nov 91. 2082 It fixes vol struct foo *a; a->elts[1] 2083 in an inline function. 2084 Hope it doesn't break something else. */ 2085 | TREE_THIS_VOLATILE (array)); 2086 return require_complete_type (fold (rval)); 2087 } 2088 else 2089 { 2090 tree ar = default_conversion (array); 2091 2092 if (ar == error_mark_node) 2093 return ar; 2094 2095 gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2096 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 2097 2098 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2099 "array indexing"); 2100 } 2101} 2102 2103/* Build an external reference to identifier ID. FUN indicates 2104 whether this will be used for a function call. LOC is the source 2105 location of the identifier. */ 2106tree 2107build_external_ref (tree id, int fun, location_t loc) 2108{ 2109 tree ref; 2110 tree decl = lookup_name (id); 2111 2112 /* In Objective-C, an instance variable (ivar) may be preferred to 2113 whatever lookup_name() found. */ 2114 decl = objc_lookup_ivar (decl, id); 2115 /* APPLE LOCAL begin radar 5732232 - blocks (C++ ci) */ 2116 if (decl && decl != error_mark_node) 2117 { 2118 if (cur_block 2119 && (TREE_CODE (decl) == VAR_DECL 2120 || TREE_CODE (decl) == PARM_DECL) 2121 && !lookup_name_in_block (id, &decl)) 2122 { 2123 /* APPLE LOCAL begin radar 5803005 (C++ ci) */ 2124 bool gdecl; 2125 /* We are referencing a variable inside a block whose declaration 2126 is outside. */ 2127 gcc_assert (decl && 2128 (TREE_CODE (decl) == VAR_DECL 2129 || TREE_CODE (decl) == PARM_DECL)); 2130 gdecl = (TREE_CODE (decl) == VAR_DECL && 2131 /* APPLE LOCAL radar 6177162 */ 2132 (DECL_EXTERNAL (decl) || TREE_STATIC (decl))); 2133 /* Treat all 'global' variables as 'byref' by default. */ 2134 /* APPLE LOCAL begin radar 6014138 (C++ ci) */ 2135 if (gdecl || (TREE_CODE (decl) == VAR_DECL && COPYABLE_BYREF_LOCAL_VAR (decl))) 2136 /* APPLE LOCAL end radar 6014138 (C++ ci) */ 2137 { 2138 /* APPLE LOCAL begin radar 5803600 (C++ ci) */ 2139 /* byref globals are directly accessed. */ 2140 /* APPLE LOCAL begin radar 7760213 */ 2141 if (!gdecl) { 2142 if (HasByrefArray(TREE_TYPE (decl))) 2143 error ("cannot access __block variable of array type inside block"); 2144 /* build a decl for the byref variable. */ 2145 decl = build_block_byref_decl (id, decl, decl); 2146 } 2147 /* APPLE LOCAL end radar 7760213 */ 2148 else 2149 add_block_global_byref_list (decl); 2150 } 2151 else 2152 { 2153 /* 'byref' globals are never copied-in. So, do not add 2154 them to the copied-in list. */ 2155 if (!in_block_global_byref_list (decl)) { 2156 /* APPLE LOCAL begin radar 7721728 */ 2157 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 2158 error ("cannot access copied-in variable of array type inside block"); 2159 /* APPLE LOCAL end radar 7721728 */ 2160 /* build a new decl node. set its type to 'const' type 2161 of the old decl. */ 2162 decl = build_block_ref_decl (id, decl); 2163 } 2164 /* APPLE LOCAL end radar 5803600 (C++ ci) */ 2165 /* APPLE LOCAL end radar 5803005 (C++ ci) */ 2166 } 2167 } 2168 ref = decl; 2169 } 2170 /* APPLE LOCAL end radar 5732232 - blocks (C++ ci) */ 2171 else if (fun) 2172 /* Implicit function declaration. */ 2173 ref = implicitly_declare (id); 2174 else if (decl == error_mark_node) 2175 /* Don't complain about something that's already been 2176 complained about. */ 2177 return error_mark_node; 2178 else 2179 { 2180 undeclared_variable (id, loc); 2181 return error_mark_node; 2182 } 2183 2184 if (TREE_TYPE (ref) == error_mark_node) 2185 return error_mark_node; 2186 2187 if (TREE_DEPRECATED (ref)) 2188 warn_deprecated_use (ref); 2189 2190 /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 2191 if (TREE_UNAVAILABLE (ref)) 2192 error_unavailable_use (ref); 2193 /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 2194 2195 if (!skip_evaluation) 2196 assemble_external (ref); 2197 TREE_USED (ref) = 1; 2198 2199 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2200 { 2201 if (!in_sizeof && !in_typeof) 2202 C_DECL_USED (ref) = 1; 2203 else if (DECL_INITIAL (ref) == 0 2204 && DECL_EXTERNAL (ref) 2205 && !TREE_PUBLIC (ref)) 2206 record_maybe_used_decl (ref); 2207 } 2208 2209 if (TREE_CODE (ref) == CONST_DECL) 2210 { 2211 used_types_insert (TREE_TYPE (ref)); 2212 ref = DECL_INITIAL (ref); 2213 TREE_CONSTANT (ref) = 1; 2214 TREE_INVARIANT (ref) = 1; 2215 } 2216 else if (current_function_decl != 0 2217 && !DECL_FILE_SCOPE_P (current_function_decl) 2218 && (TREE_CODE (ref) == VAR_DECL 2219 || TREE_CODE (ref) == PARM_DECL 2220 || TREE_CODE (ref) == FUNCTION_DECL)) 2221 { 2222 tree context = decl_function_context (ref); 2223 2224 if (context != 0 && context != current_function_decl) 2225 DECL_NONLOCAL (ref) = 1; 2226 } 2227 /* C99 6.7.4p3: An inline definition of a function with external 2228 linkage ... shall not contain a reference to an identifier with 2229 internal linkage. */ 2230 else if (current_function_decl != 0 2231 && DECL_DECLARED_INLINE_P (current_function_decl) 2232 && DECL_EXTERNAL (current_function_decl) 2233 && VAR_OR_FUNCTION_DECL_P (ref) 2234 && DECL_FILE_SCOPE_P (ref) 2235 && pedantic 2236 && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) 2237 && ! TREE_PUBLIC (ref)) 2238 pedwarn ("%H%qD is static but used in inline function %qD " 2239 "which is not static", &loc, ref, current_function_decl); 2240 2241 return ref; 2242} 2243 2244/* Record details of decls possibly used inside sizeof or typeof. */ 2245struct maybe_used_decl 2246{ 2247 /* The decl. */ 2248 tree decl; 2249 /* The level seen at (in_sizeof + in_typeof). */ 2250 int level; 2251 /* The next one at this level or above, or NULL. */ 2252 struct maybe_used_decl *next; 2253}; 2254 2255static struct maybe_used_decl *maybe_used_decls; 2256 2257/* Record that DECL, an undefined static function reference seen 2258 inside sizeof or typeof, might be used if the operand of sizeof is 2259 a VLA type or the operand of typeof is a variably modified 2260 type. */ 2261 2262static void 2263record_maybe_used_decl (tree decl) 2264{ 2265 struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2266 t->decl = decl; 2267 t->level = in_sizeof + in_typeof; 2268 t->next = maybe_used_decls; 2269 maybe_used_decls = t; 2270} 2271 2272/* Pop the stack of decls possibly used inside sizeof or typeof. If 2273 USED is false, just discard them. If it is true, mark them used 2274 (if no longer inside sizeof or typeof) or move them to the next 2275 level up (if still inside sizeof or typeof). */ 2276 2277void 2278pop_maybe_used (bool used) 2279{ 2280 struct maybe_used_decl *p = maybe_used_decls; 2281 int cur_level = in_sizeof + in_typeof; 2282 while (p && p->level > cur_level) 2283 { 2284 if (used) 2285 { 2286 if (cur_level == 0) 2287 C_DECL_USED (p->decl) = 1; 2288 else 2289 p->level = cur_level; 2290 } 2291 p = p->next; 2292 } 2293 if (!used || cur_level == 0) 2294 maybe_used_decls = p; 2295} 2296 2297/* Return the result of sizeof applied to EXPR. */ 2298 2299struct c_expr 2300c_expr_sizeof_expr (struct c_expr expr) 2301{ 2302 struct c_expr ret; 2303 if (expr.value == error_mark_node) 2304 { 2305 ret.value = error_mark_node; 2306 ret.original_code = ERROR_MARK; 2307 pop_maybe_used (false); 2308 } 2309 else 2310 { 2311 ret.value = c_sizeof (TREE_TYPE (expr.value)); 2312 ret.original_code = ERROR_MARK; 2313 if (c_vla_type_p (TREE_TYPE (expr.value))) 2314 { 2315 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2316 ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2317 } 2318 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2319 } 2320 return ret; 2321} 2322 2323/* Return the result of sizeof applied to T, a structure for the type 2324 name passed to sizeof (rather than the type itself). */ 2325 2326struct c_expr 2327c_expr_sizeof_type (struct c_type_name *t) 2328{ 2329 tree type; 2330 struct c_expr ret; 2331 type = groktypename (t); 2332 ret.value = c_sizeof (type); 2333 ret.original_code = ERROR_MARK; 2334 pop_maybe_used (type != error_mark_node 2335 ? C_TYPE_VARIABLE_SIZE (type) : false); 2336 return ret; 2337} 2338 2339/* Build a function call to function FUNCTION with parameters PARAMS. 2340 PARAMS is a list--a chain of TREE_LIST nodes--in which the 2341 TREE_VALUE of each node is a parameter-expression. 2342 FUNCTION's data type may be a function type or a pointer-to-function. */ 2343 2344tree 2345build_function_call (tree function, tree params) 2346{ 2347 tree fntype, fundecl = 0; 2348 tree coerced_params; 2349 tree name = NULL_TREE, result; 2350 tree tem; 2351 2352 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 2353 STRIP_TYPE_NOPS (function); 2354 2355 /* Convert anything with function type to a pointer-to-function. */ 2356 if (TREE_CODE (function) == FUNCTION_DECL) 2357 { 2358 /* Implement type-directed function overloading for builtins. 2359 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2360 handle all the type checking. The result is a complete expression 2361 that implements this function call. */ 2362 tem = resolve_overloaded_builtin (function, params); 2363 if (tem) 2364 return tem; 2365 2366 name = DECL_NAME (function); 2367 fundecl = function; 2368 } 2369 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2370 function = function_to_pointer_conversion (function); 2371 2372 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2373 expressions, like those used for ObjC messenger dispatches. */ 2374 function = objc_rewrite_function_call (function, params); 2375 2376 fntype = TREE_TYPE (function); 2377 2378 if (TREE_CODE (fntype) == ERROR_MARK) 2379 return error_mark_node; 2380 /* APPLE LOCAL begin radar 5732232 - blocks */ 2381 if (!((TREE_CODE (fntype) == POINTER_TYPE 2382 || TREE_CODE (fntype) == BLOCK_POINTER_TYPE) 2383 /* APPLE LOCAL end radar 5732232 - blocks */ 2384 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 2385 { 2386 error ("called object %qE is not a function", function); 2387 return error_mark_node; 2388 } 2389 2390 if (fundecl && TREE_THIS_VOLATILE (fundecl)) 2391 current_function_returns_abnormally = 1; 2392 2393 /* fntype now gets the type of function pointed to. */ 2394 fntype = TREE_TYPE (fntype); 2395 2396 /* Check that the function is called through a compatible prototype. 2397 If it is not, replace the call by a trap, wrapped up in a compound 2398 expression if necessary. This has the nice side-effect to prevent 2399 the tree-inliner from generating invalid assignment trees which may 2400 blow up in the RTL expander later. */ 2401 if ((TREE_CODE (function) == NOP_EXPR 2402 || TREE_CODE (function) == CONVERT_EXPR) 2403 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2404 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2405 && !comptypes (fntype, TREE_TYPE (tem))) 2406 { 2407 tree return_type = TREE_TYPE (fntype); 2408 tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2409 NULL_TREE); 2410 2411 /* This situation leads to run-time undefined behavior. We can't, 2412 therefore, simply error unless we can prove that all possible 2413 executions of the program must execute the code. */ 2414 warning (0, "function called through a non-compatible type"); 2415 2416 /* We can, however, treat "undefined" any way we please. 2417 Call abort to encourage the user to fix the program. */ 2418 inform ("if this code is reached, the program will abort"); 2419 2420 if (VOID_TYPE_P (return_type)) 2421 return trap; 2422 else 2423 { 2424 tree rhs; 2425 2426 if (AGGREGATE_TYPE_P (return_type)) 2427 rhs = build_compound_literal (return_type, 2428 build_constructor (return_type, 0)); 2429 else 2430 rhs = fold_convert (return_type, integer_zero_node); 2431 2432 return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2433 } 2434 } 2435 2436 /* Convert the parameters to the types declared in the 2437 function prototype, or apply default promotions. */ 2438 2439 coerced_params 2440 = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 2441 2442 if (coerced_params == error_mark_node) 2443 return error_mark_node; 2444 2445 /* Check that the arguments to the function are valid. */ 2446 2447 check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2448 TYPE_ARG_TYPES (fntype)); 2449 2450 /* APPLE LOCAL begin radar 5732232 - blocks */ 2451 if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2452 result = build_block_call (fntype, function, coerced_params); 2453 else 2454 /* APPLE LOCAL end radar 5732232 - blocks */ 2455 if (require_constant_value) 2456 { 2457 result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2458 function, coerced_params, NULL_TREE); 2459 2460 if (TREE_CONSTANT (result) 2461 && (name == NULL_TREE 2462 || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2463 pedwarn_init ("initializer element is not constant"); 2464 } 2465 else 2466 result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2467 function, coerced_params, NULL_TREE); 2468 2469 if (VOID_TYPE_P (TREE_TYPE (result))) 2470 return result; 2471 return require_complete_type (result); 2472} 2473 2474/* Convert the argument expressions in the list VALUES 2475 to the types in the list TYPELIST. The result is a list of converted 2476 argument expressions, unless there are too few arguments in which 2477 case it is error_mark_node. 2478 2479 If TYPELIST is exhausted, or when an element has NULL as its type, 2480 perform the default conversions. 2481 2482 PARMLIST is the chain of parm decls for the function being called. 2483 It may be 0, if that info is not available. 2484 It is used only for generating error messages. 2485 2486 FUNCTION is a tree for the called function. It is used only for 2487 error messages, where it is formatted with %qE. 2488 2489 This is also where warnings about wrong number of args are generated. 2490 2491 Both VALUES and the returned value are chains of TREE_LIST nodes 2492 with the elements of the list in the TREE_VALUE slots of those nodes. */ 2493 2494static tree 2495convert_arguments (tree typelist, tree values, tree function, tree fundecl) 2496{ 2497 tree typetail, valtail; 2498 tree result = NULL; 2499 int parmnum; 2500 tree selector; 2501 2502 /* Change pointer to function to the function itself for 2503 diagnostics. */ 2504 if (TREE_CODE (function) == ADDR_EXPR 2505 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2506 function = TREE_OPERAND (function, 0); 2507 2508 /* Handle an ObjC selector specially for diagnostics. */ 2509 selector = objc_message_selector (); 2510 2511 /* Scan the given expressions and types, producing individual 2512 converted arguments and pushing them on RESULT in reverse order. */ 2513 2514 for (valtail = values, typetail = typelist, parmnum = 0; 2515 valtail; 2516 valtail = TREE_CHAIN (valtail), parmnum++) 2517 { 2518 tree type = typetail ? TREE_VALUE (typetail) : 0; 2519 tree val = TREE_VALUE (valtail); 2520 tree rname = function; 2521 int argnum = parmnum + 1; 2522 const char *invalid_func_diag; 2523 2524 if (type == void_type_node) 2525 { 2526 /* APPLE LOCAL begin radar 5732232 - blocks */ 2527 if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2528 { 2529 error ("too many arguments to block call"); 2530 break; 2531 } 2532 /* APPLE LOCAL end radar 5732232 - blocks */ 2533 /* APPLE LOCAL begin radar 4491608 */ 2534 error ("too many arguments to function %qE", selector ? selector 2535 : function); 2536 /* APPLE LOCAL end radar 4491608 */ 2537 break; 2538 } 2539 2540 if (selector && argnum > 2) 2541 { 2542 rname = selector; 2543 argnum -= 2; 2544 } 2545 2546 STRIP_TYPE_NOPS (val); 2547 2548 val = require_complete_type (val); 2549 2550 if (type != 0) 2551 { 2552 /* Formal parm type is specified by a function prototype. */ 2553 tree parmval; 2554 2555 if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 2556 { 2557 error ("type of formal parameter %d is incomplete", parmnum + 1); 2558 parmval = val; 2559 } 2560 else 2561 { 2562 /* Optionally warn about conversions that 2563 differ from the default conversions. */ 2564 if (warn_conversion || warn_traditional) 2565 { 2566 unsigned int formal_prec = TYPE_PRECISION (type); 2567 2568 if (INTEGRAL_TYPE_P (type) 2569 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2570 warning (0, "passing argument %d of %qE as integer " 2571 "rather than floating due to prototype", 2572 argnum, rname); 2573 if (INTEGRAL_TYPE_P (type) 2574 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2575 warning (0, "passing argument %d of %qE as integer " 2576 "rather than complex due to prototype", 2577 argnum, rname); 2578 else if (TREE_CODE (type) == COMPLEX_TYPE 2579 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2580 warning (0, "passing argument %d of %qE as complex " 2581 "rather than floating due to prototype", 2582 argnum, rname); 2583 else if (TREE_CODE (type) == REAL_TYPE 2584 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2585 warning (0, "passing argument %d of %qE as floating " 2586 "rather than integer due to prototype", 2587 argnum, rname); 2588 else if (TREE_CODE (type) == COMPLEX_TYPE 2589 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2590 warning (0, "passing argument %d of %qE as complex " 2591 "rather than integer due to prototype", 2592 argnum, rname); 2593 else if (TREE_CODE (type) == REAL_TYPE 2594 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2595 warning (0, "passing argument %d of %qE as floating " 2596 "rather than complex due to prototype", 2597 argnum, rname); 2598 /* ??? At some point, messages should be written about 2599 conversions between complex types, but that's too messy 2600 to do now. */ 2601 else if (TREE_CODE (type) == REAL_TYPE 2602 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2603 { 2604 /* Warn if any argument is passed as `float', 2605 since without a prototype it would be `double'. */ 2606 if (formal_prec == TYPE_PRECISION (float_type_node) 2607 && type != dfloat32_type_node) 2608 warning (0, "passing argument %d of %qE as %<float%> " 2609 "rather than %<double%> due to prototype", 2610 argnum, rname); 2611 2612 /* Warn if mismatch between argument and prototype 2613 for decimal float types. Warn of conversions with 2614 binary float types and of precision narrowing due to 2615 prototype. */ 2616 else if (type != TREE_TYPE (val) 2617 && (type == dfloat32_type_node 2618 || type == dfloat64_type_node 2619 || type == dfloat128_type_node 2620 || TREE_TYPE (val) == dfloat32_type_node 2621 || TREE_TYPE (val) == dfloat64_type_node 2622 || TREE_TYPE (val) == dfloat128_type_node) 2623 && (formal_prec 2624 <= TYPE_PRECISION (TREE_TYPE (val)) 2625 || (type == dfloat128_type_node 2626 && (TREE_TYPE (val) 2627 != dfloat64_type_node 2628 && (TREE_TYPE (val) 2629 != dfloat32_type_node))) 2630 || (type == dfloat64_type_node 2631 && (TREE_TYPE (val) 2632 != dfloat32_type_node)))) 2633 warning (0, "passing argument %d of %qE as %qT " 2634 "rather than %qT due to prototype", 2635 argnum, rname, type, TREE_TYPE (val)); 2636 2637 } 2638 /* Detect integer changing in width or signedness. 2639 These warnings are only activated with 2640 -Wconversion, not with -Wtraditional. */ 2641 else if (warn_conversion && INTEGRAL_TYPE_P (type) 2642 && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2643 { 2644 tree would_have_been = default_conversion (val); 2645 tree type1 = TREE_TYPE (would_have_been); 2646 2647 if (TREE_CODE (type) == ENUMERAL_TYPE 2648 && (TYPE_MAIN_VARIANT (type) 2649 == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 2650 /* No warning if function asks for enum 2651 and the actual arg is that enum type. */ 2652 ; 2653 else if (formal_prec != TYPE_PRECISION (type1)) 2654 warning (OPT_Wconversion, "passing argument %d of %qE " 2655 "with different width due to prototype", 2656 argnum, rname); 2657 else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 2658 ; 2659 /* Don't complain if the formal parameter type 2660 is an enum, because we can't tell now whether 2661 the value was an enum--even the same enum. */ 2662 else if (TREE_CODE (type) == ENUMERAL_TYPE) 2663 ; 2664 else if (TREE_CODE (val) == INTEGER_CST 2665 && int_fits_type_p (val, type)) 2666 /* Change in signedness doesn't matter 2667 if a constant value is unaffected. */ 2668 ; 2669 /* If the value is extended from a narrower 2670 unsigned type, it doesn't matter whether we 2671 pass it as signed or unsigned; the value 2672 certainly is the same either way. */ 2673 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2674 && TYPE_UNSIGNED (TREE_TYPE (val))) 2675 ; 2676 else if (TYPE_UNSIGNED (type)) 2677 warning (OPT_Wconversion, "passing argument %d of %qE " 2678 "as unsigned due to prototype", 2679 argnum, rname); 2680 else 2681 warning (OPT_Wconversion, "passing argument %d of %qE " 2682 "as signed due to prototype", argnum, rname); 2683 } 2684 } 2685 2686 parmval = convert_for_assignment (type, val, ic_argpass, 2687 fundecl, function, 2688 parmnum + 1); 2689 2690 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 2691 && INTEGRAL_TYPE_P (type) 2692 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 2693 parmval = default_conversion (parmval); 2694 } 2695 result = tree_cons (NULL_TREE, parmval, result); 2696 } 2697 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2698 && (TYPE_PRECISION (TREE_TYPE (val)) 2699 < TYPE_PRECISION (double_type_node)) 2700 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 2701 /* Convert `float' to `double'. */ 2702 result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2703 else if ((invalid_func_diag = 2704 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2705 { 2706 error (invalid_func_diag, ""); 2707 return error_mark_node; 2708 } 2709 else 2710 /* Convert `short' and `char' to full-size `int'. */ 2711 result = tree_cons (NULL_TREE, default_conversion (val), result); 2712 2713 if (typetail) 2714 typetail = TREE_CHAIN (typetail); 2715 } 2716 2717 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 2718 { 2719 /* APPLE LOCAL begin radar 5732232 - blocks */ 2720 if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2721 error ("too few arguments to block %qE", function); 2722 else 2723 error ("too few arguments to function %qE", function); 2724 /* APPLE LOCAL end radar 5732232 - blocks */ 2725 return error_mark_node; 2726 } 2727 2728 return nreverse (result); 2729} 2730 2731/* This is the entry point used by the parser to build unary operators 2732 in the input. CODE, a tree_code, specifies the unary operator, and 2733 ARG is the operand. For unary plus, the C parser currently uses 2734 CONVERT_EXPR for code. */ 2735 2736struct c_expr 2737parser_build_unary_op (enum tree_code code, struct c_expr arg) 2738{ 2739 struct c_expr result; 2740 2741 result.original_code = ERROR_MARK; 2742 result.value = build_unary_op (code, arg.value, 0); 2743 2744 if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value)) 2745 overflow_warning (result.value); 2746 2747 return result; 2748} 2749 2750/* This is the entry point used by the parser to build binary operators 2751 in the input. CODE, a tree_code, specifies the binary operator, and 2752 ARG1 and ARG2 are the operands. In addition to constructing the 2753 expression, we check for operands that were written with other binary 2754 operators in a way that is likely to confuse the user. */ 2755 2756struct c_expr 2757parser_build_binary_op (enum tree_code code, struct c_expr arg1, 2758 struct c_expr arg2) 2759{ 2760 struct c_expr result; 2761 2762 enum tree_code code1 = arg1.original_code; 2763 enum tree_code code2 = arg2.original_code; 2764 2765 result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2766 result.original_code = code; 2767 2768 if (TREE_CODE (result.value) == ERROR_MARK) 2769 return result; 2770 2771 /* Check for cases such as x+y<<z which users are likely 2772 to misinterpret. */ 2773 if (warn_parentheses) 2774 warn_about_parentheses (code, code1, code2); 2775 2776 /* Warn about comparisons against string literals, with the exception 2777 of testing for equality or inequality of a string literal with NULL. */ 2778 if (code == EQ_EXPR || code == NE_EXPR) 2779 { 2780 if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2781 || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2782 warning (OPT_Waddress, 2783 "comparison with string literal results in unspecified behaviour"); 2784 } 2785 else if (TREE_CODE_CLASS (code) == tcc_comparison 2786 && (code1 == STRING_CST || code2 == STRING_CST)) 2787 warning (OPT_Waddress, 2788 "comparison with string literal results in unspecified behaviour"); 2789 2790 if (TREE_OVERFLOW_P (result.value) 2791 && !TREE_OVERFLOW_P (arg1.value) 2792 && !TREE_OVERFLOW_P (arg2.value)) 2793 overflow_warning (result.value); 2794 2795 return result; 2796} 2797 2798/* Return a tree for the difference of pointers OP0 and OP1. 2799 The resulting tree has type int. */ 2800 2801static tree 2802pointer_diff (tree op0, tree op1) 2803{ 2804 tree restype = ptrdiff_type_node; 2805 2806 tree target_type = TREE_TYPE (TREE_TYPE (op0)); 2807 tree con0, con1, lit0, lit1; 2808 tree orig_op1 = op1; 2809 2810 if (pedantic || warn_pointer_arith) 2811 { 2812 if (TREE_CODE (target_type) == VOID_TYPE) 2813 pedwarn ("pointer of type %<void *%> used in subtraction"); 2814 if (TREE_CODE (target_type) == FUNCTION_TYPE) 2815 pedwarn ("pointer to a function used in subtraction"); 2816 } 2817 2818 /* If the conversion to ptrdiff_type does anything like widening or 2819 converting a partial to an integral mode, we get a convert_expression 2820 that is in the way to do any simplifications. 2821 (fold-const.c doesn't know that the extra bits won't be needed. 2822 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 2823 different mode in place.) 2824 So first try to find a common term here 'by hand'; we want to cover 2825 at least the cases that occur in legal static initializers. */ 2826 if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2827 && (TYPE_PRECISION (TREE_TYPE (op0)) 2828 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2829 con0 = TREE_OPERAND (op0, 0); 2830 else 2831 con0 = op0; 2832 if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2833 && (TYPE_PRECISION (TREE_TYPE (op1)) 2834 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2835 con1 = TREE_OPERAND (op1, 0); 2836 else 2837 con1 = op1; 2838 2839 if (TREE_CODE (con0) == PLUS_EXPR) 2840 { 2841 lit0 = TREE_OPERAND (con0, 1); 2842 con0 = TREE_OPERAND (con0, 0); 2843 } 2844 else 2845 lit0 = integer_zero_node; 2846 2847 if (TREE_CODE (con1) == PLUS_EXPR) 2848 { 2849 lit1 = TREE_OPERAND (con1, 1); 2850 con1 = TREE_OPERAND (con1, 0); 2851 } 2852 else 2853 lit1 = integer_zero_node; 2854 2855 if (operand_equal_p (con0, con1, 0)) 2856 { 2857 op0 = lit0; 2858 op1 = lit1; 2859 } 2860 2861 2862 /* First do the subtraction as integers; 2863 then drop through to build the divide operator. 2864 Do not do default conversions on the minus operator 2865 in case restype is a short type. */ 2866 2867 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 2868 convert (restype, op1), 0); 2869 /* This generates an error if op1 is pointer to incomplete type. */ 2870 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 2871 error ("arithmetic on pointer to an incomplete type"); 2872 2873 /* This generates an error if op0 is pointer to incomplete type. */ 2874 op1 = c_size_in_bytes (target_type); 2875 2876 /* Divide by the size, in easiest possible way. */ 2877 return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 2878} 2879 2880/* Construct and perhaps optimize a tree representation 2881 for a unary operation. CODE, a tree_code, specifies the operation 2882 and XARG is the operand. 2883 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 2884 the default promotions (such as from short to int). 2885 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 2886 allows non-lvalues; this is only used to handle conversion of non-lvalue 2887 arrays to pointers in C99. */ 2888 2889tree 2890build_unary_op (enum tree_code code, tree xarg, int flag) 2891{ 2892 /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 2893 tree arg = xarg; 2894 tree argtype = 0; 2895 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 2896 tree val; 2897 int noconvert = flag; 2898 const char *invalid_op_diag; 2899 2900 if (typecode == ERROR_MARK) 2901 return error_mark_node; 2902 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 2903 typecode = INTEGER_TYPE; 2904 2905 if ((invalid_op_diag 2906 = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2907 { 2908 error (invalid_op_diag, ""); 2909 return error_mark_node; 2910 } 2911 2912 switch (code) 2913 { 2914 case CONVERT_EXPR: 2915 /* This is used for unary plus, because a CONVERT_EXPR 2916 is enough to prevent anybody from looking inside for 2917 associativity, but won't generate any code. */ 2918 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2919 || typecode == COMPLEX_TYPE 2920 || typecode == VECTOR_TYPE)) 2921 { 2922 error ("wrong type argument to unary plus"); 2923 return error_mark_node; 2924 } 2925 else if (!noconvert) 2926 arg = default_conversion (arg); 2927 arg = non_lvalue (arg); 2928 break; 2929 2930 case NEGATE_EXPR: 2931 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2932 || typecode == COMPLEX_TYPE 2933 || typecode == VECTOR_TYPE)) 2934 { 2935 error ("wrong type argument to unary minus"); 2936 return error_mark_node; 2937 } 2938 else if (!noconvert) 2939 arg = default_conversion (arg); 2940 break; 2941 2942 case BIT_NOT_EXPR: 2943 if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 2944 { 2945 if (!noconvert) 2946 arg = default_conversion (arg); 2947 } 2948 else if (typecode == COMPLEX_TYPE) 2949 { 2950 code = CONJ_EXPR; 2951 if (pedantic) 2952 pedwarn ("ISO C does not support %<~%> for complex conjugation"); 2953 if (!noconvert) 2954 arg = default_conversion (arg); 2955 } 2956 else 2957 { 2958 error ("wrong type argument to bit-complement"); 2959 return error_mark_node; 2960 } 2961 break; 2962 2963 case ABS_EXPR: 2964 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 2965 { 2966 error ("wrong type argument to abs"); 2967 return error_mark_node; 2968 } 2969 else if (!noconvert) 2970 arg = default_conversion (arg); 2971 break; 2972 2973 case CONJ_EXPR: 2974 /* Conjugating a real value is a no-op, but allow it anyway. */ 2975 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2976 || typecode == COMPLEX_TYPE)) 2977 { 2978 error ("wrong type argument to conjugation"); 2979 return error_mark_node; 2980 } 2981 else if (!noconvert) 2982 arg = default_conversion (arg); 2983 break; 2984 2985 case TRUTH_NOT_EXPR: 2986 if (typecode != INTEGER_TYPE 2987 /* APPLE LOCAL radar 5732232 - blocks */ 2988 && typecode != BLOCK_POINTER_TYPE 2989 && typecode != REAL_TYPE && typecode != POINTER_TYPE 2990 && typecode != COMPLEX_TYPE) 2991 { 2992 error ("wrong type argument to unary exclamation mark"); 2993 return error_mark_node; 2994 } 2995 arg = c_objc_common_truthvalue_conversion (arg); 2996 return invert_truthvalue (arg); 2997 2998 case REALPART_EXPR: 2999 if (TREE_CODE (arg) == COMPLEX_CST) 3000 return TREE_REALPART (arg); 3001 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 3002 return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 3003 else 3004 return arg; 3005 3006 case IMAGPART_EXPR: 3007 if (TREE_CODE (arg) == COMPLEX_CST) 3008 return TREE_IMAGPART (arg); 3009 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 3010 return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 3011 else 3012 return convert (TREE_TYPE (arg), integer_zero_node); 3013 3014 case PREINCREMENT_EXPR: 3015 case POSTINCREMENT_EXPR: 3016 case PREDECREMENT_EXPR: 3017 case POSTDECREMENT_EXPR: 3018 3019 /* Increment or decrement the real part of the value, 3020 and don't change the imaginary part. */ 3021 if (typecode == COMPLEX_TYPE) 3022 { 3023 tree real, imag; 3024 3025 if (pedantic) 3026 pedwarn ("ISO C does not support %<++%> and %<--%>" 3027 " on complex types"); 3028 3029 arg = stabilize_reference (arg); 3030 real = build_unary_op (REALPART_EXPR, arg, 1); 3031 imag = build_unary_op (IMAGPART_EXPR, arg, 1); 3032 return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 3033 build_unary_op (code, real, 1), imag); 3034 } 3035 3036 /* Report invalid types. */ 3037 3038 if (typecode != POINTER_TYPE 3039 && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 3040 { 3041 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3042 error ("wrong type argument to increment"); 3043 else 3044 error ("wrong type argument to decrement"); 3045 3046 return error_mark_node; 3047 } 3048 3049 { 3050 tree inc; 3051 tree result_type = TREE_TYPE (arg); 3052 3053 arg = get_unwidened (arg, 0); 3054 argtype = TREE_TYPE (arg); 3055 3056 /* Compute the increment. */ 3057 3058 if (typecode == POINTER_TYPE) 3059 { 3060 /* If pointer target is an undefined struct, 3061 we just cannot know how to do the arithmetic. */ 3062 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 3063 { 3064 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3065 error ("increment of pointer to unknown structure"); 3066 else 3067 error ("decrement of pointer to unknown structure"); 3068 } 3069 else if ((pedantic || warn_pointer_arith) 3070 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 3071 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 3072 { 3073 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3074 pedwarn ("wrong type argument to increment"); 3075 else 3076 pedwarn ("wrong type argument to decrement"); 3077 } 3078 3079 inc = c_size_in_bytes (TREE_TYPE (result_type)); 3080 } 3081 else 3082 inc = integer_one_node; 3083 3084 inc = convert (argtype, inc); 3085 3086 /* Complain about anything else that is not a true lvalue. */ 3087 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 3088 || code == POSTINCREMENT_EXPR) 3089 ? lv_increment 3090 : lv_decrement))) 3091 return error_mark_node; 3092 3093 /* Report a read-only lvalue. */ 3094 if (TREE_READONLY (arg)) 3095 { 3096 readonly_error (arg, 3097 ((code == PREINCREMENT_EXPR 3098 || code == POSTINCREMENT_EXPR) 3099 ? lv_increment : lv_decrement)); 3100 return error_mark_node; 3101 } 3102 3103 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 3104 val = boolean_increment (code, arg); 3105 else 3106 val = build2 (code, TREE_TYPE (arg), arg, inc); 3107 TREE_SIDE_EFFECTS (val) = 1; 3108 val = convert (result_type, val); 3109 if (TREE_CODE (val) != code) 3110 TREE_NO_WARNING (val) = 1; 3111 return val; 3112 } 3113 3114 case ADDR_EXPR: 3115 /* Note that this operation never does default_conversion. */ 3116 3117 /* Let &* cancel out to simplify resulting code. */ 3118 if (TREE_CODE (arg) == INDIRECT_REF) 3119 { 3120 /* Don't let this be an lvalue. */ 3121 if (lvalue_p (TREE_OPERAND (arg, 0))) 3122 return non_lvalue (TREE_OPERAND (arg, 0)); 3123 return TREE_OPERAND (arg, 0); 3124 } 3125 3126 /* For &x[y], return x+y */ 3127 if (TREE_CODE (arg) == ARRAY_REF) 3128 { 3129 tree op0 = TREE_OPERAND (arg, 0); 3130 if (!c_mark_addressable (op0)) 3131 return error_mark_node; 3132 return build_binary_op (PLUS_EXPR, 3133 (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3134 ? array_to_pointer_conversion (op0) 3135 : op0), 3136 TREE_OPERAND (arg, 1), 1); 3137 } 3138 3139 /* Anything not already handled and not a true memory reference 3140 or a non-lvalue array is an error. */ 3141 else if (typecode != FUNCTION_TYPE && !flag 3142 && !lvalue_or_else (arg, lv_addressof)) 3143 return error_mark_node; 3144 3145 /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 3146 argtype = TREE_TYPE (arg); 3147 3148 /* If the lvalue is const or volatile, merge that into the type 3149 to which the address will point. Note that you can't get a 3150 restricted pointer by taking the address of something, so we 3151 only have to deal with `const' and `volatile' here. */ 3152 if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 3153 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 3154 argtype = c_build_type_variant (argtype, 3155 TREE_READONLY (arg), 3156 TREE_THIS_VOLATILE (arg)); 3157 3158 if (!c_mark_addressable (arg)) 3159 return error_mark_node; 3160 3161 gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3162 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 3163 3164 argtype = build_pointer_type (argtype); 3165 3166 /* ??? Cope with user tricks that amount to offsetof. Delete this 3167 when we have proper support for integer constant expressions. */ 3168 val = get_base_address (arg); 3169 if (val && TREE_CODE (val) == INDIRECT_REF 3170 && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3171 { 3172 tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 3173 3174 op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3175 return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3176 } 3177 3178 val = build1 (ADDR_EXPR, argtype, arg); 3179 3180 return val; 3181 3182 default: 3183 gcc_unreachable (); 3184 } 3185 3186 if (argtype == 0) 3187 argtype = TREE_TYPE (arg); 3188 return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3189 : fold_build1 (code, argtype, arg); 3190} 3191 3192/* Return nonzero if REF is an lvalue valid for this language. 3193 Lvalues can be assigned, unless their type has TYPE_READONLY. 3194 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 3195 3196static int 3197lvalue_p (tree ref) 3198{ 3199 enum tree_code code = TREE_CODE (ref); 3200 3201 switch (code) 3202 { 3203 case REALPART_EXPR: 3204 case IMAGPART_EXPR: 3205 case COMPONENT_REF: 3206 return lvalue_p (TREE_OPERAND (ref, 0)); 3207 3208 case COMPOUND_LITERAL_EXPR: 3209 case STRING_CST: 3210 return 1; 3211 3212 case INDIRECT_REF: 3213 case ARRAY_REF: 3214 case VAR_DECL: 3215 case PARM_DECL: 3216 case RESULT_DECL: 3217 case ERROR_MARK: 3218 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 3219 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 3220 3221 case BIND_EXPR: 3222 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 3223 3224 default: 3225 return 0; 3226 } 3227} 3228 3229/* Give an error for storing in something that is 'const'. */ 3230 3231static void 3232readonly_error (tree arg, enum lvalue_use use) 3233{ 3234 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3235 || use == lv_asm); 3236 /* Using this macro rather than (for example) arrays of messages 3237 ensures that all the format strings are checked at compile 3238 time. */ 3239#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3240 : (use == lv_increment ? (I) \ 3241 : (use == lv_decrement ? (D) : (AS)))) 3242 if (TREE_CODE (arg) == COMPONENT_REF) 3243 { 3244 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3245 readonly_error (TREE_OPERAND (arg, 0), use); 3246 else 3247 error (READONLY_MSG (G_("assignment of read-only member %qD"), 3248 G_("increment of read-only member %qD"), 3249 G_("decrement of read-only member %qD"), 3250 G_("read-only member %qD used as %<asm%> output")), 3251 TREE_OPERAND (arg, 1)); 3252 } 3253 else if (TREE_CODE (arg) == VAR_DECL) 3254 error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3255 G_("increment of read-only variable %qD"), 3256 G_("decrement of read-only variable %qD"), 3257 G_("read-only variable %qD used as %<asm%> output")), 3258 arg); 3259 else 3260 error (READONLY_MSG (G_("assignment of read-only location"), 3261 G_("increment of read-only location"), 3262 G_("decrement of read-only location"), 3263 G_("read-only location used as %<asm%> output"))); 3264} 3265 3266 3267/* Return nonzero if REF is an lvalue valid for this language; 3268 otherwise, print an error message and return zero. USE says 3269 how the lvalue is being used and so selects the error message. */ 3270 3271static int 3272lvalue_or_else (tree ref, enum lvalue_use use) 3273{ 3274 int win = lvalue_p (ref); 3275 3276 if (!win) 3277 lvalue_error (use); 3278 3279 return win; 3280} 3281 3282/* Mark EXP saying that we need to be able to take the 3283 address of it; it should not be allocated in a register. 3284 Returns true if successful. */ 3285 3286bool 3287c_mark_addressable (tree exp) 3288{ 3289 tree x = exp; 3290 3291 while (1) 3292 switch (TREE_CODE (x)) 3293 { 3294 case COMPONENT_REF: 3295 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 3296 { 3297 error 3298 ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3299 return false; 3300 } 3301 3302 /* ... fall through ... */ 3303 3304 case ADDR_EXPR: 3305 case ARRAY_REF: 3306 case REALPART_EXPR: 3307 case IMAGPART_EXPR: 3308 x = TREE_OPERAND (x, 0); 3309 break; 3310 3311 case COMPOUND_LITERAL_EXPR: 3312 case CONSTRUCTOR: 3313 TREE_ADDRESSABLE (x) = 1; 3314 return true; 3315 3316 case VAR_DECL: 3317 case CONST_DECL: 3318 case PARM_DECL: 3319 case RESULT_DECL: 3320 if (C_DECL_REGISTER (x) 3321 && DECL_NONLOCAL (x)) 3322 { 3323 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3324 { 3325 error 3326 ("global register variable %qD used in nested function", x); 3327 return false; 3328 } 3329 pedwarn ("register variable %qD used in nested function", x); 3330 } 3331 else if (C_DECL_REGISTER (x)) 3332 { 3333 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3334 error ("address of global register variable %qD requested", x); 3335 else 3336 error ("address of register variable %qD requested", x); 3337 return false; 3338 } 3339 3340 /* drops in */ 3341 case FUNCTION_DECL: 3342 TREE_ADDRESSABLE (x) = 1; 3343 /* drops out */ 3344 default: 3345 return true; 3346 } 3347} 3348 3349/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 3350 3351tree 3352build_conditional_expr (tree ifexp, tree op1, tree op2) 3353{ 3354 tree type1; 3355 tree type2; 3356 enum tree_code code1; 3357 enum tree_code code2; 3358 tree result_type = NULL; 3359 tree orig_op1 = op1, orig_op2 = op2; 3360 3361 /* Promote both alternatives. */ 3362 3363 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 3364 op1 = default_conversion (op1); 3365 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 3366 op2 = default_conversion (op2); 3367 3368 if (TREE_CODE (ifexp) == ERROR_MARK 3369 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 3370 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 3371 return error_mark_node; 3372 3373 type1 = TREE_TYPE (op1); 3374 code1 = TREE_CODE (type1); 3375 type2 = TREE_TYPE (op2); 3376 code2 = TREE_CODE (type2); 3377 3378 /* C90 does not permit non-lvalue arrays in conditional expressions. 3379 In C99 they will be pointers by now. */ 3380 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3381 { 3382 error ("non-lvalue array in conditional expression"); 3383 return error_mark_node; 3384 } 3385 3386 /* Quickly detect the usual case where op1 and op2 have the same type 3387 after promotion. */ 3388 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 3389 { 3390 if (type1 == type2) 3391 result_type = type1; 3392 else 3393 result_type = TYPE_MAIN_VARIANT (type1); 3394 } 3395 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3396 || code1 == COMPLEX_TYPE) 3397 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3398 || code2 == COMPLEX_TYPE)) 3399 { 3400 result_type = c_common_type (type1, type2); 3401 3402 /* If -Wsign-compare, warn here if type1 and type2 have 3403 different signedness. We'll promote the signed to unsigned 3404 and later code won't know it used to be different. 3405 Do this check on the original types, so that explicit casts 3406 will be considered, but default promotions won't. */ 3407 if (warn_sign_compare && !skip_evaluation) 3408 { 3409 int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3410 int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 3411 3412 if (unsigned_op1 ^ unsigned_op2) 3413 { 3414 bool ovf; 3415 3416 /* Do not warn if the result type is signed, since the 3417 signed type will only be chosen if it can represent 3418 all the values of the unsigned type. */ 3419 if (!TYPE_UNSIGNED (result_type)) 3420 /* OK */; 3421 /* Do not warn if the signed quantity is an unsuffixed 3422 integer literal (or some static constant expression 3423 involving such literals) and it is non-negative. */ 3424 else if ((unsigned_op2 3425 && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3426 || (unsigned_op1 3427 && tree_expr_nonnegative_warnv_p (op2, &ovf))) 3428 /* OK */; 3429 else 3430 warning (0, "signed and unsigned type in conditional expression"); 3431 } 3432 } 3433 } 3434 else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 3435 { 3436 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 3437 pedwarn ("ISO C forbids conditional expr with only one void side"); 3438 result_type = void_type_node; 3439 } 3440 /* APPLE LOCAL begin blocks 6065211 */ 3441 else if ((code1 == POINTER_TYPE 3442 || code1 == BLOCK_POINTER_TYPE) 3443 && (code2 == POINTER_TYPE 3444 || code2 == BLOCK_POINTER_TYPE)) 3445 /* APPLE LOCAL end blocks 6065211 */ 3446 { 3447 if (comp_target_types (type1, type2)) 3448 result_type = common_pointer_type (type1, type2); 3449 else if (null_pointer_constant_p (orig_op1)) 3450 result_type = qualify_type (type2, type1); 3451 else if (null_pointer_constant_p (orig_op2)) 3452 result_type = qualify_type (type1, type2); 3453 /* APPLE LOCAL begin blocks 6065211 */ 3454 else if (code2 == BLOCK_POINTER_TYPE 3455 && VOID_TYPE_P (TREE_TYPE (type1))) 3456 result_type = type2; 3457 else if (code1 == BLOCK_POINTER_TYPE 3458 && VOID_TYPE_P (TREE_TYPE (type2))) 3459 result_type = type1; 3460 /* APPLE LOCAL end blocks 6065211 */ 3461 else if (VOID_TYPE_P (TREE_TYPE (type1))) 3462 { 3463 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3464 pedwarn ("ISO C forbids conditional expr between " 3465 "%<void *%> and function pointer"); 3466 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 3467 TREE_TYPE (type2))); 3468 } 3469 else if (VOID_TYPE_P (TREE_TYPE (type2))) 3470 { 3471 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3472 pedwarn ("ISO C forbids conditional expr between " 3473 "%<void *%> and function pointer"); 3474 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 3475 TREE_TYPE (type1))); 3476 } 3477 else 3478 { 3479 pedwarn ("pointer type mismatch in conditional expression"); 3480 result_type = build_pointer_type (void_type_node); 3481 } 3482 } 3483 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 3484 { 3485 if (!null_pointer_constant_p (orig_op2)) 3486 pedwarn ("pointer/integer type mismatch in conditional expression"); 3487 else 3488 { 3489 op2 = null_pointer_node; 3490 } 3491 result_type = type1; 3492 } 3493 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 3494 { 3495 if (!null_pointer_constant_p (orig_op1)) 3496 pedwarn ("pointer/integer type mismatch in conditional expression"); 3497 else 3498 { 3499 op1 = null_pointer_node; 3500 } 3501 result_type = type2; 3502 } 3503 /* APPLE LOCAL begin radar 5732232 - blocks (C++ co) */ 3504 /* APPLE LOCAL radar 5957801 */ 3505 else if (code1 == BLOCK_POINTER_TYPE && code2 == INTEGER_TYPE) 3506 { 3507 if (!null_pointer_constant_p (orig_op2)) 3508 error ("block pointer/integer type mismatch in conditional expression"); 3509 else 3510 { 3511 op2 = convert (type1, null_pointer_node); 3512 } 3513 result_type = type1; 3514 } 3515 /* APPLE LOCAL radar 5957801 */ 3516 else if (code2 == BLOCK_POINTER_TYPE && code1 == INTEGER_TYPE) 3517 { 3518 if (!null_pointer_constant_p (orig_op1)) 3519 error ("block pointer/integer type mismatch in conditional expression"); 3520 else 3521 { 3522 op1 = convert (type2, null_pointer_node); 3523 } 3524 result_type = type2; 3525 } 3526 3527 /* APPLE LOCAL end radar 5732232 - blocks (C++ co) */ 3528 if (!result_type) 3529 { 3530 if (flag_cond_mismatch) 3531 result_type = void_type_node; 3532 else 3533 { 3534 error ("type mismatch in conditional expression"); 3535 return error_mark_node; 3536 } 3537 } 3538 3539 /* Merge const and volatile flags of the incoming types. */ 3540 result_type 3541 = build_type_variant (result_type, 3542 TREE_READONLY (op1) || TREE_READONLY (op2), 3543 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 3544 3545 if (result_type != TREE_TYPE (op1)) 3546 op1 = convert_and_check (result_type, op1); 3547 if (result_type != TREE_TYPE (op2)) 3548 op2 = convert_and_check (result_type, op2); 3549 3550 return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 3551} 3552 3553/* Return a compound expression that performs two expressions and 3554 returns the value of the second of them. */ 3555 3556tree 3557build_compound_expr (tree expr1, tree expr2) 3558{ 3559 if (!TREE_SIDE_EFFECTS (expr1)) 3560 { 3561 /* The left-hand operand of a comma expression is like an expression 3562 statement: with -Wextra or -Wunused, we should warn if it doesn't have 3563 any side-effects, unless it was explicitly cast to (void). */ 3564 if (warn_unused_value) 3565 { 3566 if (VOID_TYPE_P (TREE_TYPE (expr1)) 3567 && (TREE_CODE (expr1) == NOP_EXPR 3568 || TREE_CODE (expr1) == CONVERT_EXPR)) 3569 ; /* (void) a, b */ 3570 else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3571 && TREE_CODE (expr1) == COMPOUND_EXPR 3572 && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3573 || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3574 ; /* (void) a, (void) b, c */ 3575 else 3576 warning (0, "left-hand operand of comma expression has no effect"); 3577 } 3578 } 3579 3580 /* With -Wunused, we should also warn if the left-hand operand does have 3581 side-effects, but computes a value which is not used. For example, in 3582 `foo() + bar(), baz()' the result of the `+' operator is not used, 3583 so we should issue a warning. */ 3584 else if (warn_unused_value) 3585 warn_if_unused_value (expr1, input_location); 3586 3587 if (expr2 == error_mark_node) 3588 return error_mark_node; 3589 3590 return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 3591} 3592 3593/* Build an expression representing a cast to type TYPE of expression EXPR. */ 3594 3595tree 3596build_c_cast (tree type, tree expr) 3597{ 3598 tree value = expr; 3599 3600 if (type == error_mark_node || expr == error_mark_node) 3601 return error_mark_node; 3602 3603 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3604 only in <protocol> qualifications. But when constructing cast expressions, 3605 the protocols do matter and must be kept around. */ 3606 if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3607 return build1 (NOP_EXPR, type, expr); 3608 3609 type = TYPE_MAIN_VARIANT (type); 3610 3611 if (TREE_CODE (type) == ARRAY_TYPE) 3612 { 3613 error ("cast specifies array type"); 3614 return error_mark_node; 3615 } 3616 3617 if (TREE_CODE (type) == FUNCTION_TYPE) 3618 { 3619 error ("cast specifies function type"); 3620 return error_mark_node; 3621 } 3622 3623 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 3624 { 3625 if (pedantic) 3626 { 3627 if (TREE_CODE (type) == RECORD_TYPE 3628 || TREE_CODE (type) == UNION_TYPE) 3629 pedwarn ("ISO C forbids casting nonscalar to the same type"); 3630 } 3631 } 3632 else if (TREE_CODE (type) == UNION_TYPE) 3633 { 3634 tree field; 3635 3636 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 3637 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3638 TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 3639 break; 3640 3641 if (field) 3642 { 3643 tree t; 3644 3645 if (pedantic) 3646 pedwarn ("ISO C forbids casts to union type"); 3647 t = digest_init (type, 3648 build_constructor_single (type, field, value), 3649 true, 0); 3650 TREE_CONSTANT (t) = TREE_CONSTANT (value); 3651 TREE_INVARIANT (t) = TREE_INVARIANT (value); 3652 return t; 3653 } 3654 error ("cast to union type from type not present in union"); 3655 return error_mark_node; 3656 } 3657 else 3658 { 3659 tree otype, ovalue; 3660 3661 if (type == void_type_node) 3662 return build1 (CONVERT_EXPR, type, value); 3663 3664 otype = TREE_TYPE (value); 3665 3666 /* APPLE LOCAL begin radar 5732232 - blocks */ 3667 if (TREE_CODE (otype) == BLOCK_POINTER_TYPE && 3668 TREE_CODE (type) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type))) 3669 return build1 (NOP_EXPR, type, value); 3670 /* APPLE LOCAL end radar 5732232 - blocks */ 3671 3672 /* Optionally warn about potentially worrisome casts. */ 3673 3674 if (warn_cast_qual 3675 && TREE_CODE (type) == POINTER_TYPE 3676 && TREE_CODE (otype) == POINTER_TYPE) 3677 { 3678 tree in_type = type; 3679 tree in_otype = otype; 3680 int added = 0; 3681 int discarded = 0; 3682 3683 /* Check that the qualifiers on IN_TYPE are a superset of 3684 the qualifiers of IN_OTYPE. The outermost level of 3685 POINTER_TYPE nodes is uninteresting and we stop as soon 3686 as we hit a non-POINTER_TYPE node on either type. */ 3687 do 3688 { 3689 in_otype = TREE_TYPE (in_otype); 3690 in_type = TREE_TYPE (in_type); 3691 3692 /* GNU C allows cv-qualified function types. 'const' 3693 means the function is very pure, 'volatile' means it 3694 can't return. We need to warn when such qualifiers 3695 are added, not when they're taken away. */ 3696 if (TREE_CODE (in_otype) == FUNCTION_TYPE 3697 && TREE_CODE (in_type) == FUNCTION_TYPE) 3698 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 3699 else 3700 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 3701 } 3702 while (TREE_CODE (in_type) == POINTER_TYPE 3703 && TREE_CODE (in_otype) == POINTER_TYPE); 3704 3705 if (added) 3706 warning (0, "cast adds new qualifiers to function type"); 3707 3708 if (discarded) 3709 /* There are qualifiers present in IN_OTYPE that are not 3710 present in IN_TYPE. */ 3711 warning (0, "cast discards qualifiers from pointer target type"); 3712 } 3713 3714 /* Warn about possible alignment problems. */ 3715 if (STRICT_ALIGNMENT 3716 && TREE_CODE (type) == POINTER_TYPE 3717 && TREE_CODE (otype) == POINTER_TYPE 3718 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 3719 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3720 /* Don't warn about opaque types, where the actual alignment 3721 restriction is unknown. */ 3722 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 3723 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 3724 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 3725 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3726 warning (OPT_Wcast_align, 3727 "cast increases required alignment of target type"); 3728 3729 if (TREE_CODE (type) == INTEGER_TYPE 3730 && TREE_CODE (otype) == POINTER_TYPE 3731 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3732 /* Unlike conversion of integers to pointers, where the 3733 warning is disabled for converting constants because 3734 of cases such as SIG_*, warn about converting constant 3735 pointers to integers. In some cases it may cause unwanted 3736 sign extension, and a warning is appropriate. */ 3737 warning (OPT_Wpointer_to_int_cast, 3738 "cast from pointer to integer of different size"); 3739 3740 if (TREE_CODE (value) == CALL_EXPR 3741 && TREE_CODE (type) != TREE_CODE (otype)) 3742 warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3743 "to non-matching type %qT", otype, type); 3744 3745 if (TREE_CODE (type) == POINTER_TYPE 3746 && TREE_CODE (otype) == INTEGER_TYPE 3747 && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 3748 /* Don't warn about converting any constant. */ 3749 && !TREE_CONSTANT (value)) 3750 warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3751 "of different size"); 3752 3753 if (warn_strict_aliasing <= 2) 3754 strict_aliasing_warning (otype, type, expr); 3755 3756 /* If pedantic, warn for conversions between function and object 3757 pointer types, except for converting a null pointer constant 3758 to function pointer type. */ 3759 if (pedantic 3760 && TREE_CODE (type) == POINTER_TYPE 3761 && TREE_CODE (otype) == POINTER_TYPE 3762 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3763 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3764 pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3765 3766 if (pedantic 3767 && TREE_CODE (type) == POINTER_TYPE 3768 && TREE_CODE (otype) == POINTER_TYPE 3769 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3770 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3771 && !null_pointer_constant_p (value)) 3772 pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3773 3774 ovalue = value; 3775 /* APPLE LOCAL begin don't sign-extend pointers cast to integers */ 3776 if (TREE_CODE (type) == INTEGER_TYPE 3777 && TREE_CODE (otype) == POINTER_TYPE 3778 && TYPE_PRECISION (type) > TYPE_PRECISION (otype) 3779 && TYPE_UNSIGNED (type)) 3780 value = convert (c_common_type_for_size (POINTER_SIZE, 1), value); 3781 /* APPLE LOCAL end don't sign-extend pointers cast to integers */ 3782 value = convert (type, value); 3783 3784 /* Ignore any integer overflow caused by the cast. */ 3785 if (TREE_CODE (value) == INTEGER_CST) 3786 { 3787 if (CONSTANT_CLASS_P (ovalue) 3788 && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3789 { 3790 /* Avoid clobbering a shared constant. */ 3791 value = copy_node (value); 3792 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3793 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3794 } 3795 else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3796 /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3797 value = build_int_cst_wide (TREE_TYPE (value), 3798 TREE_INT_CST_LOW (value), 3799 TREE_INT_CST_HIGH (value)); 3800 } 3801 } 3802 3803 /* Don't let a cast be an lvalue. */ 3804 if (value == expr) 3805 value = non_lvalue (value); 3806 3807 return value; 3808} 3809 3810/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 3811static bool 3812functiontypes_are_block_compatible (tree f1, tree f2) 3813{ 3814 tree arg1, arg2; 3815 if (!types_are_block_compatible (TREE_TYPE (f1), TREE_TYPE (f2))) 3816 return false; 3817 arg1 = TYPE_ARG_TYPES (f1); 3818 arg2 = TYPE_ARG_TYPES (f2); 3819 /* APPLE LOCAL radar 6246965, 6196572 */ 3820 return (!arg1) || (type_lists_compatible_p (arg1, arg2) == 1); 3821} 3822 3823static bool 3824types_are_block_compatible (tree lhptee, tree rhptee) 3825{ 3826 if (TYPE_MAIN_VARIANT (lhptee) == TYPE_MAIN_VARIANT (rhptee)) 3827 return true; 3828 if (TREE_CODE (lhptee) == FUNCTION_TYPE && TREE_CODE (rhptee) == FUNCTION_TYPE) 3829 return functiontypes_are_block_compatible (lhptee, rhptee); 3830 /* APPLE LOCAL begin radar 5882266 (C++ cm) */ 3831 if (TREE_CODE (lhptee) == POINTER_TYPE && TREE_CODE (rhptee) == POINTER_TYPE) 3832 return types_are_block_compatible (TREE_TYPE (lhptee), TREE_TYPE (rhptee)); 3833 /* APPLE LOCAL end radar 5882266 (C++ cm) */ 3834 /* APPLE LOCAL begin radar 5988995 (C++ cm) */ 3835 if (TREE_CODE (lhptee) == BLOCK_POINTER_TYPE 3836 && TREE_CODE (rhptee) == BLOCK_POINTER_TYPE) 3837 return types_are_block_compatible (TREE_TYPE (lhptee), TREE_TYPE (rhptee)); 3838 /* APPLE LOCAL end radar 5988995 (C++ cm) */ 3839 return false; 3840} 3841 3842/* APPLE LOCAL begin radar 5847213 - radar 6329245 */ 3843/** 3844 build_block_call - Routine to build a block call; as in: 3845 ((double(*)(void *, int))(BLOCK_PTR_EXP->__FuncPtr))(I, 42); 3846 FNTYPE is the original function type derived from the syntax. 3847 BLOCK_PTR_EXP is the block pointer variable. 3848 PARAMS is the parameter list. 3849*/ 3850static tree 3851build_block_call (tree fntype, tree block_ptr_exp, tree params) 3852{ 3853 tree function_ptr_exp; 3854 tree typelist; 3855 bool block_ptr_exp_side_effect = TREE_SIDE_EFFECTS (block_ptr_exp); 3856 3857 /* First convert BLOCK_PTR_EXP to 'void *'. */ 3858 block_ptr_exp = convert (ptr_type_node, block_ptr_exp); 3859 gcc_assert (generic_block_literal_struct_type); 3860 block_ptr_exp = convert (build_pointer_type (generic_block_literal_struct_type), 3861 block_ptr_exp); 3862 if (block_ptr_exp_side_effect) 3863 block_ptr_exp = save_expr (block_ptr_exp); 3864 3865 /* BLOCK_PTR_VAR->__FuncPtr */ 3866 function_ptr_exp = build_component_ref (build_indirect_ref (block_ptr_exp, "->"), 3867 get_identifier ("__FuncPtr")); 3868 gcc_assert (function_ptr_exp); 3869 3870 /* Build: result_type(*)(void *, function-arg-type-list) */ 3871 typelist = TYPE_ARG_TYPES (fntype); 3872 typelist = tree_cons (NULL_TREE, ptr_type_node, typelist); 3873 fntype = build_function_type (TREE_TYPE (fntype), typelist); 3874 function_ptr_exp = convert (build_pointer_type (fntype), function_ptr_exp); 3875 params = tree_cons (NULL_TREE, block_ptr_exp, params); 3876 return fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 3877 function_ptr_exp, params, NULL_TREE); 3878} 3879/* APPLE LOCAL end radar 5847213 - radar 6329245 */ 3880/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 3881 3882/* Interpret a cast of expression EXPR to type TYPE. */ 3883tree 3884c_cast_expr (struct c_type_name *type_name, tree expr) 3885{ 3886 tree type; 3887 int saved_wsp = warn_strict_prototypes; 3888 3889 /* This avoids warnings about unprototyped casts on 3890 integers. E.g. "#define SIG_DFL (void(*)())0". */ 3891 if (TREE_CODE (expr) == INTEGER_CST) 3892 warn_strict_prototypes = 0; 3893 type = groktypename (type_name); 3894 warn_strict_prototypes = saved_wsp; 3895 3896 return build_c_cast (type, expr); 3897} 3898 3899/* Build an assignment expression of lvalue LHS from value RHS. 3900 MODIFYCODE is the code for a binary operator that we use 3901 to combine the old value of LHS with RHS to get the new value. 3902 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 3903 3904tree 3905build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 3906{ 3907 tree result; 3908 tree newrhs; 3909 tree lhstype = TREE_TYPE (lhs); 3910 tree olhstype = lhstype; 3911 /* APPLE LOCAL __block assign sequence point 6639533 */ 3912 bool insert_sequence_point = false; 3913 3914 /* APPLE LOCAL begin radar 4426814 */ 3915 if (c_dialect_objc () && flag_objc_gc) 3916 { 3917 /* APPLE LOCAL radar 5276085 */ 3918 objc_weak_reference_expr (&lhs); 3919 lhstype = TREE_TYPE (lhs); 3920 olhstype = lhstype; 3921 } 3922 /* APPLE LOCAL end radar 4426814 */ 3923 3924 /* Types that aren't fully specified cannot be used in assignments. */ 3925 lhs = require_complete_type (lhs); 3926 3927 /* Avoid duplicate error messages from operands that had errors. */ 3928 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 3929 return error_mark_node; 3930 3931 /* APPLE LOCAL radar 5285911 */ 3932 if (!lvalue_or_else (lhs, lv_assign)) 3933 return error_mark_node; 3934 3935 STRIP_TYPE_NOPS (rhs); 3936 3937 /* APPLE LOCAL begin __block assign sequence point 6639533 */ 3938 /* For byref = x;, we have to transform this into {( typeof(x) x' = 3939 x; byref = x`; )} to ensure there is a sequence point before the 3940 evaluation of the byref, inorder to ensure that the access 3941 expression for byref doesn't start running before x is evaluated, 3942 as it will access the __forwarding pointer and that must be done 3943 after x is evaluated. */ 3944 /* First we check to see if lhs is a byref... byrefs look like: 3945 __Block_byref_X.__forwarding->x */ 3946 if (TREE_CODE (lhs) == COMPONENT_REF) 3947 { 3948 tree inner = TREE_OPERAND (lhs, 0); 3949 /* now check for -> */ 3950 if (TREE_CODE (inner) == INDIRECT_REF) 3951 { 3952 inner = TREE_OPERAND (inner, 0); 3953 if (TREE_CODE (inner) == COMPONENT_REF) 3954 { 3955 inner = TREE_OPERAND (inner, 0); 3956 if (TREE_CODE (inner) == VAR_DECL 3957 && COPYABLE_BYREF_LOCAL_VAR (inner)) 3958 { 3959 tree old_rhs = rhs; 3960 /* then we save the rhs. */ 3961 rhs = save_expr (rhs); 3962 if (rhs != old_rhs) 3963 /* And arrange for the sequence point to be inserted. */ 3964 insert_sequence_point = true; 3965 } 3966 } 3967 } 3968 } 3969 /* APPLE LOCAL end __block assign sequence point 6639533 */ 3970 3971 newrhs = rhs; 3972 3973 /* If a binary op has been requested, combine the old LHS value with the RHS 3974 producing the value we should actually store into the LHS. */ 3975 3976 if (modifycode != NOP_EXPR) 3977 { 3978 lhs = stabilize_reference (lhs); 3979 newrhs = build_binary_op (modifycode, lhs, rhs, 1); 3980 } 3981 3982 /* APPLE LOCAL begin C* property (Radar 4436866) */ 3983 if (c_dialect_objc ()) 3984 { 3985 result = objc_build_setter_call (lhs, newrhs); 3986 if (result) 3987 /* APPLE LOCAL begin __block assign sequence point 6639533 */ 3988 { 3989 if (insert_sequence_point) 3990 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 3991 return result; 3992 } 3993 /* APPLE LOCAL end __block assign sequence point 6639533 */ 3994 } 3995 /* APPLE LOCAL end C* property (Radar 4436866) */ 3996 3997 /* Give an error for storing in something that is 'const'. */ 3998 3999 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 4000 || ((TREE_CODE (lhstype) == RECORD_TYPE 4001 || TREE_CODE (lhstype) == UNION_TYPE) 4002 && C_TYPE_FIELDS_READONLY (lhstype))) 4003 { 4004 readonly_error (lhs, lv_assign); 4005 return error_mark_node; 4006 } 4007 4008 /* If storing into a structure or union member, 4009 it has probably been given type `int'. 4010 Compute the type that would go with 4011 the actual amount of storage the member occupies. */ 4012 4013 if (TREE_CODE (lhs) == COMPONENT_REF 4014 && (TREE_CODE (lhstype) == INTEGER_TYPE 4015 || TREE_CODE (lhstype) == BOOLEAN_TYPE 4016 || TREE_CODE (lhstype) == REAL_TYPE 4017 || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 4018 lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 4019 4020 /* If storing in a field that is in actuality a short or narrower than one, 4021 we must store in the field in its actual type. */ 4022 4023 if (lhstype != TREE_TYPE (lhs)) 4024 { 4025 lhs = copy_node (lhs); 4026 TREE_TYPE (lhs) = lhstype; 4027 } 4028 4029 /* Convert new value to destination type. */ 4030 4031 newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 4032 NULL_TREE, NULL_TREE, 0); 4033 if (TREE_CODE (newrhs) == ERROR_MARK) 4034 return error_mark_node; 4035 4036 /* Emit ObjC write barrier, if necessary. */ 4037 if (c_dialect_objc () && flag_objc_gc) 4038 { 4039 result = objc_generate_write_barrier (lhs, modifycode, newrhs); 4040 if (result) 4041 /* APPLE LOCAL begin __block assign sequence point 6639533 */ 4042 { 4043 if (insert_sequence_point) 4044 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 4045 return result; 4046 } 4047 /* APPLE LOCAL end __block assign sequence point 6639533 */ 4048 } 4049 4050 /* Scan operands. */ 4051 4052 result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 4053 TREE_SIDE_EFFECTS (result) = 1; 4054 4055 /* APPLE LOCAL begin __block assign sequence point 6639533 */ 4056 if (insert_sequence_point) 4057 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 4058 /* APPLE LOCAL end __block assign sequence point 6639533 */ 4059 4060 /* If we got the LHS in a different type for storing in, 4061 convert the result back to the nominal type of LHS 4062 so that the value we return always has the same type 4063 as the LHS argument. */ 4064 4065 if (olhstype == TREE_TYPE (result)) 4066 return result; 4067 return convert_for_assignment (olhstype, result, ic_assign, 4068 NULL_TREE, NULL_TREE, 0); 4069} 4070 4071/* Convert value RHS to type TYPE as preparation for an assignment 4072 to an lvalue of type TYPE. 4073 The real work of conversion is done by `convert'. 4074 The purpose of this function is to generate error messages 4075 for assignments that are not allowed in C. 4076 ERRTYPE says whether it is argument passing, assignment, 4077 initialization or return. 4078 4079 FUNCTION is a tree for the function being called. 4080 PARMNUM is the number of the argument, for printing in error messages. */ 4081 4082static tree 4083convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 4084 tree fundecl, tree function, int parmnum) 4085{ 4086 enum tree_code codel = TREE_CODE (type); 4087 tree rhstype; 4088 enum tree_code coder; 4089 tree rname = NULL_TREE; 4090 bool objc_ok = false; 4091 4092 if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 4093 { 4094 tree selector; 4095 /* Change pointer to function to the function itself for 4096 diagnostics. */ 4097 if (TREE_CODE (function) == ADDR_EXPR 4098 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 4099 function = TREE_OPERAND (function, 0); 4100 4101 /* Handle an ObjC selector specially for diagnostics. */ 4102 selector = objc_message_selector (); 4103 rname = function; 4104 if (selector && parmnum > 2) 4105 { 4106 rname = selector; 4107 parmnum -= 2; 4108 } 4109 } 4110 4111 /* This macro is used to emit diagnostics to ensure that all format 4112 strings are complete sentences, visible to gettext and checked at 4113 compile time. */ 4114#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 4115 do { \ 4116 switch (errtype) \ 4117 { \ 4118 case ic_argpass: \ 4119 pedwarn (AR, parmnum, rname); \ 4120 break; \ 4121 case ic_argpass_nonproto: \ 4122 warning (0, AR, parmnum, rname); \ 4123 break; \ 4124 case ic_assign: \ 4125 pedwarn (AS); \ 4126 break; \ 4127 case ic_init: \ 4128 pedwarn (IN); \ 4129 break; \ 4130 case ic_return: \ 4131 pedwarn (RE); \ 4132 break; \ 4133 default: \ 4134 gcc_unreachable (); \ 4135 } \ 4136 } while (0) 4137 4138 STRIP_TYPE_NOPS (rhs); 4139 4140 if (optimize && TREE_CODE (rhs) == VAR_DECL 4141 && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 4142 rhs = decl_constant_value_for_broken_optimization (rhs); 4143 4144 rhstype = TREE_TYPE (rhs); 4145 coder = TREE_CODE (rhstype); 4146 4147 if (coder == ERROR_MARK) 4148 return error_mark_node; 4149 4150 if (c_dialect_objc ()) 4151 { 4152 int parmno; 4153 4154 switch (errtype) 4155 { 4156 case ic_return: 4157 parmno = 0; 4158 break; 4159 4160 case ic_assign: 4161 parmno = -1; 4162 break; 4163 4164 case ic_init: 4165 parmno = -2; 4166 break; 4167 4168 default: 4169 parmno = parmnum; 4170 break; 4171 } 4172 4173 /* APPLE LOCAL radar 6231433 */ 4174 objc_ok = objc_compare_types (type, rhstype, parmno, rname, "comparison"); 4175 } 4176 4177 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 4178 return rhs; 4179 4180 if (coder == VOID_TYPE) 4181 { 4182 /* Except for passing an argument to an unprototyped function, 4183 this is a constraint violation. When passing an argument to 4184 an unprototyped function, it is compile-time undefined; 4185 making it a constraint in that case was rejected in 4186 DR#252. */ 4187 error ("void value not ignored as it ought to be"); 4188 return error_mark_node; 4189 } 4190 /* A type converts to a reference to it. 4191 This code doesn't fully support references, it's just for the 4192 special case of va_start and va_copy. */ 4193 if (codel == REFERENCE_TYPE 4194 /* APPLE LOCAL begin radar 4502186 */ 4195 && comptypes (objc_non_volatilized_type (TREE_TYPE (type)), 4196 objc_non_volatilized_type (TREE_TYPE (rhs))) == 1) 4197 /* APPLE LOCAL end radar 4502186 */ 4198 { 4199 if (!lvalue_p (rhs)) 4200 { 4201 error ("cannot pass rvalue to reference parameter"); 4202 return error_mark_node; 4203 } 4204 if (!c_mark_addressable (rhs)) 4205 return error_mark_node; 4206 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 4207 4208 /* We already know that these two types are compatible, but they 4209 may not be exactly identical. In fact, `TREE_TYPE (type)' is 4210 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 4211 likely to be va_list, a typedef to __builtin_va_list, which 4212 is different enough that it will cause problems later. */ 4213 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 4214 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 4215 4216 rhs = build1 (NOP_EXPR, type, rhs); 4217 return rhs; 4218 } 4219 /* Some types can interconvert without explicit casts. */ 4220 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 4221 && vector_types_convertible_p (type, TREE_TYPE (rhs), true)) 4222 return convert (type, rhs); 4223 /* Arithmetic types all interconvert, and enum is treated like int. */ 4224 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 4225 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 4226 || codel == BOOLEAN_TYPE) 4227 && (coder == INTEGER_TYPE || coder == REAL_TYPE 4228 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 4229 || coder == BOOLEAN_TYPE)) 4230 return convert_and_check (type, rhs); 4231 4232 /* Aggregates in different TUs might need conversion. */ 4233 if ((codel == RECORD_TYPE || codel == UNION_TYPE) 4234 && codel == coder 4235 && comptypes (type, rhstype)) 4236 return convert_and_check (type, rhs); 4237 4238 /* Conversion to a transparent union from its member types. 4239 This applies only to function arguments. */ 4240 if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 4241 && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 4242 { 4243 tree memb, marginal_memb = NULL_TREE; 4244 4245 for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 4246 { 4247 tree memb_type = TREE_TYPE (memb); 4248 4249 if (comptypes (TYPE_MAIN_VARIANT (memb_type), 4250 TYPE_MAIN_VARIANT (rhstype))) 4251 break; 4252 4253 if (TREE_CODE (memb_type) != POINTER_TYPE) 4254 continue; 4255 4256 if (coder == POINTER_TYPE) 4257 { 4258 tree ttl = TREE_TYPE (memb_type); 4259 tree ttr = TREE_TYPE (rhstype); 4260 4261 /* Any non-function converts to a [const][volatile] void * 4262 and vice versa; otherwise, targets must be the same. 4263 Meanwhile, the lhs target must have all the qualifiers of 4264 the rhs. */ 4265 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4266 || comp_target_types (memb_type, rhstype)) 4267 { 4268 /* If this type won't generate any warnings, use it. */ 4269 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 4270 || ((TREE_CODE (ttr) == FUNCTION_TYPE 4271 && TREE_CODE (ttl) == FUNCTION_TYPE) 4272 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 4273 == TYPE_QUALS (ttr)) 4274 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 4275 == TYPE_QUALS (ttl)))) 4276 break; 4277 4278 /* Keep looking for a better type, but remember this one. */ 4279 if (!marginal_memb) 4280 marginal_memb = memb; 4281 } 4282 } 4283 4284 /* Can convert integer zero to any pointer type. */ 4285 if (null_pointer_constant_p (rhs)) 4286 { 4287 rhs = null_pointer_node; 4288 break; 4289 } 4290 } 4291 4292 if (memb || marginal_memb) 4293 { 4294 if (!memb) 4295 { 4296 /* We have only a marginally acceptable member type; 4297 it needs a warning. */ 4298 tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 4299 tree ttr = TREE_TYPE (rhstype); 4300 4301 /* Const and volatile mean something different for function 4302 types, so the usual warnings are not appropriate. */ 4303 if (TREE_CODE (ttr) == FUNCTION_TYPE 4304 && TREE_CODE (ttl) == FUNCTION_TYPE) 4305 { 4306 /* Because const and volatile on functions are 4307 restrictions that say the function will not do 4308 certain things, it is okay to use a const or volatile 4309 function where an ordinary one is wanted, but not 4310 vice-versa. */ 4311 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4312 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 4313 "makes qualified function " 4314 "pointer from unqualified"), 4315 G_("assignment makes qualified " 4316 "function pointer from " 4317 "unqualified"), 4318 G_("initialization makes qualified " 4319 "function pointer from " 4320 "unqualified"), 4321 G_("return makes qualified function " 4322 "pointer from unqualified")); 4323 } 4324 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4325 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4326 "qualifiers from pointer target type"), 4327 G_("assignment discards qualifiers " 4328 "from pointer target type"), 4329 G_("initialization discards qualifiers " 4330 "from pointer target type"), 4331 G_("return discards qualifiers from " 4332 "pointer target type")); 4333 4334 memb = marginal_memb; 4335 } 4336 4337 if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 4338 pedwarn ("ISO C prohibits argument conversion to union type"); 4339 4340 return build_constructor_single (type, memb, rhs); 4341 } 4342 } 4343 4344 /* Conversions among pointers */ 4345 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4346 && (coder == codel)) 4347 { 4348 /* APPLE LOCAL begin radar 4193359 */ 4349 /* Types differing only by the presence of the 'volatile' 4350 qualifier are acceptable if the 'volatile' has been added 4351 in by the Objective-C EH machinery. */ 4352 tree ttl = objc_non_volatilized_type (TREE_TYPE (type)); 4353 tree ttr = objc_non_volatilized_type (TREE_TYPE (rhstype)); 4354 /* APPLE LOCAL end radar 4193359 */ 4355 tree mvl = ttl; 4356 tree mvr = ttr; 4357 bool is_opaque_pointer; 4358 int target_cmp = 0; /* Cache comp_target_types () result. */ 4359 4360 if (TREE_CODE (mvl) != ARRAY_TYPE) 4361 mvl = TYPE_MAIN_VARIANT (mvl); 4362 if (TREE_CODE (mvr) != ARRAY_TYPE) 4363 mvr = TYPE_MAIN_VARIANT (mvr); 4364 /* Opaque pointers are treated like void pointers. */ 4365 is_opaque_pointer = (targetm.vector_opaque_p (type) 4366 || targetm.vector_opaque_p (rhstype)) 4367 && TREE_CODE (ttl) == VECTOR_TYPE 4368 && TREE_CODE (ttr) == VECTOR_TYPE; 4369 4370 /* C++ does not allow the implicit conversion void* -> T*. However, 4371 for the purpose of reducing the number of false positives, we 4372 tolerate the special case of 4373 4374 int *p = NULL; 4375 4376 where NULL is typically defined in C to be '(void *) 0'. */ 4377 if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4378 warning (OPT_Wc___compat, "request for implicit conversion from " 4379 "%qT to %qT not permitted in C++", rhstype, type); 4380 4381 /* Check if the right-hand side has a format attribute but the 4382 left-hand side doesn't. */ 4383 if (warn_missing_format_attribute 4384 && check_missing_format_attribute (type, rhstype)) 4385 { 4386 switch (errtype) 4387 { 4388 case ic_argpass: 4389 case ic_argpass_nonproto: 4390 warning (OPT_Wmissing_format_attribute, 4391 "argument %d of %qE might be " 4392 "a candidate for a format attribute", 4393 parmnum, rname); 4394 break; 4395 case ic_assign: 4396 warning (OPT_Wmissing_format_attribute, 4397 "assignment left-hand side might be " 4398 "a candidate for a format attribute"); 4399 break; 4400 case ic_init: 4401 warning (OPT_Wmissing_format_attribute, 4402 "initialization left-hand side might be " 4403 "a candidate for a format attribute"); 4404 break; 4405 case ic_return: 4406 warning (OPT_Wmissing_format_attribute, 4407 "return type might be " 4408 "a candidate for a format attribute"); 4409 break; 4410 default: 4411 gcc_unreachable (); 4412 } 4413 } 4414 4415 /* Any non-function converts to a [const][volatile] void * 4416 and vice versa; otherwise, targets must be the same. 4417 Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 4418 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4419 || (target_cmp = comp_target_types (type, rhstype)) 4420 || is_opaque_pointer 4421 || (c_common_unsigned_type (mvl) 4422 == c_common_unsigned_type (mvr))) 4423 { 4424 if (pedantic 4425 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 4426 || 4427 (VOID_TYPE_P (ttr) 4428 && !null_pointer_constant_p (rhs) 4429 && TREE_CODE (ttl) == FUNCTION_TYPE))) 4430 WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4431 "%qE between function pointer " 4432 "and %<void *%>"), 4433 G_("ISO C forbids assignment between " 4434 "function pointer and %<void *%>"), 4435 G_("ISO C forbids initialization between " 4436 "function pointer and %<void *%>"), 4437 G_("ISO C forbids return between function " 4438 "pointer and %<void *%>")); 4439 /* Const and volatile mean something different for function types, 4440 so the usual warnings are not appropriate. */ 4441 else if (TREE_CODE (ttr) != FUNCTION_TYPE 4442 && TREE_CODE (ttl) != FUNCTION_TYPE) 4443 { 4444 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4445 { 4446 /* APPLE LOCAL begin radar 4193359 */ 4447 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4448 "qualifiers from pointer target type"), 4449 G_("assignment discards qualifiers " 4450 "from pointer target type"), 4451 G_("initialization discards qualifiers " 4452 "from pointer target type"), 4453 G_("return discards qualifiers from " 4454 "pointer target type")); 4455 } 4456 /* If this is not a case of ignoring a mismatch in signedness, 4457 no warning. */ 4458 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4459 || target_cmp) 4460 ; 4461 /* If there is a mismatch, do warn. */ 4462 else if (warn_pointer_sign) 4463 WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4464 "%d of %qE differ in signedness"), 4465 G_("pointer targets in assignment " 4466 "differ in signedness"), 4467 G_("pointer targets in initialization " 4468 "differ in signedness"), 4469 G_("pointer targets in return differ " 4470 "in signedness")); 4471 } 4472 else if (TREE_CODE (ttl) == FUNCTION_TYPE 4473 && TREE_CODE (ttr) == FUNCTION_TYPE) 4474 { 4475 /* Because const and volatile on functions are restrictions 4476 that say the function will not do certain things, 4477 it is okay to use a const or volatile function 4478 where an ordinary one is wanted, but not vice-versa. */ 4479 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4480 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4481 "qualified function pointer " 4482 "from unqualified"), 4483 G_("assignment makes qualified function " 4484 "pointer from unqualified"), 4485 G_("initialization makes qualified " 4486 "function pointer from unqualified"), 4487 G_("return makes qualified function " 4488 "pointer from unqualified")); 4489 } 4490 } 4491 else 4492 /* Avoid warning about the volatile ObjC EH puts on decls. */ 4493 if (!objc_ok) 4494 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4495 "incompatible pointer type"), 4496 G_("assignment from incompatible pointer type"), 4497 G_("initialization from incompatible " 4498 "pointer type"), 4499 G_("return from incompatible pointer type")); 4500 4501 return convert (type, rhs); 4502 } 4503 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4504 { 4505 /* ??? This should not be an error when inlining calls to 4506 unprototyped functions. */ 4507 error ("invalid use of non-lvalue array"); 4508 return error_mark_node; 4509 } 4510 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 4511 { 4512 /* An explicit constant 0 can convert to a pointer, 4513 or one that results from arithmetic, even including 4514 a cast to integer type. */ 4515 if (!null_pointer_constant_p (rhs)) 4516 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4517 "pointer from integer without a cast"), 4518 G_("assignment makes pointer from integer " 4519 "without a cast"), 4520 G_("initialization makes pointer from " 4521 "integer without a cast"), 4522 G_("return makes pointer from integer " 4523 "without a cast")); 4524 4525 return convert (type, rhs); 4526 } 4527 /* APPLE LOCAL begin radar 5732232 - blocks */ 4528 else if (codel == BLOCK_POINTER_TYPE && coder == INTEGER_TYPE) 4529 { 4530 if (!null_pointer_constant_p (rhs)) 4531 { 4532 error("invalid conversion %s integer 'int', expected block pointer", 4533 errtype == ic_assign ? "assigning" : "initializing"); 4534 return error_mark_node; 4535 } 4536 return build_int_cst (type, 0); 4537 } 4538 else if (codel == BLOCK_POINTER_TYPE && coder == codel) 4539 { 4540 tree lhptee = TREE_TYPE (type); 4541 tree rhptee = TREE_TYPE(rhstype); 4542 if (lhptee == rhptee) 4543 return rhs; 4544 if (!types_are_block_compatible (lhptee, rhptee)) 4545 { 4546 error ("incompatible block pointer types %s %qT, expected %qT", 4547 errtype == ic_assign ? "assigning" : "initializing", 4548 rhstype, type); 4549 return error_mark_node; 4550 } 4551 return rhs; 4552 } 4553 /* APPLE LOCAL begin radar 5831855 */ 4554 /* APPLE LOCAL radar 5878380 */ 4555 else if (codel == BLOCK_POINTER_TYPE && POINTER_TYPE_P (rhstype) && 4556 (VOID_TYPE_P (TREE_TYPE (rhstype)) || objc_is_id (rhstype))) 4557 return convert (type, rhs); 4558 /* APPLE LOCAL radar 5878380 */ 4559 else if (coder == BLOCK_POINTER_TYPE && POINTER_TYPE_P (type) && 4560 (VOID_TYPE_P (TREE_TYPE (type)) || objc_is_id (type))) 4561 /* APPLE LOCAL end radar 5831855 */ 4562 return convert (type, rhs); 4563 /* APPLE LOCAL end radar 5732232 - blocks */ 4564 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 4565 { 4566 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4567 "from pointer without a cast"), 4568 G_("assignment makes integer from pointer " 4569 "without a cast"), 4570 G_("initialization makes integer from pointer " 4571 "without a cast"), 4572 G_("return makes integer from pointer " 4573 "without a cast")); 4574 return convert (type, rhs); 4575 } 4576 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 4577 return convert (type, rhs); 4578 4579 switch (errtype) 4580 { 4581 case ic_argpass: 4582 case ic_argpass_nonproto: 4583 /* ??? This should not be an error when inlining calls to 4584 unprototyped functions. */ 4585 error ("convert_for_assignment: incompatible type for argument %d of %qE", parmnum, rname); 4586 break; 4587 case ic_assign: 4588 error ("incompatible types in assignment"); 4589 break; 4590 case ic_init: 4591 error ("incompatible types in initialization"); 4592 break; 4593 case ic_return: 4594 error ("incompatible types in return"); 4595 break; 4596 default: 4597 gcc_unreachable (); 4598 } 4599 4600 return error_mark_node; 4601} 4602 4603/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4604 is used for error and warning reporting and indicates which argument 4605 is being processed. */ 4606 4607tree 4608c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 4609{ 4610 tree ret, type; 4611 4612 /* If FN was prototyped at the call site, the value has been converted 4613 already in convert_arguments. 4614 However, we might see a prototype now that was not in place when 4615 the function call was seen, so check that the VALUE actually matches 4616 PARM before taking an early exit. */ 4617 if (!value 4618 || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4619 && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4620 == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 4621 return value; 4622 4623 type = TREE_TYPE (parm); 4624 ret = convert_for_assignment (type, value, 4625 ic_argpass_nonproto, fn, 4626 fn, argnum); 4627 if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 4628 && INTEGRAL_TYPE_P (type) 4629 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 4630 ret = default_conversion (ret); 4631 return ret; 4632} 4633 4634/* If VALUE is a compound expr all of whose expressions are constant, then 4635 return its value. Otherwise, return error_mark_node. 4636 4637 This is for handling COMPOUND_EXPRs as initializer elements 4638 which is allowed with a warning when -pedantic is specified. */ 4639 4640static tree 4641valid_compound_expr_initializer (tree value, tree endtype) 4642{ 4643 if (TREE_CODE (value) == COMPOUND_EXPR) 4644 { 4645 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 4646 == error_mark_node) 4647 return error_mark_node; 4648 return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 4649 endtype); 4650 } 4651 else if (!initializer_constant_valid_p (value, endtype)) 4652 return error_mark_node; 4653 else 4654 return value; 4655} 4656 4657/* Perform appropriate conversions on the initial value of a variable, 4658 store it in the declaration DECL, 4659 and print any error messages that are appropriate. 4660 If the init is invalid, store an ERROR_MARK. */ 4661 4662void 4663store_init_value (tree decl, tree init) 4664{ 4665 tree value, type; 4666 4667 /* If variable's type was invalidly declared, just ignore it. */ 4668 4669 type = TREE_TYPE (decl); 4670 if (TREE_CODE (type) == ERROR_MARK) 4671 return; 4672 4673 /* Digest the specified initializer into an expression. */ 4674 4675 value = digest_init (type, init, true, TREE_STATIC (decl)); 4676 4677 /* Store the expression if valid; else report error. */ 4678 4679 if (!in_system_header 4680 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4681 warning (OPT_Wtraditional, "traditional C rejects automatic " 4682 "aggregate initialization"); 4683 4684 DECL_INITIAL (decl) = value; 4685 4686 /* ANSI wants warnings about out-of-range constant initializers. */ 4687 STRIP_TYPE_NOPS (value); 4688 constant_expression_warning (value); 4689 4690 /* Check if we need to set array size from compound literal size. */ 4691 if (TREE_CODE (type) == ARRAY_TYPE 4692 && TYPE_DOMAIN (type) == 0 4693 && value != error_mark_node) 4694 { 4695 tree inside_init = init; 4696 4697 STRIP_TYPE_NOPS (inside_init); 4698 inside_init = fold (inside_init); 4699 4700 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4701 { 4702 tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 4703 4704 if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 4705 { 4706 /* For int foo[] = (int [3]){1}; we need to set array size 4707 now since later on array initializer will be just the 4708 brace enclosed list of the compound literal. */ 4709 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4710 TREE_TYPE (decl) = type; 4711 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 4712 layout_type (type); 4713 layout_decl (cldecl, 0); 4714 } 4715 } 4716 } 4717} 4718 4719/* Methods for storing and printing names for error messages. */ 4720 4721/* Implement a spelling stack that allows components of a name to be pushed 4722 and popped. Each element on the stack is this structure. */ 4723 4724struct spelling 4725{ 4726 int kind; 4727 union 4728 { 4729 unsigned HOST_WIDE_INT i; 4730 const char *s; 4731 } u; 4732}; 4733 4734#define SPELLING_STRING 1 4735#define SPELLING_MEMBER 2 4736#define SPELLING_BOUNDS 3 4737 4738static struct spelling *spelling; /* Next stack element (unused). */ 4739static struct spelling *spelling_base; /* Spelling stack base. */ 4740static int spelling_size; /* Size of the spelling stack. */ 4741 4742/* Macros to save and restore the spelling stack around push_... functions. 4743 Alternative to SAVE_SPELLING_STACK. */ 4744 4745#define SPELLING_DEPTH() (spelling - spelling_base) 4746#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 4747 4748/* Push an element on the spelling stack with type KIND and assign VALUE 4749 to MEMBER. */ 4750 4751#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 4752{ \ 4753 int depth = SPELLING_DEPTH (); \ 4754 \ 4755 if (depth >= spelling_size) \ 4756 { \ 4757 spelling_size += 10; \ 4758 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4759 spelling_size); \ 4760 RESTORE_SPELLING_DEPTH (depth); \ 4761 } \ 4762 \ 4763 spelling->kind = (KIND); \ 4764 spelling->MEMBER = (VALUE); \ 4765 spelling++; \ 4766} 4767 4768/* Push STRING on the stack. Printed literally. */ 4769 4770static void 4771push_string (const char *string) 4772{ 4773 PUSH_SPELLING (SPELLING_STRING, string, u.s); 4774} 4775 4776/* Push a member name on the stack. Printed as '.' STRING. */ 4777 4778static void 4779push_member_name (tree decl) 4780{ 4781 const char *const string 4782 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 4783 PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 4784} 4785 4786/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 4787 4788static void 4789push_array_bounds (unsigned HOST_WIDE_INT bounds) 4790{ 4791 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 4792} 4793 4794/* Compute the maximum size in bytes of the printed spelling. */ 4795 4796static int 4797spelling_length (void) 4798{ 4799 int size = 0; 4800 struct spelling *p; 4801 4802 for (p = spelling_base; p < spelling; p++) 4803 { 4804 if (p->kind == SPELLING_BOUNDS) 4805 size += 25; 4806 else 4807 size += strlen (p->u.s) + 1; 4808 } 4809 4810 return size; 4811} 4812 4813/* Print the spelling to BUFFER and return it. */ 4814 4815static char * 4816print_spelling (char *buffer) 4817{ 4818 char *d = buffer; 4819 struct spelling *p; 4820 4821 for (p = spelling_base; p < spelling; p++) 4822 if (p->kind == SPELLING_BOUNDS) 4823 { 4824 sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 4825 d += strlen (d); 4826 } 4827 else 4828 { 4829 const char *s; 4830 if (p->kind == SPELLING_MEMBER) 4831 *d++ = '.'; 4832 for (s = p->u.s; (*d = *s++); d++) 4833 ; 4834 } 4835 *d++ = '\0'; 4836 return buffer; 4837} 4838 4839/* Issue an error message for a bad initializer component. 4840 MSGID identifies the message. 4841 The component name is taken from the spelling stack. */ 4842 4843void 4844error_init (const char *msgid) 4845{ 4846 char *ofwhat; 4847 4848 error ("%s", _(msgid)); 4849 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4850 if (*ofwhat) 4851 error ("(near initialization for %qs)", ofwhat); 4852} 4853 4854/* Issue a pedantic warning for a bad initializer component. 4855 MSGID identifies the message. 4856 The component name is taken from the spelling stack. */ 4857 4858void 4859pedwarn_init (const char *msgid) 4860{ 4861 char *ofwhat; 4862 4863 pedwarn ("%s", _(msgid)); 4864 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4865 if (*ofwhat) 4866 pedwarn ("(near initialization for %qs)", ofwhat); 4867} 4868 4869/* Issue a warning for a bad initializer component. 4870 MSGID identifies the message. 4871 The component name is taken from the spelling stack. */ 4872 4873static void 4874warning_init (const char *msgid) 4875{ 4876 char *ofwhat; 4877 4878 warning (0, "%s", _(msgid)); 4879 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 4880 if (*ofwhat) 4881 warning (0, "(near initialization for %qs)", ofwhat); 4882} 4883 4884/* If TYPE is an array type and EXPR is a parenthesized string 4885 constant, warn if pedantic that EXPR is being used to initialize an 4886 object of type TYPE. */ 4887 4888void 4889maybe_warn_string_init (tree type, struct c_expr expr) 4890{ 4891 if (pedantic 4892 && TREE_CODE (type) == ARRAY_TYPE 4893 && TREE_CODE (expr.value) == STRING_CST 4894 && expr.original_code != STRING_CST) 4895 pedwarn_init ("array initialized from parenthesized string constant"); 4896} 4897 4898/* APPLE LOCAL begin radar 5932809 - copyable byref blocks */ 4899tree do_digest_init (tree type, tree init) 4900{ 4901 return digest_init (type, init, true, false); 4902} 4903/* APPLE LOCAL end radar 5932809 - copyable byref blocks */ 4904 4905/* Digest the parser output INIT as an initializer for type TYPE. 4906 Return a C expression of type TYPE to represent the initial value. 4907 4908 If INIT is a string constant, STRICT_STRING is true if it is 4909 unparenthesized or we should not warn here for it being parenthesized. 4910 For other types of INIT, STRICT_STRING is not used. 4911 4912 REQUIRE_CONSTANT requests an error if non-constant initializers or 4913 elements are seen. */ 4914 4915static tree 4916digest_init (tree type, tree init, bool strict_string, int require_constant) 4917{ 4918 enum tree_code code = TREE_CODE (type); 4919 tree inside_init = init; 4920 4921 if (type == error_mark_node 4922 || !init 4923 || init == error_mark_node 4924 || TREE_TYPE (init) == error_mark_node) 4925 return error_mark_node; 4926 4927 STRIP_TYPE_NOPS (inside_init); 4928 4929 inside_init = fold (inside_init); 4930 4931 /* Initialization of an array of chars from a string constant 4932 optionally enclosed in braces. */ 4933 4934 if (code == ARRAY_TYPE && inside_init 4935 && TREE_CODE (inside_init) == STRING_CST) 4936 { 4937 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4938 /* Note that an array could be both an array of character type 4939 and an array of wchar_t if wchar_t is signed char or unsigned 4940 char. */ 4941 bool char_array = (typ1 == char_type_node 4942 || typ1 == signed_char_type_node 4943 || typ1 == unsigned_char_type_node); 4944 bool wchar_array = !!comptypes (typ1, wchar_type_node); 4945 if (char_array || wchar_array) 4946 { 4947 struct c_expr expr; 4948 bool char_string; 4949 expr.value = inside_init; 4950 expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4951 maybe_warn_string_init (type, expr); 4952 4953 char_string 4954 = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4955 == char_type_node); 4956 4957 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4958 TYPE_MAIN_VARIANT (type))) 4959 return inside_init; 4960 4961 if (!wchar_array && !char_string) 4962 { 4963 error_init ("char-array initialized from wide string"); 4964 return error_mark_node; 4965 } 4966 if (char_string && !char_array) 4967 { 4968 error_init ("wchar_t-array initialized from non-wide string"); 4969 return error_mark_node; 4970 } 4971 4972 TREE_TYPE (inside_init) = type; 4973 if (TYPE_DOMAIN (type) != 0 4974 && TYPE_SIZE (type) != 0 4975 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 4976 /* Subtract 1 (or sizeof (wchar_t)) 4977 because it's ok to ignore the terminating null char 4978 that is counted in the length of the constant. */ 4979 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 4980 TREE_STRING_LENGTH (inside_init) 4981 - ((TYPE_PRECISION (typ1) 4982 != TYPE_PRECISION (char_type_node)) 4983 ? (TYPE_PRECISION (wchar_type_node) 4984 / BITS_PER_UNIT) 4985 : 1))) 4986 pedwarn_init ("initializer-string for array of chars is too long"); 4987 4988 return inside_init; 4989 } 4990 else if (INTEGRAL_TYPE_P (typ1)) 4991 { 4992 error_init ("array of inappropriate type initialized " 4993 "from string constant"); 4994 return error_mark_node; 4995 } 4996 } 4997 4998 /* Build a VECTOR_CST from a *constant* vector constructor. If the 4999 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 5000 below and handle as a constructor. */ 5001 if (code == VECTOR_TYPE 5002 && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 5003 && vector_types_convertible_p (TREE_TYPE (inside_init), type, true) 5004 && TREE_CONSTANT (inside_init)) 5005 { 5006 if (TREE_CODE (inside_init) == VECTOR_CST 5007 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 5008 TYPE_MAIN_VARIANT (type))) 5009 return inside_init; 5010 5011 if (TREE_CODE (inside_init) == CONSTRUCTOR) 5012 { 5013 unsigned HOST_WIDE_INT ix; 5014 tree value; 5015 bool constant_p = true; 5016 5017 /* Iterate through elements and check if all constructor 5018 elements are *_CSTs. */ 5019 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 5020 if (!CONSTANT_CLASS_P (value)) 5021 { 5022 constant_p = false; 5023 break; 5024 } 5025 5026 if (constant_p) 5027 return build_vector_from_ctor (type, 5028 CONSTRUCTOR_ELTS (inside_init)); 5029 } 5030 } 5031 5032 /* Any type can be initialized 5033 from an expression of the same type, optionally with braces. */ 5034 5035 if (inside_init && TREE_TYPE (inside_init) != 0 5036 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 5037 TYPE_MAIN_VARIANT (type)) 5038 || (code == ARRAY_TYPE 5039 && comptypes (TREE_TYPE (inside_init), type)) 5040 || (code == VECTOR_TYPE 5041 && comptypes (TREE_TYPE (inside_init), type)) 5042 || (code == POINTER_TYPE 5043 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 5044 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 5045 TREE_TYPE (type))))) 5046 { 5047 if (code == POINTER_TYPE) 5048 { 5049 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 5050 { 5051 if (TREE_CODE (inside_init) == STRING_CST 5052 || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 5053 inside_init = array_to_pointer_conversion (inside_init); 5054 else 5055 { 5056 error_init ("invalid use of non-lvalue array"); 5057 return error_mark_node; 5058 } 5059 } 5060 } 5061 5062 if (code == VECTOR_TYPE) 5063 /* Although the types are compatible, we may require a 5064 conversion. */ 5065 inside_init = convert (type, inside_init); 5066 5067 if (require_constant 5068 && (code == VECTOR_TYPE || !flag_isoc99) 5069 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 5070 { 5071 /* As an extension, allow initializing objects with static storage 5072 duration with compound literals (which are then treated just as 5073 the brace enclosed list they contain). Also allow this for 5074 vectors, as we can only assign them with compound literals. */ 5075 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 5076 inside_init = DECL_INITIAL (decl); 5077 } 5078 5079 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 5080 && TREE_CODE (inside_init) != CONSTRUCTOR) 5081 { 5082 error_init ("array initialized from non-constant array expression"); 5083 return error_mark_node; 5084 } 5085 5086 if (optimize && TREE_CODE (inside_init) == VAR_DECL) 5087 inside_init = decl_constant_value_for_broken_optimization (inside_init); 5088 5089 /* Compound expressions can only occur here if -pedantic or 5090 -pedantic-errors is specified. In the later case, we always want 5091 an error. In the former case, we simply want a warning. */ 5092 if (require_constant && pedantic 5093 && TREE_CODE (inside_init) == COMPOUND_EXPR) 5094 { 5095 inside_init 5096 = valid_compound_expr_initializer (inside_init, 5097 TREE_TYPE (inside_init)); 5098 if (inside_init == error_mark_node) 5099 error_init ("initializer element is not constant"); 5100 else 5101 pedwarn_init ("initializer element is not constant"); 5102 if (flag_pedantic_errors) 5103 inside_init = error_mark_node; 5104 } 5105 else if (require_constant 5106 && !initializer_constant_valid_p (inside_init, 5107 TREE_TYPE (inside_init))) 5108 { 5109 error_init ("initializer element is not constant"); 5110 inside_init = error_mark_node; 5111 } 5112 5113 /* Added to enable additional -Wmissing-format-attribute warnings. */ 5114 /* APPLE LOCAL begin radar 5822844 */ 5115 if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE || 5116 TREE_CODE (TREE_TYPE (inside_init)) == BLOCK_POINTER_TYPE) 5117 /* APPLE LOCAL end radar 5822844 */ 5118 inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 5119 NULL_TREE, 0); 5120 return inside_init; 5121 } 5122 5123 /* Handle scalar types, including conversions. */ 5124 5125 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 5126 /* APPLE LOCAL radar 5732232 - blocks */ 5127 || code == BLOCK_POINTER_TYPE 5128 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 5129 || code == VECTOR_TYPE) 5130 { 5131 if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 5132 && (TREE_CODE (init) == STRING_CST 5133 || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 5134 init = array_to_pointer_conversion (init); 5135 inside_init 5136 = convert_for_assignment (type, init, ic_init, 5137 NULL_TREE, NULL_TREE, 0); 5138 5139 /* Check to see if we have already given an error message. */ 5140 if (inside_init == error_mark_node) 5141 ; 5142 else if (require_constant && !TREE_CONSTANT (inside_init)) 5143 { 5144 error_init ("initializer element is not constant"); 5145 inside_init = error_mark_node; 5146 } 5147 else if (require_constant 5148 && !initializer_constant_valid_p (inside_init, 5149 TREE_TYPE (inside_init))) 5150 { 5151 error_init ("initializer element is not computable at load time"); 5152 inside_init = error_mark_node; 5153 } 5154 5155 return inside_init; 5156 } 5157 5158 /* Come here only for records and arrays. */ 5159 5160 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 5161 { 5162 error_init ("variable-sized object may not be initialized"); 5163 return error_mark_node; 5164 } 5165 5166 error_init ("invalid initializer"); 5167 return error_mark_node; 5168} 5169 5170/* Handle initializers that use braces. */ 5171 5172/* Type of object we are accumulating a constructor for. 5173 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 5174static tree constructor_type; 5175 5176/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 5177 left to fill. */ 5178static tree constructor_fields; 5179 5180/* For an ARRAY_TYPE, this is the specified index 5181 at which to store the next element we get. */ 5182static tree constructor_index; 5183 5184/* For an ARRAY_TYPE, this is the maximum index. */ 5185static tree constructor_max_index; 5186 5187/* For a RECORD_TYPE, this is the first field not yet written out. */ 5188static tree constructor_unfilled_fields; 5189 5190/* For an ARRAY_TYPE, this is the index of the first element 5191 not yet written out. */ 5192static tree constructor_unfilled_index; 5193 5194/* In a RECORD_TYPE, the byte index of the next consecutive field. 5195 This is so we can generate gaps between fields, when appropriate. */ 5196static tree constructor_bit_index; 5197 5198/* If we are saving up the elements rather than allocating them, 5199 this is the list of elements so far (in reverse order, 5200 most recent first). */ 5201static VEC(constructor_elt,gc) *constructor_elements; 5202 5203/* 1 if constructor should be incrementally stored into a constructor chain, 5204 0 if all the elements should be kept in AVL tree. */ 5205static int constructor_incremental; 5206 5207/* 1 if so far this constructor's elements are all compile-time constants. */ 5208static int constructor_constant; 5209 5210/* 1 if so far this constructor's elements are all valid address constants. */ 5211static int constructor_simple; 5212 5213/* 1 if this constructor is erroneous so far. */ 5214static int constructor_erroneous; 5215 5216/* Structure for managing pending initializer elements, organized as an 5217 AVL tree. */ 5218 5219struct init_node 5220{ 5221 struct init_node *left, *right; 5222 struct init_node *parent; 5223 int balance; 5224 tree purpose; 5225 tree value; 5226}; 5227 5228/* Tree of pending elements at this constructor level. 5229 These are elements encountered out of order 5230 which belong at places we haven't reached yet in actually 5231 writing the output. 5232 Will never hold tree nodes across GC runs. */ 5233static struct init_node *constructor_pending_elts; 5234 5235/* The SPELLING_DEPTH of this constructor. */ 5236static int constructor_depth; 5237 5238/* DECL node for which an initializer is being read. 5239 0 means we are reading a constructor expression 5240 such as (struct foo) {...}. */ 5241static tree constructor_decl; 5242 5243/* Nonzero if this is an initializer for a top-level decl. */ 5244static int constructor_top_level; 5245 5246/* Nonzero if there were any member designators in this initializer. */ 5247static int constructor_designated; 5248 5249/* Nesting depth of designator list. */ 5250static int designator_depth; 5251 5252/* Nonzero if there were diagnosed errors in this designator list. */ 5253static int designator_erroneous; 5254 5255 5256/* This stack has a level for each implicit or explicit level of 5257 structuring in the initializer, including the outermost one. It 5258 saves the values of most of the variables above. */ 5259 5260struct constructor_range_stack; 5261 5262struct constructor_stack 5263{ 5264 struct constructor_stack *next; 5265 tree type; 5266 tree fields; 5267 tree index; 5268 tree max_index; 5269 tree unfilled_index; 5270 tree unfilled_fields; 5271 tree bit_index; 5272 VEC(constructor_elt,gc) *elements; 5273 struct init_node *pending_elts; 5274 int offset; 5275 int depth; 5276 /* If value nonzero, this value should replace the entire 5277 constructor at this level. */ 5278 struct c_expr replacement_value; 5279 struct constructor_range_stack *range_stack; 5280 char constant; 5281 char simple; 5282 char implicit; 5283 char erroneous; 5284 char outer; 5285 char incremental; 5286 char designated; 5287}; 5288 5289static struct constructor_stack *constructor_stack; 5290 5291/* This stack represents designators from some range designator up to 5292 the last designator in the list. */ 5293 5294struct constructor_range_stack 5295{ 5296 struct constructor_range_stack *next, *prev; 5297 struct constructor_stack *stack; 5298 tree range_start; 5299 tree index; 5300 tree range_end; 5301 tree fields; 5302}; 5303 5304static struct constructor_range_stack *constructor_range_stack; 5305 5306/* This stack records separate initializers that are nested. 5307 Nested initializers can't happen in ANSI C, but GNU C allows them 5308 in cases like { ... (struct foo) { ... } ... }. */ 5309 5310struct initializer_stack 5311{ 5312 struct initializer_stack *next; 5313 tree decl; 5314 struct constructor_stack *constructor_stack; 5315 struct constructor_range_stack *constructor_range_stack; 5316 VEC(constructor_elt,gc) *elements; 5317 struct spelling *spelling; 5318 struct spelling *spelling_base; 5319 int spelling_size; 5320 char top_level; 5321 char require_constant_value; 5322 char require_constant_elements; 5323}; 5324 5325static struct initializer_stack *initializer_stack; 5326 5327/* Prepare to parse and output the initializer for variable DECL. */ 5328 5329void 5330start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 5331{ 5332 const char *locus; 5333 struct initializer_stack *p = XNEW (struct initializer_stack); 5334 5335 p->decl = constructor_decl; 5336 p->require_constant_value = require_constant_value; 5337 p->require_constant_elements = require_constant_elements; 5338 p->constructor_stack = constructor_stack; 5339 p->constructor_range_stack = constructor_range_stack; 5340 p->elements = constructor_elements; 5341 p->spelling = spelling; 5342 p->spelling_base = spelling_base; 5343 p->spelling_size = spelling_size; 5344 p->top_level = constructor_top_level; 5345 p->next = initializer_stack; 5346 initializer_stack = p; 5347 5348 constructor_decl = decl; 5349 constructor_designated = 0; 5350 constructor_top_level = top_level; 5351 5352 if (decl != 0 && decl != error_mark_node) 5353 { 5354 require_constant_value = TREE_STATIC (decl); 5355 require_constant_elements 5356 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 5357 /* For a scalar, you can always use any value to initialize, 5358 even within braces. */ 5359 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 5360 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 5361 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 5362 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 5363 locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 5364 } 5365 else 5366 { 5367 require_constant_value = 0; 5368 require_constant_elements = 0; 5369 locus = "(anonymous)"; 5370 } 5371 5372 constructor_stack = 0; 5373 constructor_range_stack = 0; 5374 5375 missing_braces_mentioned = 0; 5376 5377 spelling_base = 0; 5378 spelling_size = 0; 5379 RESTORE_SPELLING_DEPTH (0); 5380 5381 if (locus) 5382 push_string (locus); 5383} 5384 5385void 5386finish_init (void) 5387{ 5388 struct initializer_stack *p = initializer_stack; 5389 5390 /* Free the whole constructor stack of this initializer. */ 5391 while (constructor_stack) 5392 { 5393 struct constructor_stack *q = constructor_stack; 5394 constructor_stack = q->next; 5395 free (q); 5396 } 5397 5398 gcc_assert (!constructor_range_stack); 5399 5400 /* Pop back to the data of the outer initializer (if any). */ 5401 free (spelling_base); 5402 5403 constructor_decl = p->decl; 5404 require_constant_value = p->require_constant_value; 5405 require_constant_elements = p->require_constant_elements; 5406 constructor_stack = p->constructor_stack; 5407 constructor_range_stack = p->constructor_range_stack; 5408 constructor_elements = p->elements; 5409 spelling = p->spelling; 5410 spelling_base = p->spelling_base; 5411 spelling_size = p->spelling_size; 5412 constructor_top_level = p->top_level; 5413 initializer_stack = p->next; 5414 free (p); 5415} 5416 5417/* Call here when we see the initializer is surrounded by braces. 5418 This is instead of a call to push_init_level; 5419 it is matched by a call to pop_init_level. 5420 5421 TYPE is the type to initialize, for a constructor expression. 5422 For an initializer for a decl, TYPE is zero. */ 5423 5424void 5425really_start_incremental_init (tree type) 5426{ 5427 struct constructor_stack *p = XNEW (struct constructor_stack); 5428 5429 if (type == 0) 5430 type = TREE_TYPE (constructor_decl); 5431 5432 if (targetm.vector_opaque_p (type)) 5433 error ("opaque vector types cannot be initialized"); 5434 5435 p->type = constructor_type; 5436 p->fields = constructor_fields; 5437 p->index = constructor_index; 5438 p->max_index = constructor_max_index; 5439 p->unfilled_index = constructor_unfilled_index; 5440 p->unfilled_fields = constructor_unfilled_fields; 5441 p->bit_index = constructor_bit_index; 5442 p->elements = constructor_elements; 5443 p->constant = constructor_constant; 5444 p->simple = constructor_simple; 5445 p->erroneous = constructor_erroneous; 5446 p->pending_elts = constructor_pending_elts; 5447 p->depth = constructor_depth; 5448 p->replacement_value.value = 0; 5449 p->replacement_value.original_code = ERROR_MARK; 5450 p->implicit = 0; 5451 p->range_stack = 0; 5452 p->outer = 0; 5453 p->incremental = constructor_incremental; 5454 p->designated = constructor_designated; 5455 p->next = 0; 5456 constructor_stack = p; 5457 5458 constructor_constant = 1; 5459 constructor_simple = 1; 5460 constructor_depth = SPELLING_DEPTH (); 5461 constructor_elements = 0; 5462 constructor_pending_elts = 0; 5463 constructor_type = type; 5464 constructor_incremental = 1; 5465 constructor_designated = 0; 5466 designator_depth = 0; 5467 designator_erroneous = 0; 5468 5469 if (TREE_CODE (constructor_type) == RECORD_TYPE 5470 || TREE_CODE (constructor_type) == UNION_TYPE) 5471 { 5472 constructor_fields = TYPE_FIELDS (constructor_type); 5473 /* Skip any nameless bit fields at the beginning. */ 5474 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5475 && DECL_NAME (constructor_fields) == 0) 5476 constructor_fields = TREE_CHAIN (constructor_fields); 5477 5478 constructor_unfilled_fields = constructor_fields; 5479 constructor_bit_index = bitsize_zero_node; 5480 } 5481 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5482 { 5483 if (TYPE_DOMAIN (constructor_type)) 5484 { 5485 constructor_max_index 5486 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5487 5488 /* Detect non-empty initializations of zero-length arrays. */ 5489 if (constructor_max_index == NULL_TREE 5490 && TYPE_SIZE (constructor_type)) 5491 constructor_max_index = build_int_cst (NULL_TREE, -1); 5492 5493 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5494 to initialize VLAs will cause a proper error; avoid tree 5495 checking errors as well by setting a safe value. */ 5496 if (constructor_max_index 5497 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5498 constructor_max_index = build_int_cst (NULL_TREE, -1); 5499 5500 constructor_index 5501 = convert (bitsizetype, 5502 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5503 } 5504 else 5505 { 5506 constructor_index = bitsize_zero_node; 5507 constructor_max_index = NULL_TREE; 5508 } 5509 5510 constructor_unfilled_index = constructor_index; 5511 } 5512 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 5513 { 5514 /* Vectors are like simple fixed-size arrays. */ 5515 constructor_max_index = 5516 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5517 constructor_index = bitsize_zero_node; 5518 constructor_unfilled_index = constructor_index; 5519 } 5520 else 5521 { 5522 /* Handle the case of int x = {5}; */ 5523 constructor_fields = constructor_type; 5524 constructor_unfilled_fields = constructor_type; 5525 } 5526} 5527 5528/* Push down into a subobject, for initialization. 5529 If this is for an explicit set of braces, IMPLICIT is 0. 5530 If it is because the next element belongs at a lower level, 5531 IMPLICIT is 1 (or 2 if the push is because of designator list). */ 5532 5533void 5534push_init_level (int implicit) 5535{ 5536 struct constructor_stack *p; 5537 tree value = NULL_TREE; 5538 5539 /* If we've exhausted any levels that didn't have braces, 5540 pop them now. If implicit == 1, this will have been done in 5541 process_init_element; do not repeat it here because in the case 5542 of excess initializers for an empty aggregate this leads to an 5543 infinite cycle of popping a level and immediately recreating 5544 it. */ 5545 if (implicit != 1) 5546 { 5547 while (constructor_stack->implicit) 5548 { 5549 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5550 || TREE_CODE (constructor_type) == UNION_TYPE) 5551 && constructor_fields == 0) 5552 process_init_element (pop_init_level (1)); 5553 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5554 && constructor_max_index 5555 && tree_int_cst_lt (constructor_max_index, 5556 constructor_index)) 5557 process_init_element (pop_init_level (1)); 5558 else 5559 break; 5560 } 5561 } 5562 5563 /* Unless this is an explicit brace, we need to preserve previous 5564 content if any. */ 5565 if (implicit) 5566 { 5567 if ((TREE_CODE (constructor_type) == RECORD_TYPE 5568 || TREE_CODE (constructor_type) == UNION_TYPE) 5569 && constructor_fields) 5570 value = find_init_member (constructor_fields); 5571 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5572 value = find_init_member (constructor_index); 5573 } 5574 5575 p = XNEW (struct constructor_stack); 5576 p->type = constructor_type; 5577 p->fields = constructor_fields; 5578 p->index = constructor_index; 5579 p->max_index = constructor_max_index; 5580 p->unfilled_index = constructor_unfilled_index; 5581 p->unfilled_fields = constructor_unfilled_fields; 5582 p->bit_index = constructor_bit_index; 5583 p->elements = constructor_elements; 5584 p->constant = constructor_constant; 5585 p->simple = constructor_simple; 5586 p->erroneous = constructor_erroneous; 5587 p->pending_elts = constructor_pending_elts; 5588 p->depth = constructor_depth; 5589 p->replacement_value.value = 0; 5590 p->replacement_value.original_code = ERROR_MARK; 5591 p->implicit = implicit; 5592 p->outer = 0; 5593 p->incremental = constructor_incremental; 5594 p->designated = constructor_designated; 5595 p->next = constructor_stack; 5596 p->range_stack = 0; 5597 constructor_stack = p; 5598 5599 constructor_constant = 1; 5600 constructor_simple = 1; 5601 constructor_depth = SPELLING_DEPTH (); 5602 constructor_elements = 0; 5603 constructor_incremental = 1; 5604 constructor_designated = 0; 5605 constructor_pending_elts = 0; 5606 if (!implicit) 5607 { 5608 p->range_stack = constructor_range_stack; 5609 constructor_range_stack = 0; 5610 designator_depth = 0; 5611 designator_erroneous = 0; 5612 } 5613 5614 /* Don't die if an entire brace-pair level is superfluous 5615 in the containing level. */ 5616 if (constructor_type == 0) 5617 ; 5618 else if (TREE_CODE (constructor_type) == RECORD_TYPE 5619 || TREE_CODE (constructor_type) == UNION_TYPE) 5620 { 5621 /* Don't die if there are extra init elts at the end. */ 5622 if (constructor_fields == 0) 5623 constructor_type = 0; 5624 else 5625 { 5626 constructor_type = TREE_TYPE (constructor_fields); 5627 push_member_name (constructor_fields); 5628 constructor_depth++; 5629 } 5630 } 5631 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5632 { 5633 constructor_type = TREE_TYPE (constructor_type); 5634 push_array_bounds (tree_low_cst (constructor_index, 1)); 5635 constructor_depth++; 5636 } 5637 5638 if (constructor_type == 0) 5639 { 5640 error_init ("extra brace group at end of initializer"); 5641 constructor_fields = 0; 5642 constructor_unfilled_fields = 0; 5643 return; 5644 } 5645 5646 if (value && TREE_CODE (value) == CONSTRUCTOR) 5647 { 5648 constructor_constant = TREE_CONSTANT (value); 5649 constructor_simple = TREE_STATIC (value); 5650 constructor_elements = CONSTRUCTOR_ELTS (value); 5651 if (!VEC_empty (constructor_elt, constructor_elements) 5652 && (TREE_CODE (constructor_type) == RECORD_TYPE 5653 || TREE_CODE (constructor_type) == ARRAY_TYPE)) 5654 set_nonincremental_init (); 5655 } 5656 5657 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 5658 { 5659 missing_braces_mentioned = 1; 5660 warning_init ("missing braces around initializer"); 5661 } 5662 5663 if (TREE_CODE (constructor_type) == RECORD_TYPE 5664 || TREE_CODE (constructor_type) == UNION_TYPE) 5665 { 5666 constructor_fields = TYPE_FIELDS (constructor_type); 5667 /* Skip any nameless bit fields at the beginning. */ 5668 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 5669 && DECL_NAME (constructor_fields) == 0) 5670 constructor_fields = TREE_CHAIN (constructor_fields); 5671 5672 constructor_unfilled_fields = constructor_fields; 5673 constructor_bit_index = bitsize_zero_node; 5674 } 5675 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 5676 { 5677 /* Vectors are like simple fixed-size arrays. */ 5678 constructor_max_index = 5679 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5680 constructor_index = convert (bitsizetype, integer_zero_node); 5681 constructor_unfilled_index = constructor_index; 5682 } 5683 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 5684 { 5685 if (TYPE_DOMAIN (constructor_type)) 5686 { 5687 constructor_max_index 5688 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 5689 5690 /* Detect non-empty initializations of zero-length arrays. */ 5691 if (constructor_max_index == NULL_TREE 5692 && TYPE_SIZE (constructor_type)) 5693 constructor_max_index = build_int_cst (NULL_TREE, -1); 5694 5695 /* constructor_max_index needs to be an INTEGER_CST. Attempts 5696 to initialize VLAs will cause a proper error; avoid tree 5697 checking errors as well by setting a safe value. */ 5698 if (constructor_max_index 5699 && TREE_CODE (constructor_max_index) != INTEGER_CST) 5700 constructor_max_index = build_int_cst (NULL_TREE, -1); 5701 5702 constructor_index 5703 = convert (bitsizetype, 5704 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 5705 } 5706 else 5707 constructor_index = bitsize_zero_node; 5708 5709 constructor_unfilled_index = constructor_index; 5710 if (value && TREE_CODE (value) == STRING_CST) 5711 { 5712 /* We need to split the char/wchar array into individual 5713 characters, so that we don't have to special case it 5714 everywhere. */ 5715 set_nonincremental_init_from_string (value); 5716 } 5717 } 5718 else 5719 { 5720 if (constructor_type != error_mark_node) 5721 warning_init ("braces around scalar initializer"); 5722 constructor_fields = constructor_type; 5723 constructor_unfilled_fields = constructor_type; 5724 } 5725} 5726 5727/* At the end of an implicit or explicit brace level, 5728 finish up that level of constructor. If a single expression 5729 with redundant braces initialized that level, return the 5730 c_expr structure for that expression. Otherwise, the original_code 5731 element is set to ERROR_MARK. 5732 If we were outputting the elements as they are read, return 0 as the value 5733 from inner levels (process_init_element ignores that), 5734 but return error_mark_node as the value from the outermost level 5735 (that's what we want to put in DECL_INITIAL). 5736 Otherwise, return a CONSTRUCTOR expression as the value. */ 5737 5738struct c_expr 5739pop_init_level (int implicit) 5740{ 5741 struct constructor_stack *p; 5742 struct c_expr ret; 5743 ret.value = 0; 5744 ret.original_code = ERROR_MARK; 5745 5746 if (implicit == 0) 5747 { 5748 /* When we come to an explicit close brace, 5749 pop any inner levels that didn't have explicit braces. */ 5750 while (constructor_stack->implicit) 5751 process_init_element (pop_init_level (1)); 5752 5753 gcc_assert (!constructor_range_stack); 5754 } 5755 5756 /* Now output all pending elements. */ 5757 constructor_incremental = 1; 5758 output_pending_init_elements (1); 5759 5760 p = constructor_stack; 5761 5762 /* Error for initializing a flexible array member, or a zero-length 5763 array member in an inappropriate context. */ 5764 if (constructor_type && constructor_fields 5765 && TREE_CODE (constructor_type) == ARRAY_TYPE 5766 && TYPE_DOMAIN (constructor_type) 5767 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 5768 { 5769 /* Silently discard empty initializations. The parser will 5770 already have pedwarned for empty brackets. */ 5771 if (integer_zerop (constructor_unfilled_index)) 5772 constructor_type = NULL_TREE; 5773 else 5774 { 5775 gcc_assert (!TYPE_SIZE (constructor_type)); 5776 5777 if (constructor_depth > 2) 5778 error_init ("initialization of flexible array member in a nested context"); 5779 else if (pedantic) 5780 pedwarn_init ("initialization of a flexible array member"); 5781 5782 /* We have already issued an error message for the existence 5783 of a flexible array member not at the end of the structure. 5784 Discard the initializer so that we do not die later. */ 5785 if (TREE_CHAIN (constructor_fields) != NULL_TREE) 5786 constructor_type = NULL_TREE; 5787 } 5788 } 5789 5790 /* Warn when some struct elements are implicitly initialized to zero. */ 5791 if (warn_missing_field_initializers 5792 && constructor_type 5793 && TREE_CODE (constructor_type) == RECORD_TYPE 5794 && constructor_unfilled_fields) 5795 { 5796 /* Do not warn for flexible array members or zero-length arrays. */ 5797 while (constructor_unfilled_fields 5798 && (!DECL_SIZE (constructor_unfilled_fields) 5799 || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 5800 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5801 5802 /* Do not warn if this level of the initializer uses member 5803 designators; it is likely to be deliberate. */ 5804 if (constructor_unfilled_fields && !constructor_designated) 5805 { 5806 push_member_name (constructor_unfilled_fields); 5807 warning_init ("missing initializer"); 5808 RESTORE_SPELLING_DEPTH (constructor_depth); 5809 } 5810 } 5811 5812 /* Pad out the end of the structure. */ 5813 if (p->replacement_value.value) 5814 /* If this closes a superfluous brace pair, 5815 just pass out the element between them. */ 5816 ret = p->replacement_value; 5817 else if (constructor_type == 0) 5818 ; 5819 else if (TREE_CODE (constructor_type) != RECORD_TYPE 5820 && TREE_CODE (constructor_type) != UNION_TYPE 5821 && TREE_CODE (constructor_type) != ARRAY_TYPE 5822 && TREE_CODE (constructor_type) != VECTOR_TYPE) 5823 { 5824 /* A nonincremental scalar initializer--just return 5825 the element, after verifying there is just one. */ 5826 if (VEC_empty (constructor_elt,constructor_elements)) 5827 { 5828 if (!constructor_erroneous) 5829 error_init ("empty scalar initializer"); 5830 ret.value = error_mark_node; 5831 } 5832 else if (VEC_length (constructor_elt,constructor_elements) != 1) 5833 { 5834 error_init ("extra elements in scalar initializer"); 5835 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 5836 } 5837 else 5838 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 5839 } 5840 else 5841 { 5842 if (constructor_erroneous) 5843 ret.value = error_mark_node; 5844 /* APPLE LOCAL begin radar 4188876 */ 5845 else if (!constructor_constant 5846 && TREE_CODE (constructor_type) == VECTOR_TYPE && constructor_decl 5847 && (TREE_CODE (TREE_TYPE (constructor_decl)) == RECORD_TYPE 5848 || TREE_CODE (TREE_TYPE (constructor_decl)) == UNION_TYPE)) 5849 { 5850 error ("Initializer is a non-const vector type"); 5851 ret.value = error_mark_node; 5852 } 5853 /* APPLE LOCAL end radar 4188876 */ 5854 else 5855 { 5856 ret.value = build_constructor (constructor_type, 5857 constructor_elements); 5858 if (constructor_constant) 5859 TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 5860 if (constructor_constant && constructor_simple) 5861 TREE_STATIC (ret.value) = 1; 5862 } 5863 } 5864 5865 constructor_type = p->type; 5866 constructor_fields = p->fields; 5867 constructor_index = p->index; 5868 constructor_max_index = p->max_index; 5869 constructor_unfilled_index = p->unfilled_index; 5870 constructor_unfilled_fields = p->unfilled_fields; 5871 constructor_bit_index = p->bit_index; 5872 constructor_elements = p->elements; 5873 constructor_constant = p->constant; 5874 constructor_simple = p->simple; 5875 constructor_erroneous = p->erroneous; 5876 constructor_incremental = p->incremental; 5877 constructor_designated = p->designated; 5878 constructor_pending_elts = p->pending_elts; 5879 constructor_depth = p->depth; 5880 if (!p->implicit) 5881 constructor_range_stack = p->range_stack; 5882 RESTORE_SPELLING_DEPTH (constructor_depth); 5883 5884 constructor_stack = p->next; 5885 free (p); 5886 5887 if (ret.value == 0 && constructor_stack == 0) 5888 ret.value = error_mark_node; 5889 return ret; 5890} 5891 5892/* Common handling for both array range and field name designators. 5893 ARRAY argument is nonzero for array ranges. Returns zero for success. */ 5894 5895static int 5896set_designator (int array) 5897{ 5898 tree subtype; 5899 enum tree_code subcode; 5900 5901 /* Don't die if an entire brace-pair level is superfluous 5902 in the containing level. */ 5903 if (constructor_type == 0) 5904 return 1; 5905 5906 /* If there were errors in this designator list already, bail out 5907 silently. */ 5908 if (designator_erroneous) 5909 return 1; 5910 5911 if (!designator_depth) 5912 { 5913 gcc_assert (!constructor_range_stack); 5914 5915 /* Designator list starts at the level of closest explicit 5916 braces. */ 5917 while (constructor_stack->implicit) 5918 process_init_element (pop_init_level (1)); 5919 constructor_designated = 1; 5920 return 0; 5921 } 5922 5923 switch (TREE_CODE (constructor_type)) 5924 { 5925 case RECORD_TYPE: 5926 case UNION_TYPE: 5927 subtype = TREE_TYPE (constructor_fields); 5928 if (subtype != error_mark_node) 5929 subtype = TYPE_MAIN_VARIANT (subtype); 5930 break; 5931 case ARRAY_TYPE: 5932 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5933 break; 5934 default: 5935 gcc_unreachable (); 5936 } 5937 5938 subcode = TREE_CODE (subtype); 5939 if (array && subcode != ARRAY_TYPE) 5940 { 5941 error_init ("array index in non-array initializer"); 5942 return 1; 5943 } 5944 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 5945 { 5946 error_init ("field name not in record or union initializer"); 5947 return 1; 5948 } 5949 5950 constructor_designated = 1; 5951 push_init_level (2); 5952 return 0; 5953} 5954 5955/* If there are range designators in designator list, push a new designator 5956 to constructor_range_stack. RANGE_END is end of such stack range or 5957 NULL_TREE if there is no range designator at this level. */ 5958 5959static void 5960push_range_stack (tree range_end) 5961{ 5962 struct constructor_range_stack *p; 5963 5964 p = GGC_NEW (struct constructor_range_stack); 5965 p->prev = constructor_range_stack; 5966 p->next = 0; 5967 p->fields = constructor_fields; 5968 p->range_start = constructor_index; 5969 p->index = constructor_index; 5970 p->stack = constructor_stack; 5971 p->range_end = range_end; 5972 if (constructor_range_stack) 5973 constructor_range_stack->next = p; 5974 constructor_range_stack = p; 5975} 5976 5977/* Within an array initializer, specify the next index to be initialized. 5978 FIRST is that index. If LAST is nonzero, then initialize a range 5979 of indices, running from FIRST through LAST. */ 5980 5981void 5982set_init_index (tree first, tree last) 5983{ 5984 if (set_designator (1)) 5985 return; 5986 5987 designator_erroneous = 1; 5988 5989 if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5990 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5991 { 5992 error_init ("array index in initializer not of integer type"); 5993 return; 5994 } 5995 5996 if (TREE_CODE (first) != INTEGER_CST) 5997 error_init ("nonconstant array index in initializer"); 5998 else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 5999 error_init ("nonconstant array index in initializer"); 6000 else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 6001 error_init ("array index in non-array initializer"); 6002 else if (tree_int_cst_sgn (first) == -1) 6003 error_init ("array index in initializer exceeds array bounds"); 6004 else if (constructor_max_index 6005 && tree_int_cst_lt (constructor_max_index, first)) 6006 error_init ("array index in initializer exceeds array bounds"); 6007 else 6008 { 6009 constructor_index = convert (bitsizetype, first); 6010 6011 if (last) 6012 { 6013 if (tree_int_cst_equal (first, last)) 6014 last = 0; 6015 else if (tree_int_cst_lt (last, first)) 6016 { 6017 error_init ("empty index range in initializer"); 6018 last = 0; 6019 } 6020 else 6021 { 6022 last = convert (bitsizetype, last); 6023 if (constructor_max_index != 0 6024 && tree_int_cst_lt (constructor_max_index, last)) 6025 { 6026 error_init ("array index range in initializer exceeds array bounds"); 6027 last = 0; 6028 } 6029 } 6030 } 6031 6032 designator_depth++; 6033 designator_erroneous = 0; 6034 if (constructor_range_stack || last) 6035 push_range_stack (last); 6036 } 6037} 6038 6039/* Within a struct initializer, specify the next field to be initialized. */ 6040 6041void 6042set_init_label (tree fieldname) 6043{ 6044 tree tail; 6045 6046 if (set_designator (0)) 6047 return; 6048 6049 designator_erroneous = 1; 6050 6051 if (TREE_CODE (constructor_type) != RECORD_TYPE 6052 && TREE_CODE (constructor_type) != UNION_TYPE) 6053 { 6054 error_init ("field name not in record or union initializer"); 6055 return; 6056 } 6057 6058 for (tail = TYPE_FIELDS (constructor_type); tail; 6059 tail = TREE_CHAIN (tail)) 6060 { 6061 if (DECL_NAME (tail) == fieldname) 6062 break; 6063 } 6064 6065 if (tail == 0) 6066 error ("unknown field %qE specified in initializer", fieldname); 6067 else 6068 { 6069 constructor_fields = tail; 6070 designator_depth++; 6071 designator_erroneous = 0; 6072 if (constructor_range_stack) 6073 push_range_stack (NULL_TREE); 6074 } 6075} 6076 6077/* Add a new initializer to the tree of pending initializers. PURPOSE 6078 identifies the initializer, either array index or field in a structure. 6079 VALUE is the value of that index or field. */ 6080 6081static void 6082add_pending_init (tree purpose, tree value) 6083{ 6084 struct init_node *p, **q, *r; 6085 6086 q = &constructor_pending_elts; 6087 p = 0; 6088 6089 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6090 { 6091 while (*q != 0) 6092 { 6093 p = *q; 6094 if (tree_int_cst_lt (purpose, p->purpose)) 6095 q = &p->left; 6096 else if (tree_int_cst_lt (p->purpose, purpose)) 6097 q = &p->right; 6098 else 6099 { 6100 if (TREE_SIDE_EFFECTS (p->value)) 6101 warning_init ("initialized field with side-effects overwritten"); 6102 else if (warn_override_init) 6103 warning_init ("initialized field overwritten"); 6104 p->value = value; 6105 return; 6106 } 6107 } 6108 } 6109 else 6110 { 6111 tree bitpos; 6112 6113 bitpos = bit_position (purpose); 6114 while (*q != NULL) 6115 { 6116 p = *q; 6117 if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 6118 q = &p->left; 6119 else if (p->purpose != purpose) 6120 q = &p->right; 6121 else 6122 { 6123 if (TREE_SIDE_EFFECTS (p->value)) 6124 warning_init ("initialized field with side-effects overwritten"); 6125 else if (warn_override_init) 6126 warning_init ("initialized field overwritten"); 6127 p->value = value; 6128 return; 6129 } 6130 } 6131 } 6132 6133 r = GGC_NEW (struct init_node); 6134 r->purpose = purpose; 6135 r->value = value; 6136 6137 *q = r; 6138 r->parent = p; 6139 r->left = 0; 6140 r->right = 0; 6141 r->balance = 0; 6142 6143 while (p) 6144 { 6145 struct init_node *s; 6146 6147 if (r == p->left) 6148 { 6149 if (p->balance == 0) 6150 p->balance = -1; 6151 else if (p->balance < 0) 6152 { 6153 if (r->balance < 0) 6154 { 6155 /* L rotation. */ 6156 p->left = r->right; 6157 if (p->left) 6158 p->left->parent = p; 6159 r->right = p; 6160 6161 p->balance = 0; 6162 r->balance = 0; 6163 6164 s = p->parent; 6165 p->parent = r; 6166 r->parent = s; 6167 if (s) 6168 { 6169 if (s->left == p) 6170 s->left = r; 6171 else 6172 s->right = r; 6173 } 6174 else 6175 constructor_pending_elts = r; 6176 } 6177 else 6178 { 6179 /* LR rotation. */ 6180 struct init_node *t = r->right; 6181 6182 r->right = t->left; 6183 if (r->right) 6184 r->right->parent = r; 6185 t->left = r; 6186 6187 p->left = t->right; 6188 if (p->left) 6189 p->left->parent = p; 6190 t->right = p; 6191 6192 p->balance = t->balance < 0; 6193 r->balance = -(t->balance > 0); 6194 t->balance = 0; 6195 6196 s = p->parent; 6197 p->parent = t; 6198 r->parent = t; 6199 t->parent = s; 6200 if (s) 6201 { 6202 if (s->left == p) 6203 s->left = t; 6204 else 6205 s->right = t; 6206 } 6207 else 6208 constructor_pending_elts = t; 6209 } 6210 break; 6211 } 6212 else 6213 { 6214 /* p->balance == +1; growth of left side balances the node. */ 6215 p->balance = 0; 6216 break; 6217 } 6218 } 6219 else /* r == p->right */ 6220 { 6221 if (p->balance == 0) 6222 /* Growth propagation from right side. */ 6223 p->balance++; 6224 else if (p->balance > 0) 6225 { 6226 if (r->balance > 0) 6227 { 6228 /* R rotation. */ 6229 p->right = r->left; 6230 if (p->right) 6231 p->right->parent = p; 6232 r->left = p; 6233 6234 p->balance = 0; 6235 r->balance = 0; 6236 6237 s = p->parent; 6238 p->parent = r; 6239 r->parent = s; 6240 if (s) 6241 { 6242 if (s->left == p) 6243 s->left = r; 6244 else 6245 s->right = r; 6246 } 6247 else 6248 constructor_pending_elts = r; 6249 } 6250 else /* r->balance == -1 */ 6251 { 6252 /* RL rotation */ 6253 struct init_node *t = r->left; 6254 6255 r->left = t->right; 6256 if (r->left) 6257 r->left->parent = r; 6258 t->right = r; 6259 6260 p->right = t->left; 6261 if (p->right) 6262 p->right->parent = p; 6263 t->left = p; 6264 6265 r->balance = (t->balance < 0); 6266 p->balance = -(t->balance > 0); 6267 t->balance = 0; 6268 6269 s = p->parent; 6270 p->parent = t; 6271 r->parent = t; 6272 t->parent = s; 6273 if (s) 6274 { 6275 if (s->left == p) 6276 s->left = t; 6277 else 6278 s->right = t; 6279 } 6280 else 6281 constructor_pending_elts = t; 6282 } 6283 break; 6284 } 6285 else 6286 { 6287 /* p->balance == -1; growth of right side balances the node. */ 6288 p->balance = 0; 6289 break; 6290 } 6291 } 6292 6293 r = p; 6294 p = p->parent; 6295 } 6296} 6297 6298/* Build AVL tree from a sorted chain. */ 6299 6300static void 6301set_nonincremental_init (void) 6302{ 6303 unsigned HOST_WIDE_INT ix; 6304 tree index, value; 6305 6306 if (TREE_CODE (constructor_type) != RECORD_TYPE 6307 && TREE_CODE (constructor_type) != ARRAY_TYPE) 6308 return; 6309 6310 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 6311 add_pending_init (index, value); 6312 constructor_elements = 0; 6313 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6314 { 6315 constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 6316 /* Skip any nameless bit fields at the beginning. */ 6317 while (constructor_unfilled_fields != 0 6318 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6319 && DECL_NAME (constructor_unfilled_fields) == 0) 6320 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 6321 6322 } 6323 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6324 { 6325 if (TYPE_DOMAIN (constructor_type)) 6326 constructor_unfilled_index 6327 = convert (bitsizetype, 6328 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 6329 else 6330 constructor_unfilled_index = bitsize_zero_node; 6331 } 6332 constructor_incremental = 0; 6333} 6334 6335/* Build AVL tree from a string constant. */ 6336 6337static void 6338set_nonincremental_init_from_string (tree str) 6339{ 6340 tree value, purpose, type; 6341 HOST_WIDE_INT val[2]; 6342 const char *p, *end; 6343 int byte, wchar_bytes, charwidth, bitpos; 6344 6345 gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 6346 6347 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6348 == TYPE_PRECISION (char_type_node)) 6349 wchar_bytes = 1; 6350 else 6351 { 6352 gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6353 == TYPE_PRECISION (wchar_type_node)); 6354 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6355 } 6356 charwidth = TYPE_PRECISION (char_type_node); 6357 type = TREE_TYPE (constructor_type); 6358 p = TREE_STRING_POINTER (str); 6359 end = p + TREE_STRING_LENGTH (str); 6360 6361 for (purpose = bitsize_zero_node; 6362 p < end && !tree_int_cst_lt (constructor_max_index, purpose); 6363 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 6364 { 6365 if (wchar_bytes == 1) 6366 { 6367 val[1] = (unsigned char) *p++; 6368 val[0] = 0; 6369 } 6370 else 6371 { 6372 val[0] = 0; 6373 val[1] = 0; 6374 for (byte = 0; byte < wchar_bytes; byte++) 6375 { 6376 if (BYTES_BIG_ENDIAN) 6377 bitpos = (wchar_bytes - byte - 1) * charwidth; 6378 else 6379 bitpos = byte * charwidth; 6380 val[bitpos < HOST_BITS_PER_WIDE_INT] 6381 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 6382 << (bitpos % HOST_BITS_PER_WIDE_INT); 6383 } 6384 } 6385 6386 if (!TYPE_UNSIGNED (type)) 6387 { 6388 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 6389 if (bitpos < HOST_BITS_PER_WIDE_INT) 6390 { 6391 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 6392 { 6393 val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 6394 val[0] = -1; 6395 } 6396 } 6397 else if (bitpos == HOST_BITS_PER_WIDE_INT) 6398 { 6399 if (val[1] < 0) 6400 val[0] = -1; 6401 } 6402 else if (val[0] & (((HOST_WIDE_INT) 1) 6403 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 6404 val[0] |= ((HOST_WIDE_INT) -1) 6405 << (bitpos - HOST_BITS_PER_WIDE_INT); 6406 } 6407 6408 value = build_int_cst_wide (type, val[1], val[0]); 6409 add_pending_init (purpose, value); 6410 } 6411 6412 constructor_incremental = 0; 6413} 6414 6415/* Return value of FIELD in pending initializer or zero if the field was 6416 not initialized yet. */ 6417 6418static tree 6419find_init_member (tree field) 6420{ 6421 struct init_node *p; 6422 6423 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6424 { 6425 if (constructor_incremental 6426 && tree_int_cst_lt (field, constructor_unfilled_index)) 6427 set_nonincremental_init (); 6428 6429 p = constructor_pending_elts; 6430 while (p) 6431 { 6432 if (tree_int_cst_lt (field, p->purpose)) 6433 p = p->left; 6434 else if (tree_int_cst_lt (p->purpose, field)) 6435 p = p->right; 6436 else 6437 return p->value; 6438 } 6439 } 6440 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6441 { 6442 tree bitpos = bit_position (field); 6443 6444 if (constructor_incremental 6445 && (!constructor_unfilled_fields 6446 || tree_int_cst_lt (bitpos, 6447 bit_position (constructor_unfilled_fields)))) 6448 set_nonincremental_init (); 6449 6450 p = constructor_pending_elts; 6451 while (p) 6452 { 6453 if (field == p->purpose) 6454 return p->value; 6455 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 6456 p = p->left; 6457 else 6458 p = p->right; 6459 } 6460 } 6461 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6462 { 6463 if (!VEC_empty (constructor_elt, constructor_elements) 6464 && (VEC_last (constructor_elt, constructor_elements)->index 6465 == field)) 6466 return VEC_last (constructor_elt, constructor_elements)->value; 6467 } 6468 return 0; 6469} 6470 6471/* "Output" the next constructor element. 6472 At top level, really output it to assembler code now. 6473 Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 6474 TYPE is the data type that the containing data type wants here. 6475 FIELD is the field (a FIELD_DECL) or the index that this element fills. 6476 If VALUE is a string constant, STRICT_STRING is true if it is 6477 unparenthesized or we should not warn here for it being parenthesized. 6478 For other types of VALUE, STRICT_STRING is not used. 6479 6480 PENDING if non-nil means output pending elements that belong 6481 right after this element. (PENDING is normally 1; 6482 it is 0 while outputting pending elements, to avoid recursion.) */ 6483 6484static void 6485output_init_element (tree value, bool strict_string, tree type, tree field, 6486 int pending) 6487{ 6488 constructor_elt *celt; 6489 6490 if (type == error_mark_node || value == error_mark_node) 6491 { 6492 constructor_erroneous = 1; 6493 return; 6494 } 6495 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6496 && (TREE_CODE (value) == STRING_CST 6497 || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6498 && !(TREE_CODE (value) == STRING_CST 6499 && TREE_CODE (type) == ARRAY_TYPE 6500 && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6501 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6502 TYPE_MAIN_VARIANT (type))) 6503 value = array_to_pointer_conversion (value); 6504 6505 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 6506 && require_constant_value && !flag_isoc99 && pending) 6507 { 6508 /* As an extension, allow initializing objects with static storage 6509 duration with compound literals (which are then treated just as 6510 the brace enclosed list they contain). */ 6511 tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 6512 value = DECL_INITIAL (decl); 6513 } 6514 6515 if (value == error_mark_node) 6516 constructor_erroneous = 1; 6517 else if (!TREE_CONSTANT (value)) 6518 constructor_constant = 0; 6519 else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 6520 || ((TREE_CODE (constructor_type) == RECORD_TYPE 6521 || TREE_CODE (constructor_type) == UNION_TYPE) 6522 && DECL_C_BIT_FIELD (field) 6523 && TREE_CODE (value) != INTEGER_CST)) 6524 constructor_simple = 0; 6525 6526 if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 6527 { 6528 if (require_constant_value) 6529 { 6530 error_init ("initializer element is not constant"); 6531 value = error_mark_node; 6532 } 6533 else if (require_constant_elements) 6534 pedwarn ("initializer element is not computable at load time"); 6535 } 6536 6537 /* If this field is empty (and not at the end of structure), 6538 don't do anything other than checking the initializer. */ 6539 if (field 6540 && (TREE_TYPE (field) == error_mark_node 6541 || (COMPLETE_TYPE_P (TREE_TYPE (field)) 6542 && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 6543 && (TREE_CODE (constructor_type) == ARRAY_TYPE 6544 || TREE_CHAIN (field))))) 6545 return; 6546 6547 value = digest_init (type, value, strict_string, require_constant_value); 6548 if (value == error_mark_node) 6549 { 6550 constructor_erroneous = 1; 6551 return; 6552 } 6553 6554 /* If this element doesn't come next in sequence, 6555 put it on constructor_pending_elts. */ 6556 if (TREE_CODE (constructor_type) == ARRAY_TYPE 6557 && (!constructor_incremental 6558 || !tree_int_cst_equal (field, constructor_unfilled_index))) 6559 { 6560 if (constructor_incremental 6561 && tree_int_cst_lt (field, constructor_unfilled_index)) 6562 set_nonincremental_init (); 6563 6564 add_pending_init (field, value); 6565 return; 6566 } 6567 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6568 && (!constructor_incremental 6569 || field != constructor_unfilled_fields)) 6570 { 6571 /* We do this for records but not for unions. In a union, 6572 no matter which field is specified, it can be initialized 6573 right away since it starts at the beginning of the union. */ 6574 if (constructor_incremental) 6575 { 6576 if (!constructor_unfilled_fields) 6577 set_nonincremental_init (); 6578 else 6579 { 6580 tree bitpos, unfillpos; 6581 6582 bitpos = bit_position (field); 6583 unfillpos = bit_position (constructor_unfilled_fields); 6584 6585 if (tree_int_cst_lt (bitpos, unfillpos)) 6586 set_nonincremental_init (); 6587 } 6588 } 6589 6590 add_pending_init (field, value); 6591 return; 6592 } 6593 else if (TREE_CODE (constructor_type) == UNION_TYPE 6594 && !VEC_empty (constructor_elt, constructor_elements)) 6595 { 6596 if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6597 constructor_elements)->value)) 6598 warning_init ("initialized field with side-effects overwritten"); 6599 else if (warn_override_init) 6600 warning_init ("initialized field overwritten"); 6601 6602 /* We can have just one union field set. */ 6603 constructor_elements = 0; 6604 } 6605 6606 /* Otherwise, output this element either to 6607 constructor_elements or to the assembler file. */ 6608 6609 celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6610 celt->index = field; 6611 celt->value = value; 6612 6613 /* Advance the variable that indicates sequential elements output. */ 6614 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6615 constructor_unfilled_index 6616 = size_binop (PLUS_EXPR, constructor_unfilled_index, 6617 bitsize_one_node); 6618 else if (TREE_CODE (constructor_type) == RECORD_TYPE) 6619 { 6620 constructor_unfilled_fields 6621 = TREE_CHAIN (constructor_unfilled_fields); 6622 6623 /* Skip any nameless bit fields. */ 6624 while (constructor_unfilled_fields != 0 6625 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6626 && DECL_NAME (constructor_unfilled_fields) == 0) 6627 constructor_unfilled_fields = 6628 TREE_CHAIN (constructor_unfilled_fields); 6629 } 6630 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6631 constructor_unfilled_fields = 0; 6632 6633 /* Now output any pending elements which have become next. */ 6634 if (pending) 6635 output_pending_init_elements (0); 6636} 6637 6638/* Output any pending elements which have become next. 6639 As we output elements, constructor_unfilled_{fields,index} 6640 advances, which may cause other elements to become next; 6641 if so, they too are output. 6642 6643 If ALL is 0, we return when there are 6644 no more pending elements to output now. 6645 6646 If ALL is 1, we output space as necessary so that 6647 we can output all the pending elements. */ 6648 6649static void 6650output_pending_init_elements (int all) 6651{ 6652 struct init_node *elt = constructor_pending_elts; 6653 tree next; 6654 6655 retry: 6656 6657 /* Look through the whole pending tree. 6658 If we find an element that should be output now, 6659 output it. Otherwise, set NEXT to the element 6660 that comes first among those still pending. */ 6661 6662 next = 0; 6663 while (elt) 6664 { 6665 if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6666 { 6667 if (tree_int_cst_equal (elt->purpose, 6668 constructor_unfilled_index)) 6669 output_init_element (elt->value, true, 6670 TREE_TYPE (constructor_type), 6671 constructor_unfilled_index, 0); 6672 else if (tree_int_cst_lt (constructor_unfilled_index, 6673 elt->purpose)) 6674 { 6675 /* Advance to the next smaller node. */ 6676 if (elt->left) 6677 elt = elt->left; 6678 else 6679 { 6680 /* We have reached the smallest node bigger than the 6681 current unfilled index. Fill the space first. */ 6682 next = elt->purpose; 6683 break; 6684 } 6685 } 6686 else 6687 { 6688 /* Advance to the next bigger node. */ 6689 if (elt->right) 6690 elt = elt->right; 6691 else 6692 { 6693 /* We have reached the biggest node in a subtree. Find 6694 the parent of it, which is the next bigger node. */ 6695 while (elt->parent && elt->parent->right == elt) 6696 elt = elt->parent; 6697 elt = elt->parent; 6698 if (elt && tree_int_cst_lt (constructor_unfilled_index, 6699 elt->purpose)) 6700 { 6701 next = elt->purpose; 6702 break; 6703 } 6704 } 6705 } 6706 } 6707 else if (TREE_CODE (constructor_type) == RECORD_TYPE 6708 || TREE_CODE (constructor_type) == UNION_TYPE) 6709 { 6710 tree ctor_unfilled_bitpos, elt_bitpos; 6711 6712 /* If the current record is complete we are done. */ 6713 if (constructor_unfilled_fields == 0) 6714 break; 6715 6716 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 6717 elt_bitpos = bit_position (elt->purpose); 6718 /* We can't compare fields here because there might be empty 6719 fields in between. */ 6720 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 6721 { 6722 constructor_unfilled_fields = elt->purpose; 6723 output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 6724 elt->purpose, 0); 6725 } 6726 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 6727 { 6728 /* Advance to the next smaller node. */ 6729 if (elt->left) 6730 elt = elt->left; 6731 else 6732 { 6733 /* We have reached the smallest node bigger than the 6734 current unfilled field. Fill the space first. */ 6735 next = elt->purpose; 6736 break; 6737 } 6738 } 6739 else 6740 { 6741 /* Advance to the next bigger node. */ 6742 if (elt->right) 6743 elt = elt->right; 6744 else 6745 { 6746 /* We have reached the biggest node in a subtree. Find 6747 the parent of it, which is the next bigger node. */ 6748 while (elt->parent && elt->parent->right == elt) 6749 elt = elt->parent; 6750 elt = elt->parent; 6751 if (elt 6752 && (tree_int_cst_lt (ctor_unfilled_bitpos, 6753 bit_position (elt->purpose)))) 6754 { 6755 next = elt->purpose; 6756 break; 6757 } 6758 } 6759 } 6760 } 6761 } 6762 6763 /* Ordinarily return, but not if we want to output all 6764 and there are elements left. */ 6765 if (!(all && next != 0)) 6766 return; 6767 6768 /* If it's not incremental, just skip over the gap, so that after 6769 jumping to retry we will output the next successive element. */ 6770 if (TREE_CODE (constructor_type) == RECORD_TYPE 6771 || TREE_CODE (constructor_type) == UNION_TYPE) 6772 constructor_unfilled_fields = next; 6773 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 6774 constructor_unfilled_index = next; 6775 6776 /* ELT now points to the node in the pending tree with the next 6777 initializer to output. */ 6778 goto retry; 6779} 6780 6781/* Add one non-braced element to the current constructor level. 6782 This adjusts the current position within the constructor's type. 6783 This may also start or terminate implicit levels 6784 to handle a partly-braced initializer. 6785 6786 Once this has found the correct level for the new element, 6787 it calls output_init_element. */ 6788 6789void 6790process_init_element (struct c_expr value) 6791{ 6792 tree orig_value = value.value; 6793 int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6794 bool strict_string = value.original_code == STRING_CST; 6795 6796 designator_depth = 0; 6797 designator_erroneous = 0; 6798 6799 /* Handle superfluous braces around string cst as in 6800 char x[] = {"foo"}; */ 6801 if (string_flag 6802 && constructor_type 6803 && TREE_CODE (constructor_type) == ARRAY_TYPE 6804 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 6805 && integer_zerop (constructor_unfilled_index)) 6806 { 6807 if (constructor_stack->replacement_value.value) 6808 error_init ("excess elements in char array initializer"); 6809 constructor_stack->replacement_value = value; 6810 return; 6811 } 6812 6813 if (constructor_stack->replacement_value.value != 0) 6814 { 6815 error_init ("excess elements in struct initializer"); 6816 return; 6817 } 6818 6819 /* Ignore elements of a brace group if it is entirely superfluous 6820 and has already been diagnosed. */ 6821 if (constructor_type == 0) 6822 return; 6823 6824 /* If we've exhausted any levels that didn't have braces, 6825 pop them now. */ 6826 while (constructor_stack->implicit) 6827 { 6828 if ((TREE_CODE (constructor_type) == RECORD_TYPE 6829 || TREE_CODE (constructor_type) == UNION_TYPE) 6830 && constructor_fields == 0) 6831 process_init_element (pop_init_level (1)); 6832 else if (TREE_CODE (constructor_type) == ARRAY_TYPE 6833 && (constructor_max_index == 0 6834 || tree_int_cst_lt (constructor_max_index, 6835 constructor_index))) 6836 process_init_element (pop_init_level (1)); 6837 else 6838 break; 6839 } 6840 6841 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 6842 if (constructor_range_stack) 6843 { 6844 /* If value is a compound literal and we'll be just using its 6845 content, don't put it into a SAVE_EXPR. */ 6846 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 6847 || !require_constant_value 6848 || flag_isoc99) 6849 value.value = save_expr (value.value); 6850 } 6851 6852 while (1) 6853 { 6854 if (TREE_CODE (constructor_type) == RECORD_TYPE) 6855 { 6856 tree fieldtype; 6857 enum tree_code fieldcode; 6858 6859 if (constructor_fields == 0) 6860 { 6861 pedwarn_init ("excess elements in struct initializer"); 6862 break; 6863 } 6864 6865 fieldtype = TREE_TYPE (constructor_fields); 6866 if (fieldtype != error_mark_node) 6867 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6868 fieldcode = TREE_CODE (fieldtype); 6869 6870 /* Error for non-static initialization of a flexible array member. */ 6871 if (fieldcode == ARRAY_TYPE 6872 && !require_constant_value 6873 && TYPE_SIZE (fieldtype) == NULL_TREE 6874 && TREE_CHAIN (constructor_fields) == NULL_TREE) 6875 { 6876 error_init ("non-static initialization of a flexible array member"); 6877 break; 6878 } 6879 6880 /* Accept a string constant to initialize a subarray. */ 6881 if (value.value != 0 6882 && fieldcode == ARRAY_TYPE 6883 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 6884 && string_flag) 6885 value.value = orig_value; 6886 /* Otherwise, if we have come to a subaggregate, 6887 and we don't have an element of its type, push into it. */ 6888 else if (value.value != 0 6889 && value.value != error_mark_node 6890 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 6891 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6892 || fieldcode == UNION_TYPE)) 6893 { 6894 push_init_level (1); 6895 continue; 6896 } 6897 6898 if (value.value) 6899 { 6900 push_member_name (constructor_fields); 6901 output_init_element (value.value, strict_string, 6902 fieldtype, constructor_fields, 1); 6903 RESTORE_SPELLING_DEPTH (constructor_depth); 6904 } 6905 else 6906 /* Do the bookkeeping for an element that was 6907 directly output as a constructor. */ 6908 { 6909 /* For a record, keep track of end position of last field. */ 6910 if (DECL_SIZE (constructor_fields)) 6911 constructor_bit_index 6912 = size_binop (PLUS_EXPR, 6913 bit_position (constructor_fields), 6914 DECL_SIZE (constructor_fields)); 6915 6916 /* If the current field was the first one not yet written out, 6917 it isn't now, so update. */ 6918 if (constructor_unfilled_fields == constructor_fields) 6919 { 6920 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6921 /* Skip any nameless bit fields. */ 6922 while (constructor_unfilled_fields != 0 6923 && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6924 && DECL_NAME (constructor_unfilled_fields) == 0) 6925 constructor_unfilled_fields = 6926 TREE_CHAIN (constructor_unfilled_fields); 6927 } 6928 } 6929 6930 constructor_fields = TREE_CHAIN (constructor_fields); 6931 /* Skip any nameless bit fields at the beginning. */ 6932 while (constructor_fields != 0 6933 && DECL_C_BIT_FIELD (constructor_fields) 6934 && DECL_NAME (constructor_fields) == 0) 6935 constructor_fields = TREE_CHAIN (constructor_fields); 6936 } 6937 else if (TREE_CODE (constructor_type) == UNION_TYPE) 6938 { 6939 tree fieldtype; 6940 enum tree_code fieldcode; 6941 6942 if (constructor_fields == 0) 6943 { 6944 pedwarn_init ("excess elements in union initializer"); 6945 break; 6946 } 6947 6948 fieldtype = TREE_TYPE (constructor_fields); 6949 if (fieldtype != error_mark_node) 6950 fieldtype = TYPE_MAIN_VARIANT (fieldtype); 6951 fieldcode = TREE_CODE (fieldtype); 6952 6953 /* Warn that traditional C rejects initialization of unions. 6954 We skip the warning if the value is zero. This is done 6955 under the assumption that the zero initializer in user 6956 code appears conditioned on e.g. __STDC__ to avoid 6957 "missing initializer" warnings and relies on default 6958 initialization to zero in the traditional C case. 6959 We also skip the warning if the initializer is designated, 6960 again on the assumption that this must be conditional on 6961 __STDC__ anyway (and we've already complained about the 6962 member-designator already). */ 6963 if (!in_system_header && !constructor_designated 6964 && !(value.value && (integer_zerop (value.value) 6965 || real_zerop (value.value)))) 6966 warning (OPT_Wtraditional, "traditional C rejects initialization " 6967 "of unions"); 6968 6969 /* Accept a string constant to initialize a subarray. */ 6970 if (value.value != 0 6971 && fieldcode == ARRAY_TYPE 6972 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 6973 && string_flag) 6974 value.value = orig_value; 6975 /* Otherwise, if we have come to a subaggregate, 6976 and we don't have an element of its type, push into it. */ 6977 else if (value.value != 0 6978 && value.value != error_mark_node 6979 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 6980 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 6981 || fieldcode == UNION_TYPE)) 6982 { 6983 push_init_level (1); 6984 continue; 6985 } 6986 6987 if (value.value) 6988 { 6989 push_member_name (constructor_fields); 6990 output_init_element (value.value, strict_string, 6991 fieldtype, constructor_fields, 1); 6992 RESTORE_SPELLING_DEPTH (constructor_depth); 6993 } 6994 else 6995 /* Do the bookkeeping for an element that was 6996 directly output as a constructor. */ 6997 { 6998 constructor_bit_index = DECL_SIZE (constructor_fields); 6999 constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 7000 } 7001 7002 constructor_fields = 0; 7003 } 7004 else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 7005 { 7006 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 7007 enum tree_code eltcode = TREE_CODE (elttype); 7008 7009 /* Accept a string constant to initialize a subarray. */ 7010 if (value.value != 0 7011 && eltcode == ARRAY_TYPE 7012 && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 7013 && string_flag) 7014 value.value = orig_value; 7015 /* Otherwise, if we have come to a subaggregate, 7016 and we don't have an element of its type, push into it. */ 7017 else if (value.value != 0 7018 && value.value != error_mark_node 7019 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 7020 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 7021 || eltcode == UNION_TYPE)) 7022 { 7023 push_init_level (1); 7024 continue; 7025 } 7026 7027 if (constructor_max_index != 0 7028 && (tree_int_cst_lt (constructor_max_index, constructor_index) 7029 || integer_all_onesp (constructor_max_index))) 7030 { 7031 pedwarn_init ("excess elements in array initializer"); 7032 break; 7033 } 7034 7035 /* Now output the actual element. */ 7036 if (value.value) 7037 { 7038 push_array_bounds (tree_low_cst (constructor_index, 1)); 7039 output_init_element (value.value, strict_string, 7040 elttype, constructor_index, 1); 7041 RESTORE_SPELLING_DEPTH (constructor_depth); 7042 } 7043 7044 constructor_index 7045 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 7046 7047 if (!value.value) 7048 /* If we are doing the bookkeeping for an element that was 7049 directly output as a constructor, we must update 7050 constructor_unfilled_index. */ 7051 constructor_unfilled_index = constructor_index; 7052 } 7053 else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 7054 { 7055 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 7056 7057 /* Do a basic check of initializer size. Note that vectors 7058 always have a fixed size derived from their type. */ 7059 if (tree_int_cst_lt (constructor_max_index, constructor_index)) 7060 { 7061 pedwarn_init ("excess elements in vector initializer"); 7062 break; 7063 } 7064 7065 /* Now output the actual element. */ 7066 if (value.value) 7067 output_init_element (value.value, strict_string, 7068 elttype, constructor_index, 1); 7069 7070 constructor_index 7071 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 7072 7073 if (!value.value) 7074 /* If we are doing the bookkeeping for an element that was 7075 directly output as a constructor, we must update 7076 constructor_unfilled_index. */ 7077 constructor_unfilled_index = constructor_index; 7078 } 7079 7080 /* Handle the sole element allowed in a braced initializer 7081 for a scalar variable. */ 7082 else if (constructor_type != error_mark_node 7083 && constructor_fields == 0) 7084 { 7085 pedwarn_init ("excess elements in scalar initializer"); 7086 break; 7087 } 7088 else 7089 { 7090 if (value.value) 7091 output_init_element (value.value, strict_string, 7092 constructor_type, NULL_TREE, 1); 7093 constructor_fields = 0; 7094 } 7095 7096 /* Handle range initializers either at this level or anywhere higher 7097 in the designator stack. */ 7098 if (constructor_range_stack) 7099 { 7100 struct constructor_range_stack *p, *range_stack; 7101 int finish = 0; 7102 7103 range_stack = constructor_range_stack; 7104 constructor_range_stack = 0; 7105 while (constructor_stack != range_stack->stack) 7106 { 7107 gcc_assert (constructor_stack->implicit); 7108 process_init_element (pop_init_level (1)); 7109 } 7110 for (p = range_stack; 7111 !p->range_end || tree_int_cst_equal (p->index, p->range_end); 7112 p = p->prev) 7113 { 7114 gcc_assert (constructor_stack->implicit); 7115 process_init_element (pop_init_level (1)); 7116 } 7117 7118 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 7119 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 7120 finish = 1; 7121 7122 while (1) 7123 { 7124 constructor_index = p->index; 7125 constructor_fields = p->fields; 7126 if (finish && p->range_end && p->index == p->range_start) 7127 { 7128 finish = 0; 7129 p->prev = 0; 7130 } 7131 p = p->next; 7132 if (!p) 7133 break; 7134 push_init_level (2); 7135 p->stack = constructor_stack; 7136 if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 7137 p->index = p->range_start; 7138 } 7139 7140 if (!finish) 7141 constructor_range_stack = range_stack; 7142 continue; 7143 } 7144 7145 break; 7146 } 7147 7148 constructor_range_stack = 0; 7149} 7150 7151/* Build a complete asm-statement, whose components are a CV_QUALIFIER 7152 (guaranteed to be 'volatile' or null) and ARGS (represented using 7153 an ASM_EXPR node). */ 7154tree 7155build_asm_stmt (tree cv_qualifier, tree args) 7156{ 7157 if (!ASM_VOLATILE_P (args) && cv_qualifier) 7158 ASM_VOLATILE_P (args) = 1; 7159 return add_stmt (args); 7160} 7161 7162/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 7163 some INPUTS, and some CLOBBERS. The latter three may be NULL. 7164 SIMPLE indicates whether there was anything at all after the 7165 string in the asm expression -- asm("blah") and asm("blah" : ) 7166 are subtly different. We use a ASM_EXPR node to represent this. */ 7167tree 7168build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 7169 bool simple) 7170{ 7171 tree tail; 7172 tree args; 7173 int i; 7174 const char *constraint; 7175 const char **oconstraints; 7176 bool allows_mem, allows_reg, is_inout; 7177 int ninputs, noutputs; 7178 7179 ninputs = list_length (inputs); 7180 noutputs = list_length (outputs); 7181 oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 7182 7183 string = resolve_asm_operand_names (string, outputs, inputs); 7184 7185 /* Remove output conversions that change the type but not the mode. */ 7186 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 7187 { 7188 tree output = TREE_VALUE (tail); 7189 7190 /* ??? Really, this should not be here. Users should be using a 7191 proper lvalue, dammit. But there's a long history of using casts 7192 in the output operands. In cases like longlong.h, this becomes a 7193 primitive form of typechecking -- if the cast can be removed, then 7194 the output operand had a type of the proper width; otherwise we'll 7195 get an error. Gross, but ... */ 7196 STRIP_NOPS (output); 7197 7198 if (!lvalue_or_else (output, lv_asm)) 7199 output = error_mark_node; 7200 7201 if (output != error_mark_node 7202 && (TREE_READONLY (output) 7203 || TYPE_READONLY (TREE_TYPE (output)) 7204 || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 7205 || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 7206 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 7207 readonly_error (output, lv_asm); 7208 7209 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 7210 oconstraints[i] = constraint; 7211 7212 if (parse_output_constraint (&constraint, i, ninputs, noutputs, 7213 &allows_mem, &allows_reg, &is_inout)) 7214 { 7215 /* If the operand is going to end up in memory, 7216 mark it addressable. */ 7217 if (!allows_reg && !c_mark_addressable (output)) 7218 output = error_mark_node; 7219 } 7220 else 7221 output = error_mark_node; 7222 7223 TREE_VALUE (tail) = output; 7224 } 7225 7226 for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 7227 { 7228 tree input; 7229 7230 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 7231 input = TREE_VALUE (tail); 7232 7233 if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 7234 oconstraints, &allows_mem, &allows_reg)) 7235 { 7236 /* If the operand is going to end up in memory, 7237 mark it addressable. */ 7238 if (!allows_reg && allows_mem) 7239 { 7240 /* Strip the nops as we allow this case. FIXME, this really 7241 should be rejected or made deprecated. */ 7242 STRIP_NOPS (input); 7243 if (!c_mark_addressable (input)) 7244 input = error_mark_node; 7245 } 7246 } 7247 else 7248 input = error_mark_node; 7249 7250 TREE_VALUE (tail) = input; 7251 } 7252 7253 args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 7254 7255 /* asm statements without outputs, including simple ones, are treated 7256 as volatile. */ 7257 ASM_INPUT_P (args) = simple; 7258 ASM_VOLATILE_P (args) = (noutputs == 0); 7259 7260 return args; 7261} 7262 7263/* Generate a goto statement to LABEL. */ 7264 7265tree 7266c_finish_goto_label (tree label) 7267{ 7268 tree decl = lookup_label (label); 7269 if (!decl) 7270 return NULL_TREE; 7271 7272 if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 7273 { 7274 error ("jump into statement expression"); 7275 return NULL_TREE; 7276 } 7277 7278 if (C_DECL_UNJUMPABLE_VM (decl)) 7279 { 7280 error ("jump into scope of identifier with variably modified type"); 7281 return NULL_TREE; 7282 } 7283 7284 if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 7285 { 7286 /* No jump from outside this statement expression context, so 7287 record that there is a jump from within this context. */ 7288 struct c_label_list *nlist; 7289 nlist = XOBNEW (&parser_obstack, struct c_label_list); 7290 nlist->next = label_context_stack_se->labels_used; 7291 nlist->label = decl; 7292 label_context_stack_se->labels_used = nlist; 7293 } 7294 7295 if (!C_DECL_UNDEFINABLE_VM (decl)) 7296 { 7297 /* No jump from outside this context context of identifiers with 7298 variably modified type, so record that there is a jump from 7299 within this context. */ 7300 struct c_label_list *nlist; 7301 nlist = XOBNEW (&parser_obstack, struct c_label_list); 7302 nlist->next = label_context_stack_vm->labels_used; 7303 nlist->label = decl; 7304 label_context_stack_vm->labels_used = nlist; 7305 } 7306 7307 TREE_USED (decl) = 1; 7308 return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 7309} 7310 7311/* Generate a computed goto statement to EXPR. */ 7312 7313tree 7314c_finish_goto_ptr (tree expr) 7315{ 7316 if (pedantic) 7317 pedwarn ("ISO C forbids %<goto *expr;%>"); 7318 expr = convert (ptr_type_node, expr); 7319 return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 7320} 7321 7322/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 7323/** c_finish_block_return_stmt - Utilty routine to figure out block's return 7324 type. 7325 */ 7326static tree 7327c_finish_block_return_stmt (tree retval) 7328{ 7329 tree valtype; 7330 /* If this is the first return we've seen in the block, infer the type of 7331 the block from it. */ 7332 if (cur_block->return_type == NULL_TREE) 7333 { 7334 tree restype; 7335 if (retval) 7336 { 7337 restype = TYPE_MAIN_VARIANT (TREE_TYPE (retval)); 7338 TREE_TYPE (current_function_decl) 7339 = build_function_type (restype, 7340 TYPE_ARG_TYPES (TREE_TYPE (current_function_decl))); 7341 TREE_TYPE (DECL_RESULT (current_function_decl)) = restype; 7342 relayout_decl (DECL_RESULT (current_function_decl)); 7343 } 7344 else 7345 restype = void_type_node; 7346 7347 cur_block->return_type = restype; 7348 } 7349 7350 /* Verify that this result type matches the previous one. We are 7351 pickier with blocks than for normal functions because this is a 7352 new feature and we set the rules. */ 7353 if (TREE_CODE (cur_block->return_type) == VOID_TYPE) 7354 { 7355 if (retval) 7356 { 7357 error ("void block should not return a value"); 7358 retval = NULL_TREE; 7359 } 7360 return retval; 7361 } 7362 7363 if (!retval) 7364 { 7365 error ("non-void block should return a value"); 7366 return error_mark_node; 7367 } 7368 7369 /* We have a non-void block with an expression, continue checking. */ 7370 valtype = TREE_TYPE (retval); 7371 7372 /* For now, restrict multiple return statements in a block to have 7373 strict compatible types only. */ 7374 if (!types_are_block_compatible (cur_block->return_type, valtype)) 7375 error ("incompatible type returning %qT, expected %qT", 7376 valtype, cur_block->return_type); 7377 return retval; 7378} 7379/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 7380 7381/* Generate a C `return' statement. RETVAL is the expression for what 7382 to return, or a null pointer for `return;' with no value. */ 7383 7384tree 7385c_finish_return (tree retval) 7386{ 7387 /* APPLE LOCAL begin radar 5732232 - blocks */ 7388 tree valtype, ret_stmt; 7389 bool no_warning = false; 7390 7391 /* APPLE LOCAL radar 5822844 - radar 6185344 */ 7392 if (cur_block && !cur_block->block_has_return_type) 7393 { 7394 retval = c_finish_block_return_stmt (retval); 7395 if (retval == error_mark_node) 7396 return NULL_TREE; 7397 } 7398 7399 valtype = TREE_TYPE (TREE_TYPE (current_function_decl)); 7400 /* APPLE LOCAL end radar 5732232 - blocks */ 7401 7402 if (TREE_THIS_VOLATILE (current_function_decl)) 7403 warning (0, "function declared %<noreturn%> has a %<return%> statement"); 7404 7405 if (!retval) 7406 { 7407 current_function_returns_null = 1; 7408 if ((warn_return_type || flag_isoc99) 7409 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 7410 { 7411 pedwarn_c99 ("%<return%> with no value, in " 7412 "function returning non-void"); 7413 no_warning = true; 7414 } 7415 } 7416 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 7417 { 7418 current_function_returns_null = 1; 7419 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 7420 pedwarn ("%<return%> with a value, in function returning void"); 7421 } 7422 else 7423 { 7424 tree t = convert_for_assignment (valtype, retval, ic_return, 7425 NULL_TREE, NULL_TREE, 0); 7426 tree res = DECL_RESULT (current_function_decl); 7427 tree inner; 7428 7429 current_function_returns_value = 1; 7430 if (t == error_mark_node) 7431 return NULL_TREE; 7432 7433 inner = t = convert (TREE_TYPE (res), t); 7434 7435 /* Strip any conversions, additions, and subtractions, and see if 7436 we are returning the address of a local variable. Warn if so. */ 7437 while (1) 7438 { 7439 switch (TREE_CODE (inner)) 7440 { 7441 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 7442 case PLUS_EXPR: 7443 inner = TREE_OPERAND (inner, 0); 7444 continue; 7445 7446 case MINUS_EXPR: 7447 /* If the second operand of the MINUS_EXPR has a pointer 7448 type (or is converted from it), this may be valid, so 7449 don't give a warning. */ 7450 { 7451 tree op1 = TREE_OPERAND (inner, 1); 7452 7453 while (!POINTER_TYPE_P (TREE_TYPE (op1)) 7454 && (TREE_CODE (op1) == NOP_EXPR 7455 || TREE_CODE (op1) == NON_LVALUE_EXPR 7456 || TREE_CODE (op1) == CONVERT_EXPR)) 7457 op1 = TREE_OPERAND (op1, 0); 7458 7459 if (POINTER_TYPE_P (TREE_TYPE (op1))) 7460 break; 7461 7462 inner = TREE_OPERAND (inner, 0); 7463 continue; 7464 } 7465 7466 case ADDR_EXPR: 7467 inner = TREE_OPERAND (inner, 0); 7468 7469 while (REFERENCE_CLASS_P (inner) 7470 && TREE_CODE (inner) != INDIRECT_REF) 7471 inner = TREE_OPERAND (inner, 0); 7472 7473 if (DECL_P (inner) 7474 && !DECL_EXTERNAL (inner) 7475 && !TREE_STATIC (inner) 7476 && DECL_CONTEXT (inner) == current_function_decl) 7477 /* APPLE LOCAL begin radar 5732232 - blocks (C++ cn) */ 7478 { 7479 if (TREE_CODE (valtype) == BLOCK_POINTER_TYPE) 7480 /* APPLE LOCAL radar 6048570 */ 7481 error ("returning block that lives on the local stack"); 7482 else 7483 warning (0, "function returns address of local variable"); 7484 } 7485 /* APPLE LOCAL end radar 5732232 - blocks (C++ cn) */ 7486 break; 7487 7488 default: 7489 break; 7490 } 7491 7492 break; 7493 } 7494 7495 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 7496 } 7497 7498 ret_stmt = build_stmt (RETURN_EXPR, retval); 7499 TREE_NO_WARNING (ret_stmt) |= no_warning; 7500 return add_stmt (ret_stmt); 7501} 7502 7503struct c_switch { 7504 /* The SWITCH_EXPR being built. */ 7505 tree switch_expr; 7506 7507 /* The original type of the testing expression, i.e. before the 7508 default conversion is applied. */ 7509 tree orig_type; 7510 7511 /* A splay-tree mapping the low element of a case range to the high 7512 element, or NULL_TREE if there is no high element. Used to 7513 determine whether or not a new case label duplicates an old case 7514 label. We need a tree, rather than simply a hash table, because 7515 of the GNU case range extension. */ 7516 splay_tree cases; 7517 7518 /* Number of nested statement expressions within this switch 7519 statement; if nonzero, case and default labels may not 7520 appear. */ 7521 unsigned int blocked_stmt_expr; 7522 7523 /* Scope of outermost declarations of identifiers with variably 7524 modified type within this switch statement; if nonzero, case and 7525 default labels may not appear. */ 7526 unsigned int blocked_vm; 7527 7528 /* The next node on the stack. */ 7529 struct c_switch *next; 7530}; 7531 7532/* A stack of the currently active switch statements. The innermost 7533 switch statement is on the top of the stack. There is no need to 7534 mark the stack for garbage collection because it is only active 7535 during the processing of the body of a function, and we never 7536 collect at that point. */ 7537 7538struct c_switch *c_switch_stack; 7539 7540/* Start a C switch statement, testing expression EXP. Return the new 7541 SWITCH_EXPR. */ 7542 7543tree 7544c_start_case (tree exp) 7545{ 7546 tree orig_type = error_mark_node; 7547 struct c_switch *cs; 7548 7549 if (exp != error_mark_node) 7550 { 7551 orig_type = TREE_TYPE (exp); 7552 7553 if (!INTEGRAL_TYPE_P (orig_type)) 7554 { 7555 if (orig_type != error_mark_node) 7556 { 7557 error ("switch quantity not an integer"); 7558 orig_type = error_mark_node; 7559 } 7560 exp = integer_zero_node; 7561 } 7562 else 7563 { 7564 tree type = TYPE_MAIN_VARIANT (orig_type); 7565 7566 if (!in_system_header 7567 && (type == long_integer_type_node 7568 || type == long_unsigned_type_node)) 7569 warning (OPT_Wtraditional, "%<long%> switch expression not " 7570 "converted to %<int%> in ISO C"); 7571 7572 exp = default_conversion (exp); 7573 } 7574 } 7575 7576 /* Add this new SWITCH_EXPR to the stack. */ 7577 cs = XNEW (struct c_switch); 7578 cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7579 cs->orig_type = orig_type; 7580 cs->cases = splay_tree_new (case_compare, NULL, NULL); 7581 cs->blocked_stmt_expr = 0; 7582 cs->blocked_vm = 0; 7583 cs->next = c_switch_stack; 7584 c_switch_stack = cs; 7585 7586 return add_stmt (cs->switch_expr); 7587} 7588 7589/* Process a case label. */ 7590 7591tree 7592do_case (tree low_value, tree high_value) 7593{ 7594 tree label = NULL_TREE; 7595 7596 if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7597 && !c_switch_stack->blocked_vm) 7598 { 7599 label = c_add_case_label (c_switch_stack->cases, 7600 SWITCH_COND (c_switch_stack->switch_expr), 7601 c_switch_stack->orig_type, 7602 low_value, high_value); 7603 if (label == error_mark_node) 7604 label = NULL_TREE; 7605 } 7606 else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7607 { 7608 if (low_value) 7609 error ("case label in statement expression not containing " 7610 "enclosing switch statement"); 7611 else 7612 error ("%<default%> label in statement expression not containing " 7613 "enclosing switch statement"); 7614 } 7615 else if (c_switch_stack && c_switch_stack->blocked_vm) 7616 { 7617 if (low_value) 7618 error ("case label in scope of identifier with variably modified " 7619 "type not containing enclosing switch statement"); 7620 else 7621 error ("%<default%> label in scope of identifier with variably " 7622 "modified type not containing enclosing switch statement"); 7623 } 7624 else if (low_value) 7625 error ("case label not within a switch statement"); 7626 else 7627 error ("%<default%> label not within a switch statement"); 7628 7629 return label; 7630} 7631 7632/* Finish the switch statement. */ 7633 7634void 7635c_finish_case (tree body) 7636{ 7637 struct c_switch *cs = c_switch_stack; 7638 location_t switch_location; 7639 7640 SWITCH_BODY (cs->switch_expr) = body; 7641 7642 /* We must not be within a statement expression nested in the switch 7643 at this point; we might, however, be within the scope of an 7644 identifier with variably modified type nested in the switch. */ 7645 gcc_assert (!cs->blocked_stmt_expr); 7646 7647 /* Emit warnings as needed. */ 7648 if (EXPR_HAS_LOCATION (cs->switch_expr)) 7649 switch_location = EXPR_LOCATION (cs->switch_expr); 7650 else 7651 switch_location = input_location; 7652 c_do_switch_warnings (cs->cases, switch_location, 7653 TREE_TYPE (cs->switch_expr), 7654 SWITCH_COND (cs->switch_expr)); 7655 7656 /* Pop the stack. */ 7657 c_switch_stack = cs->next; 7658 splay_tree_delete (cs->cases); 7659 XDELETE (cs); 7660} 7661 7662/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7663 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7664 may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7665 statement, and was not surrounded with parenthesis. */ 7666 7667void 7668c_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7669 tree else_block, bool nested_if) 7670{ 7671 tree stmt; 7672 7673 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7674 if (warn_parentheses && nested_if && else_block == NULL) 7675 { 7676 tree inner_if = then_block; 7677 7678 /* We know from the grammar productions that there is an IF nested 7679 within THEN_BLOCK. Due to labels and c99 conditional declarations, 7680 it might not be exactly THEN_BLOCK, but should be the last 7681 non-container statement within. */ 7682 while (1) 7683 switch (TREE_CODE (inner_if)) 7684 { 7685 case COND_EXPR: 7686 goto found; 7687 case BIND_EXPR: 7688 inner_if = BIND_EXPR_BODY (inner_if); 7689 break; 7690 case STATEMENT_LIST: 7691 inner_if = expr_last (then_block); 7692 break; 7693 case TRY_FINALLY_EXPR: 7694 case TRY_CATCH_EXPR: 7695 inner_if = TREE_OPERAND (inner_if, 0); 7696 break; 7697 default: 7698 gcc_unreachable (); 7699 } 7700 found: 7701 7702 if (COND_EXPR_ELSE (inner_if)) 7703 warning (OPT_Wparentheses, 7704 "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7705 &if_locus); 7706 } 7707 7708 empty_body_warning (then_block, else_block); 7709 7710 stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7711 SET_EXPR_LOCATION (stmt, if_locus); 7712 add_stmt (stmt); 7713} 7714 7715/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7716/* Emit a general-purpose loop construct. START_LOCUS is the location 7717 of the beginning of the loop. COND is the loop condition. 7718 COND_IS_FIRST is false for DO loops. INCR is the FOR increment 7719 expression. BODY is the statement controlled by the loop. BLAB is 7720 the break label. CLAB is the continue label. ATTRS is the 7721 attributes associated with the loop, which at present are 7722 associated with the topmost label. Everything is allowed to be 7723 NULL. */ 7724 7725/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7726void 7727c_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7728/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7729 tree blab, tree clab, tree attrs, bool cond_is_first) 7730/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7731{ 7732 tree entry = NULL, exit = NULL, t; 7733 7734 /* If the condition is zero don't generate a loop construct. */ 7735 if (cond && integer_zerop (cond)) 7736 { 7737 if (cond_is_first) 7738 { 7739 t = build_and_jump (&blab); 7740 SET_EXPR_LOCATION (t, start_locus); 7741 add_stmt (t); 7742 } 7743 } 7744 else 7745 { 7746 tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7747 7748 /* If we have an exit condition, then we build an IF with gotos either 7749 out of the loop, or to the top of it. If there's no exit condition, 7750 then we just build a jump back to the top. */ 7751 exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7752 7753/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7754 /* Add the attributes to the 'top' label. */ 7755 decl_attributes (&LABEL_EXPR_LABEL (top), attrs, 0); 7756 7757/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7758 if (cond && !integer_nonzerop (cond)) 7759 { 7760 /* Canonicalize the loop condition to the end. This means 7761 generating a branch to the loop condition. Reuse the 7762 continue label, if possible. */ 7763 if (cond_is_first) 7764 { 7765 if (incr || !clab) 7766 { 7767 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7768 t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7769 } 7770 else 7771 t = build1 (GOTO_EXPR, void_type_node, clab); 7772 SET_EXPR_LOCATION (t, start_locus); 7773 add_stmt (t); 7774 } 7775 7776 t = build_and_jump (&blab); 7777 exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7778 if (cond_is_first) 7779 SET_EXPR_LOCATION (exit, start_locus); 7780 else 7781 SET_EXPR_LOCATION (exit, input_location); 7782 } 7783 7784 add_stmt (top); 7785 } 7786 7787 if (body) 7788 add_stmt (body); 7789 if (clab) 7790 add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7791 if (incr) 7792 add_stmt (incr); 7793 if (entry) 7794 add_stmt (entry); 7795 if (exit) 7796 add_stmt (exit); 7797 if (blab) 7798 add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7799} 7800 7801tree 7802c_finish_bc_stmt (tree *label_p, bool is_break) 7803{ 7804 bool skip; 7805 tree label = *label_p; 7806 7807 /* In switch statements break is sometimes stylistically used after 7808 a return statement. This can lead to spurious warnings about 7809 control reaching the end of a non-void function when it is 7810 inlined. Note that we are calling block_may_fallthru with 7811 language specific tree nodes; this works because 7812 block_may_fallthru returns true when given something it does not 7813 understand. */ 7814 skip = !block_may_fallthru (cur_stmt_list); 7815 7816 if (!label) 7817 { 7818 if (!skip) 7819 *label_p = label = create_artificial_label (); 7820 } 7821 else if (TREE_CODE (label) == LABEL_DECL) 7822 ; 7823 else switch (TREE_INT_CST_LOW (label)) 7824 { 7825 case 0: 7826 if (is_break) 7827 error ("break statement not within loop or switch"); 7828 else 7829 error ("continue statement not within a loop"); 7830 return NULL_TREE; 7831 7832 case 1: 7833 gcc_assert (is_break); 7834 error ("break statement used with OpenMP for loop"); 7835 return NULL_TREE; 7836 7837 default: 7838 gcc_unreachable (); 7839 } 7840 7841 if (skip) 7842 return NULL_TREE; 7843 7844 return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7845} 7846 7847/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7848 7849static void 7850emit_side_effect_warnings (tree expr) 7851{ 7852 if (expr == error_mark_node) 7853 ; 7854 else if (!TREE_SIDE_EFFECTS (expr)) 7855 { 7856 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7857 warning (0, "%Hstatement with no effect", 7858 EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7859 } 7860 else if (warn_unused_value) 7861 warn_if_unused_value (expr, input_location); 7862} 7863 7864/* Process an expression as if it were a complete statement. Emit 7865 diagnostics, but do not call ADD_STMT. */ 7866 7867tree 7868c_process_expr_stmt (tree expr) 7869{ 7870 if (!expr) 7871 return NULL_TREE; 7872 7873 if (warn_sequence_point) 7874 verify_sequence_points (expr); 7875 7876 if (TREE_TYPE (expr) != error_mark_node 7877 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7878 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7879 error ("expression statement has incomplete type"); 7880 7881 /* If we're not processing a statement expression, warn about unused values. 7882 Warnings for statement expressions will be emitted later, once we figure 7883 out which is the result. */ 7884 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7885 && (extra_warnings || warn_unused_value)) 7886 emit_side_effect_warnings (expr); 7887 7888 /* If the expression is not of a type to which we cannot assign a line 7889 number, wrap the thing in a no-op NOP_EXPR. */ 7890 if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7891 expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7892 7893 if (EXPR_P (expr)) 7894 SET_EXPR_LOCATION (expr, input_location); 7895 7896 return expr; 7897} 7898 7899/* Emit an expression as a statement. */ 7900 7901tree 7902c_finish_expr_stmt (tree expr) 7903{ 7904 if (expr) 7905 return add_stmt (c_process_expr_stmt (expr)); 7906 else 7907 return NULL; 7908} 7909 7910/* Do the opposite and emit a statement as an expression. To begin, 7911 create a new binding level and return it. */ 7912 7913tree 7914c_begin_stmt_expr (void) 7915{ 7916 tree ret; 7917 struct c_label_context_se *nstack; 7918 struct c_label_list *glist; 7919 7920 /* We must force a BLOCK for this level so that, if it is not expanded 7921 later, there is a way to turn off the entire subtree of blocks that 7922 are contained in it. */ 7923 keep_next_level (); 7924 ret = c_begin_compound_stmt (true); 7925 if (c_switch_stack) 7926 { 7927 c_switch_stack->blocked_stmt_expr++; 7928 gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7929 } 7930 for (glist = label_context_stack_se->labels_used; 7931 glist != NULL; 7932 glist = glist->next) 7933 { 7934 C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7935 } 7936 nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7937 nstack->labels_def = NULL; 7938 nstack->labels_used = NULL; 7939 nstack->next = label_context_stack_se; 7940 label_context_stack_se = nstack; 7941 7942 /* Mark the current statement list as belonging to a statement list. */ 7943 STATEMENT_LIST_STMT_EXPR (ret) = 1; 7944 7945 return ret; 7946} 7947 7948tree 7949c_finish_stmt_expr (tree body) 7950{ 7951 tree last, type, tmp, val; 7952 tree *last_p; 7953 struct c_label_list *dlist, *glist, *glist_prev = NULL; 7954 7955 body = c_end_compound_stmt (body, true); 7956 if (c_switch_stack) 7957 { 7958 gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7959 c_switch_stack->blocked_stmt_expr--; 7960 } 7961 /* It is no longer possible to jump to labels defined within this 7962 statement expression. */ 7963 for (dlist = label_context_stack_se->labels_def; 7964 dlist != NULL; 7965 dlist = dlist->next) 7966 { 7967 C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7968 } 7969 /* It is again possible to define labels with a goto just outside 7970 this statement expression. */ 7971 for (glist = label_context_stack_se->next->labels_used; 7972 glist != NULL; 7973 glist = glist->next) 7974 { 7975 C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7976 glist_prev = glist; 7977 } 7978 if (glist_prev != NULL) 7979 glist_prev->next = label_context_stack_se->labels_used; 7980 else 7981 label_context_stack_se->next->labels_used 7982 = label_context_stack_se->labels_used; 7983 label_context_stack_se = label_context_stack_se->next; 7984 7985 /* Locate the last statement in BODY. See c_end_compound_stmt 7986 about always returning a BIND_EXPR. */ 7987 last_p = &BIND_EXPR_BODY (body); 7988 last = BIND_EXPR_BODY (body); 7989 7990 continue_searching: 7991 if (TREE_CODE (last) == STATEMENT_LIST) 7992 { 7993 tree_stmt_iterator i; 7994 7995 /* This can happen with degenerate cases like ({ }). No value. */ 7996 if (!TREE_SIDE_EFFECTS (last)) 7997 return body; 7998 7999 /* If we're supposed to generate side effects warnings, process 8000 all of the statements except the last. */ 8001 if (extra_warnings || warn_unused_value) 8002 { 8003 for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 8004 emit_side_effect_warnings (tsi_stmt (i)); 8005 } 8006 else 8007 i = tsi_last (last); 8008 last_p = tsi_stmt_ptr (i); 8009 last = *last_p; 8010 } 8011 8012 /* If the end of the list is exception related, then the list was split 8013 by a call to push_cleanup. Continue searching. */ 8014 if (TREE_CODE (last) == TRY_FINALLY_EXPR 8015 || TREE_CODE (last) == TRY_CATCH_EXPR) 8016 { 8017 last_p = &TREE_OPERAND (last, 0); 8018 last = *last_p; 8019 goto continue_searching; 8020 } 8021 8022 /* In the case that the BIND_EXPR is not necessary, return the 8023 expression out from inside it. */ 8024 if (last == error_mark_node 8025 || (last == BIND_EXPR_BODY (body) 8026 && BIND_EXPR_VARS (body) == NULL)) 8027 { 8028 /* Do not warn if the return value of a statement expression is 8029 unused. */ 8030 if (EXPR_P (last)) 8031 TREE_NO_WARNING (last) = 1; 8032 return last; 8033 } 8034 8035 /* Extract the type of said expression. */ 8036 type = TREE_TYPE (last); 8037 8038 /* If we're not returning a value at all, then the BIND_EXPR that 8039 we already have is a fine expression to return. */ 8040 if (!type || VOID_TYPE_P (type)) 8041 return body; 8042 8043 /* Now that we've located the expression containing the value, it seems 8044 silly to make voidify_wrapper_expr repeat the process. Create a 8045 temporary of the appropriate type and stick it in a TARGET_EXPR. */ 8046 tmp = create_tmp_var_raw (type, NULL); 8047 8048 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 8049 tree_expr_nonnegative_p giving up immediately. */ 8050 val = last; 8051 if (TREE_CODE (val) == NOP_EXPR 8052 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 8053 val = TREE_OPERAND (val, 0); 8054 8055 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 8056 SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 8057 8058 return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 8059} 8060 8061/* Begin the scope of an identifier of variably modified type, scope 8062 number SCOPE. Jumping from outside this scope to inside it is not 8063 permitted. */ 8064 8065void 8066c_begin_vm_scope (unsigned int scope) 8067{ 8068 struct c_label_context_vm *nstack; 8069 struct c_label_list *glist; 8070 8071 gcc_assert (scope > 0); 8072 8073 /* At file_scope, we don't have to do any processing. */ 8074 if (label_context_stack_vm == NULL) 8075 return; 8076 8077 if (c_switch_stack && !c_switch_stack->blocked_vm) 8078 c_switch_stack->blocked_vm = scope; 8079 for (glist = label_context_stack_vm->labels_used; 8080 glist != NULL; 8081 glist = glist->next) 8082 { 8083 C_DECL_UNDEFINABLE_VM (glist->label) = 1; 8084 } 8085 nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 8086 nstack->labels_def = NULL; 8087 nstack->labels_used = NULL; 8088 nstack->scope = scope; 8089 nstack->next = label_context_stack_vm; 8090 label_context_stack_vm = nstack; 8091} 8092 8093/* End a scope which may contain identifiers of variably modified 8094 type, scope number SCOPE. */ 8095 8096void 8097c_end_vm_scope (unsigned int scope) 8098{ 8099 if (label_context_stack_vm == NULL) 8100 return; 8101 if (c_switch_stack && c_switch_stack->blocked_vm == scope) 8102 c_switch_stack->blocked_vm = 0; 8103 /* We may have a number of nested scopes of identifiers with 8104 variably modified type, all at this depth. Pop each in turn. */ 8105 while (label_context_stack_vm->scope == scope) 8106 { 8107 struct c_label_list *dlist, *glist, *glist_prev = NULL; 8108 8109 /* It is no longer possible to jump to labels defined within this 8110 scope. */ 8111 for (dlist = label_context_stack_vm->labels_def; 8112 dlist != NULL; 8113 dlist = dlist->next) 8114 { 8115 C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 8116 } 8117 /* It is again possible to define labels with a goto just outside 8118 this scope. */ 8119 for (glist = label_context_stack_vm->next->labels_used; 8120 glist != NULL; 8121 glist = glist->next) 8122 { 8123 C_DECL_UNDEFINABLE_VM (glist->label) = 0; 8124 glist_prev = glist; 8125 } 8126 if (glist_prev != NULL) 8127 glist_prev->next = label_context_stack_vm->labels_used; 8128 else 8129 label_context_stack_vm->next->labels_used 8130 = label_context_stack_vm->labels_used; 8131 label_context_stack_vm = label_context_stack_vm->next; 8132 } 8133} 8134 8135/* Begin and end compound statements. This is as simple as pushing 8136 and popping new statement lists from the tree. */ 8137 8138tree 8139c_begin_compound_stmt (bool do_scope) 8140{ 8141 tree stmt = push_stmt_list (); 8142 if (do_scope) 8143 push_scope (); 8144 return stmt; 8145} 8146 8147tree 8148c_end_compound_stmt (tree stmt, bool do_scope) 8149{ 8150 tree block = NULL; 8151 8152 if (do_scope) 8153 { 8154 if (c_dialect_objc ()) 8155 objc_clear_super_receiver (); 8156 block = pop_scope (); 8157 } 8158 8159 stmt = pop_stmt_list (stmt); 8160 stmt = c_build_bind_expr (block, stmt); 8161 8162 /* If this compound statement is nested immediately inside a statement 8163 expression, then force a BIND_EXPR to be created. Otherwise we'll 8164 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 8165 STATEMENT_LISTs merge, and thus we can lose track of what statement 8166 was really last. */ 8167 if (cur_stmt_list 8168 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 8169 && TREE_CODE (stmt) != BIND_EXPR) 8170 { 8171 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 8172 TREE_SIDE_EFFECTS (stmt) = 1; 8173 } 8174 8175 return stmt; 8176} 8177 8178/* Queue a cleanup. CLEANUP is an expression/statement to be executed 8179 when the current scope is exited. EH_ONLY is true when this is not 8180 meant to apply to normal control flow transfer. */ 8181 8182void 8183push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 8184{ 8185 enum tree_code code; 8186 tree stmt, list; 8187 bool stmt_expr; 8188 8189 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 8190 stmt = build_stmt (code, NULL, cleanup); 8191 add_stmt (stmt); 8192 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 8193 list = push_stmt_list (); 8194 TREE_OPERAND (stmt, 0) = list; 8195 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 8196} 8197 8198/* Build a binary-operation expression without default conversions. 8199 CODE is the kind of expression to build. 8200 This function differs from `build' in several ways: 8201 the data type of the result is computed and recorded in it, 8202 warnings are generated if arg data types are invalid, 8203 special handling for addition and subtraction of pointers is known, 8204 and some optimization is done (operations on narrow ints 8205 are done in the narrower type when that gives the same result). 8206 Constant folding is also done before the result is returned. 8207 8208 Note that the operands will never have enumeral types, or function 8209 or array types, because either they will have the default conversions 8210 performed or they have both just been converted to some other type in which 8211 the arithmetic is to be done. */ 8212 8213tree 8214build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 8215 int convert_p) 8216{ 8217 tree type0, type1; 8218 enum tree_code code0, code1; 8219 tree op0, op1; 8220 const char *invalid_op_diag; 8221 8222 /* Expression code to give to the expression when it is built. 8223 Normally this is CODE, which is what the caller asked for, 8224 but in some special cases we change it. */ 8225 enum tree_code resultcode = code; 8226 8227 /* Data type in which the computation is to be performed. 8228 In the simplest cases this is the common type of the arguments. */ 8229 tree result_type = NULL; 8230 8231 /* Nonzero means operands have already been type-converted 8232 in whatever way is necessary. 8233 Zero means they need to be converted to RESULT_TYPE. */ 8234 int converted = 0; 8235 8236 /* Nonzero means create the expression with this type, rather than 8237 RESULT_TYPE. */ 8238 tree build_type = 0; 8239 8240 /* Nonzero means after finally constructing the expression 8241 convert it to this type. */ 8242 tree final_type = 0; 8243 8244 /* Nonzero if this is an operation like MIN or MAX which can 8245 safely be computed in short if both args are promoted shorts. 8246 Also implies COMMON. 8247 -1 indicates a bitwise operation; this makes a difference 8248 in the exact conditions for when it is safe to do the operation 8249 in a narrower mode. */ 8250 int shorten = 0; 8251 8252 /* Nonzero if this is a comparison operation; 8253 if both args are promoted shorts, compare the original shorts. 8254 Also implies COMMON. */ 8255 int short_compare = 0; 8256 8257 /* Nonzero if this is a right-shift operation, which can be computed on the 8258 original short and then promoted if the operand is a promoted short. */ 8259 int short_shift = 0; 8260 8261 /* Nonzero means set RESULT_TYPE to the common type of the args. */ 8262 int common = 0; 8263 8264 /* True means types are compatible as far as ObjC is concerned. */ 8265 bool objc_ok; 8266 8267 if (convert_p) 8268 { 8269 op0 = default_conversion (orig_op0); 8270 op1 = default_conversion (orig_op1); 8271 } 8272 else 8273 { 8274 op0 = orig_op0; 8275 op1 = orig_op1; 8276 } 8277 8278 type0 = TREE_TYPE (op0); 8279 type1 = TREE_TYPE (op1); 8280 8281 /* The expression codes of the data types of the arguments tell us 8282 whether the arguments are integers, floating, pointers, etc. */ 8283 code0 = TREE_CODE (type0); 8284 code1 = TREE_CODE (type1); 8285 8286 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 8287 STRIP_TYPE_NOPS (op0); 8288 STRIP_TYPE_NOPS (op1); 8289 8290 /* If an error was already reported for one of the arguments, 8291 avoid reporting another error. */ 8292 8293 if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8294 return error_mark_node; 8295 8296 if ((invalid_op_diag 8297 = targetm.invalid_binary_op (code, type0, type1))) 8298 { 8299 error (invalid_op_diag, ""); 8300 return error_mark_node; 8301 } 8302 8303 objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE, "comparison"); 8304 8305 switch (code) 8306 { 8307 case PLUS_EXPR: 8308 /* Handle the pointer + int case. */ 8309 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8310 return pointer_int_sum (PLUS_EXPR, op0, op1); 8311 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 8312 return pointer_int_sum (PLUS_EXPR, op1, op0); 8313 else 8314 common = 1; 8315 break; 8316 8317 case MINUS_EXPR: 8318 /* Subtraction of two similar pointers. 8319 We must subtract them as integers, then divide by object size. */ 8320 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 8321 && comp_target_types (type0, type1)) 8322 return pointer_diff (op0, op1); 8323 /* Handle pointer minus int. Just like pointer plus int. */ 8324 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8325 return pointer_int_sum (MINUS_EXPR, op0, op1); 8326 else 8327 common = 1; 8328 break; 8329 8330 case MULT_EXPR: 8331 common = 1; 8332 break; 8333 8334 case TRUNC_DIV_EXPR: 8335 case CEIL_DIV_EXPR: 8336 case FLOOR_DIV_EXPR: 8337 case ROUND_DIV_EXPR: 8338 case EXACT_DIV_EXPR: 8339 /* Floating point division by zero is a legitimate way to obtain 8340 infinities and NaNs. */ 8341 if (skip_evaluation == 0 && integer_zerop (op1)) 8342 warning (OPT_Wdiv_by_zero, "division by zero"); 8343 8344 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8345 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 8346 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8347 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 8348 { 8349 enum tree_code tcode0 = code0, tcode1 = code1; 8350 8351 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 8352 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 8353 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 8354 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 8355 8356 if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 8357 resultcode = RDIV_EXPR; 8358 else 8359 /* Although it would be tempting to shorten always here, that 8360 loses on some targets, since the modulo instruction is 8361 undefined if the quotient can't be represented in the 8362 computation mode. We shorten only if unsigned or if 8363 dividing by something we know != -1. */ 8364 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 8365 || (TREE_CODE (op1) == INTEGER_CST 8366 && !integer_all_onesp (op1))); 8367 common = 1; 8368 } 8369 break; 8370 8371 case BIT_AND_EXPR: 8372 case BIT_IOR_EXPR: 8373 case BIT_XOR_EXPR: 8374 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8375 shorten = -1; 8376 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 8377 common = 1; 8378 break; 8379 8380 case TRUNC_MOD_EXPR: 8381 case FLOOR_MOD_EXPR: 8382 if (skip_evaluation == 0 && integer_zerop (op1)) 8383 warning (OPT_Wdiv_by_zero, "division by zero"); 8384 8385 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8386 { 8387 /* Although it would be tempting to shorten always here, that loses 8388 on some targets, since the modulo instruction is undefined if the 8389 quotient can't be represented in the computation mode. We shorten 8390 only if unsigned or if dividing by something we know != -1. */ 8391 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 8392 || (TREE_CODE (op1) == INTEGER_CST 8393 && !integer_all_onesp (op1))); 8394 common = 1; 8395 } 8396 break; 8397 8398 case TRUTH_ANDIF_EXPR: 8399 case TRUTH_ORIF_EXPR: 8400 case TRUTH_AND_EXPR: 8401 case TRUTH_OR_EXPR: 8402 case TRUTH_XOR_EXPR: 8403 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 8404 /* APPLE LOCAL radar 5928316 */ 8405 || code0 == BLOCK_POINTER_TYPE 8406 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 8407 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 8408 /* APPLE LOCAL radar 5928316 */ 8409 || code1 == BLOCK_POINTER_TYPE 8410 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 8411 { 8412 /* Result of these operations is always an int, 8413 but that does not mean the operands should be 8414 converted to ints! */ 8415 result_type = integer_type_node; 8416 op0 = c_common_truthvalue_conversion (op0); 8417 op1 = c_common_truthvalue_conversion (op1); 8418 converted = 1; 8419 } 8420 break; 8421 8422 /* Shift operations: result has same type as first operand; 8423 always convert second operand to int. 8424 Also set SHORT_SHIFT if shifting rightward. */ 8425 8426 case RSHIFT_EXPR: 8427 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8428 { 8429 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8430 { 8431 if (tree_int_cst_sgn (op1) < 0) 8432 warning (0, "right shift count is negative"); 8433 else 8434 { 8435 if (!integer_zerop (op1)) 8436 short_shift = 1; 8437 8438 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8439 warning (0, "right shift count >= width of type"); 8440 } 8441 } 8442 8443 /* Use the type of the value to be shifted. */ 8444 result_type = type0; 8445 /* Convert the shift-count to an integer, regardless of size 8446 of value being shifted. */ 8447 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8448 op1 = convert (integer_type_node, op1); 8449 /* Avoid converting op1 to result_type later. */ 8450 converted = 1; 8451 } 8452 break; 8453 8454 case LSHIFT_EXPR: 8455 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8456 { 8457 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8458 { 8459 if (tree_int_cst_sgn (op1) < 0) 8460 warning (0, "left shift count is negative"); 8461 8462 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8463 warning (0, "left shift count >= width of type"); 8464 } 8465 8466 /* Use the type of the value to be shifted. */ 8467 result_type = type0; 8468 /* Convert the shift-count to an integer, regardless of size 8469 of value being shifted. */ 8470 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8471 op1 = convert (integer_type_node, op1); 8472 /* Avoid converting op1 to result_type later. */ 8473 converted = 1; 8474 } 8475 break; 8476 8477 case EQ_EXPR: 8478 case NE_EXPR: 8479 if (code0 == REAL_TYPE || code1 == REAL_TYPE) 8480 warning (OPT_Wfloat_equal, 8481 "comparing floating point with == or != is unsafe"); 8482 /* Result of comparison is always int, 8483 but don't convert the args to int! */ 8484 build_type = integer_type_node; 8485 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8486 || code0 == COMPLEX_TYPE) 8487 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8488 || code1 == COMPLEX_TYPE)) 8489 short_compare = 1; 8490 /* APPLE LOCAL begin blocks 6065211 */ 8491 else if ((code0 == POINTER_TYPE || code0 == BLOCK_POINTER_TYPE) 8492 && (code1 == POINTER_TYPE || code1 == BLOCK_POINTER_TYPE)) 8493 /* APPLE LOCAL end blocks 6065211 */ 8494 { 8495 tree tt0 = TREE_TYPE (type0); 8496 tree tt1 = TREE_TYPE (type1); 8497 /* Anything compares with void *. void * compares with anything. 8498 Otherwise, the targets must be compatible 8499 and both must be object or both incomplete. */ 8500 if (comp_target_types (type0, type1)) 8501 result_type = common_pointer_type (type0, type1); 8502 /* APPLE LOCAL begin blocks 6065211 */ 8503 else if (code1 == BLOCK_POINTER_TYPE && VOID_TYPE_P (tt0)) 8504 ; 8505 else if (code0 == BLOCK_POINTER_TYPE && VOID_TYPE_P (tt1)) 8506 ; 8507 /* APPLE LOCAL end blocks 6065211 */ 8508 else if (VOID_TYPE_P (tt0)) 8509 { 8510 /* op0 != orig_op0 detects the case of something 8511 whose value is 0 but which isn't a valid null ptr const. */ 8512 if (pedantic && !null_pointer_constant_p (orig_op0) 8513 && TREE_CODE (tt1) == FUNCTION_TYPE) 8514 pedwarn ("ISO C forbids comparison of %<void *%>" 8515 " with function pointer"); 8516 } 8517 else if (VOID_TYPE_P (tt1)) 8518 { 8519 if (pedantic && !null_pointer_constant_p (orig_op1) 8520 && TREE_CODE (tt0) == FUNCTION_TYPE) 8521 pedwarn ("ISO C forbids comparison of %<void *%>" 8522 " with function pointer"); 8523 } 8524 else 8525 /* Avoid warning about the volatile ObjC EH puts on decls. */ 8526 if (!objc_ok) 8527 /* APPLE LOCAL begin blocks 6065211 */ 8528 { 8529 if (code0 == BLOCK_POINTER_TYPE || code1 == BLOCK_POINTER_TYPE) 8530 pedwarn ("comparison of distinct block types lacks a cast"); 8531 else 8532 pedwarn ("comparison of distinct pointer types lacks a cast"); 8533 } 8534 /* APPLE LOCAL end blocks 6065211 */ 8535 8536 if (result_type == NULL_TREE) 8537 result_type = ptr_type_node; 8538 } 8539 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8540 { 8541 if (TREE_CODE (op0) == ADDR_EXPR 8542 && DECL_P (TREE_OPERAND (op0, 0)) 8543 && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8544 || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8545 || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8546 warning (OPT_Waddress, "the address of %qD will never be NULL", 8547 TREE_OPERAND (op0, 0)); 8548 result_type = type0; 8549 } 8550 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8551 { 8552 if (TREE_CODE (op1) == ADDR_EXPR 8553 && DECL_P (TREE_OPERAND (op1, 0)) 8554 && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8555 || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8556 || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8557 warning (OPT_Waddress, "the address of %qD will never be NULL", 8558 TREE_OPERAND (op1, 0)); 8559 result_type = type1; 8560 } 8561 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8562 { 8563 result_type = type0; 8564 pedwarn ("comparison between pointer and integer"); 8565 } 8566 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8567 { 8568 result_type = type1; 8569 pedwarn ("comparison between pointer and integer"); 8570 } 8571 /* APPLE LOCAL begin radar 5732232 - blocks (C++ cl) */ 8572 else if (code0 == BLOCK_POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8573 result_type = type0; 8574 else if (code1 == BLOCK_POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8575 result_type = type1; 8576 /* APPLE LOCAL end radar 5732232 - blocks (C++ cl) */ 8577 break; 8578 8579 case LE_EXPR: 8580 case GE_EXPR: 8581 case LT_EXPR: 8582 case GT_EXPR: 8583 build_type = integer_type_node; 8584 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8585 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8586 short_compare = 1; 8587 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8588 { 8589 if (comp_target_types (type0, type1)) 8590 { 8591 result_type = common_pointer_type (type0, type1); 8592 if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8593 != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8594 pedwarn ("comparison of complete and incomplete pointers"); 8595 else if (pedantic 8596 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8597 pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8598 } 8599 else 8600 { 8601 result_type = ptr_type_node; 8602 pedwarn ("comparison of distinct pointer types lacks a cast"); 8603 } 8604 } 8605 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8606 { 8607 result_type = type0; 8608 if (pedantic || extra_warnings) 8609 pedwarn ("ordered comparison of pointer with integer zero"); 8610 } 8611 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8612 { 8613 result_type = type1; 8614 if (pedantic) 8615 pedwarn ("ordered comparison of pointer with integer zero"); 8616 } 8617 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8618 { 8619 result_type = type0; 8620 pedwarn ("comparison between pointer and integer"); 8621 } 8622 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8623 { 8624 result_type = type1; 8625 pedwarn ("comparison between pointer and integer"); 8626 } 8627 break; 8628 8629 default: 8630 gcc_unreachable (); 8631 } 8632 8633 if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8634 return error_mark_node; 8635 8636 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8637 && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8638 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8639 TREE_TYPE (type1)))) 8640 { 8641 binary_op_error (code, type0, type1); 8642 return error_mark_node; 8643 } 8644 8645 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8646 || code0 == VECTOR_TYPE) 8647 && 8648 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8649 || code1 == VECTOR_TYPE)) 8650 { 8651 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8652 8653 if (shorten || common || short_compare) 8654 result_type = c_common_type (type0, type1); 8655 8656 /* For certain operations (which identify themselves by shorten != 0) 8657 if both args were extended from the same smaller type, 8658 do the arithmetic in that type and then extend. 8659 8660 shorten !=0 and !=1 indicates a bitwise operation. 8661 For them, this optimization is safe only if 8662 both args are zero-extended or both are sign-extended. 8663 Otherwise, we might change the result. 8664 Eg, (short)-1 | (unsigned short)-1 is (int)-1 8665 but calculated in (unsigned short) it would be (unsigned short)-1. */ 8666 8667 if (shorten && none_complex) 8668 { 8669 int unsigned0, unsigned1; 8670 tree arg0, arg1; 8671 int uns; 8672 tree type; 8673 8674 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8675 excessive narrowing when we call get_narrower below. For 8676 example, suppose that OP0 is of unsigned int extended 8677 from signed char and that RESULT_TYPE is long long int. 8678 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8679 like 8680 8681 (long long int) (unsigned int) signed_char 8682 8683 which get_narrower would narrow down to 8684 8685 (unsigned int) signed char 8686 8687 If we do not cast OP0 first, get_narrower would return 8688 signed_char, which is inconsistent with the case of the 8689 explicit cast. */ 8690 op0 = convert (result_type, op0); 8691 op1 = convert (result_type, op1); 8692 8693 arg0 = get_narrower (op0, &unsigned0); 8694 arg1 = get_narrower (op1, &unsigned1); 8695 8696 /* UNS is 1 if the operation to be done is an unsigned one. */ 8697 uns = TYPE_UNSIGNED (result_type); 8698 8699 final_type = result_type; 8700 8701 /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8702 but it *requires* conversion to FINAL_TYPE. */ 8703 8704 if ((TYPE_PRECISION (TREE_TYPE (op0)) 8705 == TYPE_PRECISION (TREE_TYPE (arg0))) 8706 && TREE_TYPE (op0) != final_type) 8707 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8708 if ((TYPE_PRECISION (TREE_TYPE (op1)) 8709 == TYPE_PRECISION (TREE_TYPE (arg1))) 8710 && TREE_TYPE (op1) != final_type) 8711 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8712 8713 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8714 8715 /* For bitwise operations, signedness of nominal type 8716 does not matter. Consider only how operands were extended. */ 8717 if (shorten == -1) 8718 uns = unsigned0; 8719 8720 /* Note that in all three cases below we refrain from optimizing 8721 an unsigned operation on sign-extended args. 8722 That would not be valid. */ 8723 8724 /* Both args variable: if both extended in same way 8725 from same width, do it in that width. 8726 Do it unsigned if args were zero-extended. */ 8727 if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8728 < TYPE_PRECISION (result_type)) 8729 && (TYPE_PRECISION (TREE_TYPE (arg1)) 8730 == TYPE_PRECISION (TREE_TYPE (arg0))) 8731 && unsigned0 == unsigned1 8732 && (unsigned0 || !uns)) 8733 result_type 8734 = c_common_signed_or_unsigned_type 8735 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8736 else if (TREE_CODE (arg0) == INTEGER_CST 8737 && (unsigned1 || !uns) 8738 && (TYPE_PRECISION (TREE_TYPE (arg1)) 8739 < TYPE_PRECISION (result_type)) 8740 && (type 8741 = c_common_signed_or_unsigned_type (unsigned1, 8742 TREE_TYPE (arg1)), 8743 int_fits_type_p (arg0, type))) 8744 result_type = type; 8745 else if (TREE_CODE (arg1) == INTEGER_CST 8746 && (unsigned0 || !uns) 8747 && (TYPE_PRECISION (TREE_TYPE (arg0)) 8748 < TYPE_PRECISION (result_type)) 8749 && (type 8750 = c_common_signed_or_unsigned_type (unsigned0, 8751 TREE_TYPE (arg0)), 8752 int_fits_type_p (arg1, type))) 8753 result_type = type; 8754 } 8755 8756 /* Shifts can be shortened if shifting right. */ 8757 8758 if (short_shift) 8759 { 8760 int unsigned_arg; 8761 tree arg0 = get_narrower (op0, &unsigned_arg); 8762 8763 final_type = result_type; 8764 8765 if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8766 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8767 8768 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8769 /* We can shorten only if the shift count is less than the 8770 number of bits in the smaller type size. */ 8771 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8772 /* We cannot drop an unsigned shift after sign-extension. */ 8773 && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8774 { 8775 /* Do an unsigned shift if the operand was zero-extended. */ 8776 result_type 8777 = c_common_signed_or_unsigned_type (unsigned_arg, 8778 TREE_TYPE (arg0)); 8779 /* Convert value-to-be-shifted to that type. */ 8780 if (TREE_TYPE (op0) != result_type) 8781 op0 = convert (result_type, op0); 8782 converted = 1; 8783 } 8784 } 8785 8786 /* Comparison operations are shortened too but differently. 8787 They identify themselves by setting short_compare = 1. */ 8788 8789 if (short_compare) 8790 { 8791 /* Don't write &op0, etc., because that would prevent op0 8792 from being kept in a register. 8793 Instead, make copies of the our local variables and 8794 pass the copies by reference, then copy them back afterward. */ 8795 tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8796 enum tree_code xresultcode = resultcode; 8797 tree val 8798 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8799 8800 if (val != 0) 8801 return val; 8802 8803 op0 = xop0, op1 = xop1; 8804 converted = 1; 8805 resultcode = xresultcode; 8806 8807 if (warn_sign_compare && skip_evaluation == 0) 8808 { 8809 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8810 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8811 int unsignedp0, unsignedp1; 8812 tree primop0 = get_narrower (op0, &unsignedp0); 8813 tree primop1 = get_narrower (op1, &unsignedp1); 8814 8815 xop0 = orig_op0; 8816 xop1 = orig_op1; 8817 STRIP_TYPE_NOPS (xop0); 8818 STRIP_TYPE_NOPS (xop1); 8819 8820 /* Give warnings for comparisons between signed and unsigned 8821 quantities that may fail. 8822 8823 Do the checking based on the original operand trees, so that 8824 casts will be considered, but default promotions won't be. 8825 8826 Do not warn if the comparison is being done in a signed type, 8827 since the signed type will only be chosen if it can represent 8828 all the values of the unsigned type. */ 8829 if (!TYPE_UNSIGNED (result_type)) 8830 /* OK */; 8831 /* Do not warn if both operands are the same signedness. */ 8832 else if (op0_signed == op1_signed) 8833 /* OK */; 8834 else 8835 { 8836 tree sop, uop; 8837 bool ovf; 8838 8839 if (op0_signed) 8840 sop = xop0, uop = xop1; 8841 else 8842 sop = xop1, uop = xop0; 8843 8844 /* Do not warn if the signed quantity is an 8845 unsuffixed integer literal (or some static 8846 constant expression involving such literals or a 8847 conditional expression involving such literals) 8848 and it is non-negative. */ 8849 if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8850 /* OK */; 8851 /* Do not warn if the comparison is an equality operation, 8852 the unsigned quantity is an integral constant, and it 8853 would fit in the result if the result were signed. */ 8854 else if (TREE_CODE (uop) == INTEGER_CST 8855 && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8856 && int_fits_type_p 8857 (uop, c_common_signed_type (result_type))) 8858 /* OK */; 8859 /* Do not warn if the unsigned quantity is an enumeration 8860 constant and its maximum value would fit in the result 8861 if the result were signed. */ 8862 else if (TREE_CODE (uop) == INTEGER_CST 8863 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8864 && int_fits_type_p 8865 (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8866 c_common_signed_type (result_type))) 8867 /* OK */; 8868 else 8869 warning (0, "comparison between signed and unsigned"); 8870 } 8871 8872 /* Warn if two unsigned values are being compared in a size 8873 larger than their original size, and one (and only one) is the 8874 result of a `~' operator. This comparison will always fail. 8875 8876 Also warn if one operand is a constant, and the constant 8877 does not have all bits set that are set in the ~ operand 8878 when it is extended. */ 8879 8880 if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8881 != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8882 { 8883 if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8884 primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8885 &unsignedp0); 8886 else 8887 primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8888 &unsignedp1); 8889 8890 if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8891 { 8892 tree primop; 8893 HOST_WIDE_INT constant, mask; 8894 int unsignedp, bits; 8895 8896 if (host_integerp (primop0, 0)) 8897 { 8898 primop = primop1; 8899 unsignedp = unsignedp1; 8900 constant = tree_low_cst (primop0, 0); 8901 } 8902 else 8903 { 8904 primop = primop0; 8905 unsignedp = unsignedp0; 8906 constant = tree_low_cst (primop1, 0); 8907 } 8908 8909 bits = TYPE_PRECISION (TREE_TYPE (primop)); 8910 if (bits < TYPE_PRECISION (result_type) 8911 && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8912 { 8913 mask = (~(HOST_WIDE_INT) 0) << bits; 8914 if ((mask & constant) != mask) 8915 warning (0, "comparison of promoted ~unsigned with constant"); 8916 } 8917 } 8918 else if (unsignedp0 && unsignedp1 8919 && (TYPE_PRECISION (TREE_TYPE (primop0)) 8920 < TYPE_PRECISION (result_type)) 8921 && (TYPE_PRECISION (TREE_TYPE (primop1)) 8922 < TYPE_PRECISION (result_type))) 8923 warning (0, "comparison of promoted ~unsigned with unsigned"); 8924 } 8925 } 8926 } 8927 } 8928 8929 /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8930 If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8931 Then the expression will be built. 8932 It will be given type FINAL_TYPE if that is nonzero; 8933 otherwise, it will be given type RESULT_TYPE. */ 8934 8935 if (!result_type) 8936 { 8937 binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1)); 8938 return error_mark_node; 8939 } 8940 8941 if (!converted) 8942 { 8943 if (TREE_TYPE (op0) != result_type) 8944 op0 = convert_and_check (result_type, op0); 8945 if (TREE_TYPE (op1) != result_type) 8946 op1 = convert_and_check (result_type, op1); 8947 8948 /* This can happen if one operand has a vector type, and the other 8949 has a different type. */ 8950 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8951 return error_mark_node; 8952 } 8953 8954 if (build_type == NULL_TREE) 8955 build_type = result_type; 8956 8957 { 8958 /* Treat expressions in initializers specially as they can't trap. */ 8959 tree result = require_constant_value ? fold_build2_initializer (resultcode, 8960 build_type, 8961 op0, op1) 8962 : fold_build2 (resultcode, build_type, 8963 op0, op1); 8964 8965 if (final_type != 0) 8966 result = convert (final_type, result); 8967 return result; 8968 } 8969} 8970 8971 8972/* Convert EXPR to be a truth-value, validating its type for this 8973 purpose. */ 8974 8975tree 8976c_objc_common_truthvalue_conversion (tree expr) 8977{ 8978 switch (TREE_CODE (TREE_TYPE (expr))) 8979 { 8980 case ARRAY_TYPE: 8981 error ("used array that cannot be converted to pointer where scalar is required"); 8982 return error_mark_node; 8983 8984 case RECORD_TYPE: 8985 error ("used struct type value where scalar is required"); 8986 return error_mark_node; 8987 8988 case UNION_TYPE: 8989 error ("used union type value where scalar is required"); 8990 return error_mark_node; 8991 8992 case FUNCTION_TYPE: 8993 gcc_unreachable (); 8994 8995 default: 8996 break; 8997 } 8998 8999 /* ??? Should we also give an error for void and vectors rather than 9000 leaving those to give errors later? */ 9001 return c_common_truthvalue_conversion (expr); 9002} 9003 9004 9005/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 9006 required. */ 9007 9008tree 9009c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 9010 bool *ti ATTRIBUTE_UNUSED, bool *se) 9011{ 9012 if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 9013 { 9014 tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 9015 /* Executing a compound literal inside a function reinitializes 9016 it. */ 9017 if (!TREE_STATIC (decl)) 9018 *se = true; 9019 return decl; 9020 } 9021 else 9022 return expr; 9023} 9024 9025/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 9026 9027tree 9028c_begin_omp_parallel (void) 9029{ 9030 tree block; 9031 9032 keep_next_level (); 9033 block = c_begin_compound_stmt (true); 9034 9035 return block; 9036} 9037 9038tree 9039c_finish_omp_parallel (tree clauses, tree block) 9040{ 9041 tree stmt; 9042 9043 block = c_end_compound_stmt (block, true); 9044 9045 stmt = make_node (OMP_PARALLEL); 9046 TREE_TYPE (stmt) = void_type_node; 9047 OMP_PARALLEL_CLAUSES (stmt) = clauses; 9048 OMP_PARALLEL_BODY (stmt) = block; 9049 9050 return add_stmt (stmt); 9051} 9052 9053/* For all elements of CLAUSES, validate them vs OpenMP constraints. 9054 Remove any elements from the list that are invalid. */ 9055 9056tree 9057c_finish_omp_clauses (tree clauses) 9058{ 9059 bitmap_head generic_head, firstprivate_head, lastprivate_head; 9060 tree c, t, *pc = &clauses; 9061 const char *name; 9062 9063 bitmap_obstack_initialize (NULL); 9064 bitmap_initialize (&generic_head, &bitmap_default_obstack); 9065 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 9066 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 9067 9068 for (pc = &clauses, c = clauses; c ; c = *pc) 9069 { 9070 bool remove = false; 9071 bool need_complete = false; 9072 bool need_implicitly_determined = false; 9073 9074 switch (OMP_CLAUSE_CODE (c)) 9075 { 9076 case OMP_CLAUSE_SHARED: 9077 name = "shared"; 9078 need_implicitly_determined = true; 9079 goto check_dup_generic; 9080 9081 case OMP_CLAUSE_PRIVATE: 9082 name = "private"; 9083 need_complete = true; 9084 need_implicitly_determined = true; 9085 goto check_dup_generic; 9086 9087 case OMP_CLAUSE_REDUCTION: 9088 name = "reduction"; 9089 need_implicitly_determined = true; 9090 t = OMP_CLAUSE_DECL (c); 9091 if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 9092 || POINTER_TYPE_P (TREE_TYPE (t))) 9093 { 9094 error ("%qE has invalid type for %<reduction%>", t); 9095 remove = true; 9096 } 9097 else if (FLOAT_TYPE_P (TREE_TYPE (t))) 9098 { 9099 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 9100 const char *r_name = NULL; 9101 9102 switch (r_code) 9103 { 9104 case PLUS_EXPR: 9105 case MULT_EXPR: 9106 case MINUS_EXPR: 9107 break; 9108 case BIT_AND_EXPR: 9109 r_name = "&"; 9110 break; 9111 case BIT_XOR_EXPR: 9112 r_name = "^"; 9113 break; 9114 case BIT_IOR_EXPR: 9115 r_name = "|"; 9116 break; 9117 case TRUTH_ANDIF_EXPR: 9118 r_name = "&&"; 9119 break; 9120 case TRUTH_ORIF_EXPR: 9121 r_name = "||"; 9122 break; 9123 default: 9124 gcc_unreachable (); 9125 } 9126 if (r_name) 9127 { 9128 error ("%qE has invalid type for %<reduction(%s)%>", 9129 t, r_name); 9130 remove = true; 9131 } 9132 } 9133 goto check_dup_generic; 9134 9135 case OMP_CLAUSE_COPYPRIVATE: 9136 name = "copyprivate"; 9137 goto check_dup_generic; 9138 9139 case OMP_CLAUSE_COPYIN: 9140 name = "copyin"; 9141 t = OMP_CLAUSE_DECL (c); 9142 if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 9143 { 9144 error ("%qE must be %<threadprivate%> for %<copyin%>", t); 9145 remove = true; 9146 } 9147 goto check_dup_generic; 9148 9149 check_dup_generic: 9150 t = OMP_CLAUSE_DECL (c); 9151 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9152 { 9153 error ("%qE is not a variable in clause %qs", t, name); 9154 remove = true; 9155 } 9156 else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9157 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 9158 || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 9159 { 9160 error ("%qE appears more than once in data clauses", t); 9161 remove = true; 9162 } 9163 else 9164 bitmap_set_bit (&generic_head, DECL_UID (t)); 9165 break; 9166 9167 case OMP_CLAUSE_FIRSTPRIVATE: 9168 name = "firstprivate"; 9169 t = OMP_CLAUSE_DECL (c); 9170 need_complete = true; 9171 need_implicitly_determined = true; 9172 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9173 { 9174 error ("%qE is not a variable in clause %<firstprivate%>", t); 9175 remove = true; 9176 } 9177 else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9178 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 9179 { 9180 error ("%qE appears more than once in data clauses", t); 9181 remove = true; 9182 } 9183 else 9184 bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 9185 break; 9186 9187 case OMP_CLAUSE_LASTPRIVATE: 9188 name = "lastprivate"; 9189 t = OMP_CLAUSE_DECL (c); 9190 need_complete = true; 9191 need_implicitly_determined = true; 9192 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9193 { 9194 error ("%qE is not a variable in clause %<lastprivate%>", t); 9195 remove = true; 9196 } 9197 else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9198 || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 9199 { 9200 error ("%qE appears more than once in data clauses", t); 9201 remove = true; 9202 } 9203 else 9204 bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 9205 break; 9206 9207 case OMP_CLAUSE_IF: 9208 case OMP_CLAUSE_NUM_THREADS: 9209 case OMP_CLAUSE_SCHEDULE: 9210 case OMP_CLAUSE_NOWAIT: 9211 case OMP_CLAUSE_ORDERED: 9212 case OMP_CLAUSE_DEFAULT: 9213 pc = &OMP_CLAUSE_CHAIN (c); 9214 continue; 9215 9216 default: 9217 gcc_unreachable (); 9218 } 9219 9220 if (!remove) 9221 { 9222 t = OMP_CLAUSE_DECL (c); 9223 9224 if (need_complete) 9225 { 9226 t = require_complete_type (t); 9227 if (t == error_mark_node) 9228 remove = true; 9229 } 9230 9231 if (need_implicitly_determined) 9232 { 9233 const char *share_name = NULL; 9234 9235 if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 9236 share_name = "threadprivate"; 9237 else switch (c_omp_predetermined_sharing (t)) 9238 { 9239 case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 9240 break; 9241 case OMP_CLAUSE_DEFAULT_SHARED: 9242 share_name = "shared"; 9243 break; 9244 case OMP_CLAUSE_DEFAULT_PRIVATE: 9245 share_name = "private"; 9246 break; 9247 default: 9248 gcc_unreachable (); 9249 } 9250 if (share_name) 9251 { 9252 error ("%qE is predetermined %qs for %qs", 9253 t, share_name, name); 9254 remove = true; 9255 } 9256 } 9257 } 9258 9259 if (remove) 9260 *pc = OMP_CLAUSE_CHAIN (c); 9261 else 9262 pc = &OMP_CLAUSE_CHAIN (c); 9263 } 9264 9265 bitmap_obstack_release (NULL); 9266 return clauses; 9267} 9268