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