1/* Subroutines shared by all languages that are variants of C. 2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "intl.h" 27#include "tree.h" 28#include "flags.h" 29#include "output.h" 30#include "c-pragma.h" 31#include "rtl.h" 32#include "ggc.h" 33#include "varray.h" 34#include "expr.h" 35#include "c-common.h" 36#include "diagnostic.h" 37#include "tm_p.h" 38#include "obstack.h" 39#include "cpplib.h" 40#include "target.h" 41#include "langhooks.h" 42#include "tree-inline.h" 43#include "c-tree.h" 44#include "toplev.h" 45#include "tree-iterator.h" 46#include "hashtab.h" 47#include "tree-mudflap.h" 48#include "opts.h" 49#include "real.h" 50#include "cgraph.h" 51 52cpp_reader *parse_in; /* Declared in c-pragma.h. */ 53 54/* We let tm.h override the types used here, to handle trivial differences 55 such as the choice of unsigned int or long unsigned int for size_t. 56 When machines start needing nontrivial differences in the size type, 57 it would be best to do something here to figure out automatically 58 from other information what type to use. */ 59 60#ifndef SIZE_TYPE 61#define SIZE_TYPE "long unsigned int" 62#endif 63 64#ifndef PID_TYPE 65#define PID_TYPE "int" 66#endif 67 68#ifndef WCHAR_TYPE 69#define WCHAR_TYPE "int" 70#endif 71 72/* WCHAR_TYPE gets overridden by -fshort-wchar. */ 73#define MODIFIED_WCHAR_TYPE \ 74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) 75 76#ifndef PTRDIFF_TYPE 77#define PTRDIFF_TYPE "long int" 78#endif 79 80#ifndef WINT_TYPE 81#define WINT_TYPE "unsigned int" 82#endif 83 84#ifndef INTMAX_TYPE 85#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ 86 ? "int" \ 87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ 88 ? "long int" \ 89 : "long long int")) 90#endif 91 92#ifndef UINTMAX_TYPE 93#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ 94 ? "unsigned int" \ 95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ 96 ? "long unsigned int" \ 97 : "long long unsigned int")) 98#endif 99 100/* The following symbols are subsumed in the c_global_trees array, and 101 listed here individually for documentation purposes. 102 103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types. 104 105 tree short_integer_type_node; 106 tree long_integer_type_node; 107 tree long_long_integer_type_node; 108 109 tree short_unsigned_type_node; 110 tree long_unsigned_type_node; 111 tree long_long_unsigned_type_node; 112 113 tree truthvalue_type_node; 114 tree truthvalue_false_node; 115 tree truthvalue_true_node; 116 117 tree ptrdiff_type_node; 118 119 tree unsigned_char_type_node; 120 tree signed_char_type_node; 121 tree wchar_type_node; 122 tree signed_wchar_type_node; 123 tree unsigned_wchar_type_node; 124 125 tree float_type_node; 126 tree double_type_node; 127 tree long_double_type_node; 128 129 tree complex_integer_type_node; 130 tree complex_float_type_node; 131 tree complex_double_type_node; 132 tree complex_long_double_type_node; 133 134 tree dfloat32_type_node; 135 tree dfloat64_type_node; 136 tree_dfloat128_type_node; 137 138 tree intQI_type_node; 139 tree intHI_type_node; 140 tree intSI_type_node; 141 tree intDI_type_node; 142 tree intTI_type_node; 143 144 tree unsigned_intQI_type_node; 145 tree unsigned_intHI_type_node; 146 tree unsigned_intSI_type_node; 147 tree unsigned_intDI_type_node; 148 tree unsigned_intTI_type_node; 149 150 tree widest_integer_literal_type_node; 151 tree widest_unsigned_literal_type_node; 152 153 Nodes for types `void *' and `const void *'. 154 155 tree ptr_type_node, const_ptr_type_node; 156 157 Nodes for types `char *' and `const char *'. 158 159 tree string_type_node, const_string_type_node; 160 161 Type `char[SOMENUMBER]'. 162 Used when an array of char is needed and the size is irrelevant. 163 164 tree char_array_type_node; 165 166 Type `int[SOMENUMBER]' or something like it. 167 Used when an array of int needed and the size is irrelevant. 168 169 tree int_array_type_node; 170 171 Type `wchar_t[SOMENUMBER]' or something like it. 172 Used when a wide string literal is created. 173 174 tree wchar_array_type_node; 175 176 Type `int ()' -- used for implicit declaration of functions. 177 178 tree default_function_type; 179 180 A VOID_TYPE node, packaged in a TREE_LIST. 181 182 tree void_list_node; 183 184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__, 185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__ 186 VAR_DECLS, but C++ does.) 187 188 tree function_name_decl_node; 189 tree pretty_function_name_decl_node; 190 tree c99_function_name_decl_node; 191 192 Stack of nested function name VAR_DECLs. 193 194 tree saved_function_name_decls; 195 196*/ 197 198tree c_global_trees[CTI_MAX]; 199 200/* Switches common to the C front ends. */ 201 202/* Nonzero if prepreprocessing only. */ 203 204int flag_preprocess_only; 205 206/* Nonzero means don't output line number information. */ 207 208char flag_no_line_commands; 209 210/* Nonzero causes -E output not to be done, but directives such as 211 #define that have side effects are still obeyed. */ 212 213char flag_no_output; 214 215/* Nonzero means dump macros in some fashion. */ 216 217char flag_dump_macros; 218 219/* Nonzero means pass #include lines through to the output. */ 220 221char flag_dump_includes; 222 223/* Nonzero means process PCH files while preprocessing. */ 224 225bool flag_pch_preprocess; 226 227/* The file name to which we should write a precompiled header, or 228 NULL if no header will be written in this compile. */ 229 230const char *pch_file; 231 232/* Nonzero if an ISO standard was selected. It rejects macros in the 233 user's namespace. */ 234int flag_iso; 235 236/* Nonzero if -undef was given. It suppresses target built-in macros 237 and assertions. */ 238int flag_undef; 239 240/* Nonzero means don't recognize the non-ANSI builtin functions. */ 241 242int flag_no_builtin; 243 244/* Nonzero means don't recognize the non-ANSI builtin functions. 245 -ansi sets this. */ 246 247int flag_no_nonansi_builtin; 248 249/* Nonzero means give `double' the same size as `float'. */ 250 251int flag_short_double; 252 253/* Nonzero means give `wchar_t' the same size as `short'. */ 254 255int flag_short_wchar; 256 257/* Nonzero means allow implicit conversions between vectors with 258 differing numbers of subparts and/or differing element types. */ 259int flag_lax_vector_conversions; 260 261/* Nonzero means allow Microsoft extensions without warnings or errors. */ 262int flag_ms_extensions; 263 264/* Nonzero means don't recognize the keyword `asm'. */ 265 266int flag_no_asm; 267 268/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */ 269 270int flag_signed_bitfields = 1; 271 272/* Warn about #pragma directives that are not recognized. */ 273 274int warn_unknown_pragmas; /* Tri state variable. */ 275 276/* Warn about format/argument anomalies in calls to formatted I/O functions 277 (*printf, *scanf, strftime, strfmon, etc.). */ 278 279int warn_format; 280 281/* Warn about using __null (as NULL in C++) as sentinel. For code compiled 282 with GCC this doesn't matter as __null is guaranteed to have the right 283 size. */ 284 285int warn_strict_null_sentinel; 286 287/* Zero means that faster, ...NonNil variants of objc_msgSend... 288 calls will be used in ObjC; passing nil receivers to such calls 289 will most likely result in crashes. */ 290int flag_nil_receivers = 1; 291 292/* Nonzero means that code generation will be altered to support 293 "zero-link" execution. This currently affects ObjC only, but may 294 affect other languages in the future. */ 295int flag_zero_link = 0; 296 297/* Nonzero means emit an '__OBJC, __image_info' for the current translation 298 unit. It will inform the ObjC runtime that class definition(s) herein 299 contained are to replace one(s) previously loaded. */ 300int flag_replace_objc_classes = 0; 301 302/* C/ObjC language option variables. */ 303 304 305/* Nonzero means allow type mismatches in conditional expressions; 306 just make their values `void'. */ 307 308int flag_cond_mismatch; 309 310/* Nonzero means enable C89 Amendment 1 features. */ 311 312int flag_isoc94; 313 314/* Nonzero means use the ISO C99 dialect of C. */ 315 316int flag_isoc99; 317 318/* Nonzero means that we have builtin functions, and main is an int. */ 319 320int flag_hosted = 1; 321 322/* Warn if main is suspicious. */ 323 324int warn_main; 325 326 327/* ObjC language option variables. */ 328 329 330/* Open and close the file for outputting class declarations, if 331 requested (ObjC). */ 332 333int flag_gen_declaration; 334 335/* Tells the compiler that this is a special run. Do not perform any 336 compiling, instead we are to test some platform dependent features 337 and output a C header file with appropriate definitions. */ 338 339int print_struct_values; 340 341/* Tells the compiler what is the constant string class for Objc. */ 342 343const char *constant_string_class_name; 344 345 346/* C++ language option variables. */ 347 348 349/* Nonzero means don't recognize any extension keywords. */ 350 351int flag_no_gnu_keywords; 352 353/* Nonzero means do emit exported implementations of functions even if 354 they can be inlined. */ 355 356int flag_implement_inlines = 1; 357 358/* Nonzero means that implicit instantiations will be emitted if needed. */ 359 360int flag_implicit_templates = 1; 361 362/* Nonzero means that implicit instantiations of inline templates will be 363 emitted if needed, even if instantiations of non-inline templates 364 aren't. */ 365 366int flag_implicit_inline_templates = 1; 367 368/* Nonzero means generate separate instantiation control files and 369 juggle them at link time. */ 370 371int flag_use_repository; 372 373/* Nonzero if we want to issue diagnostics that the standard says are not 374 required. */ 375 376int flag_optional_diags = 1; 377 378/* Nonzero means we should attempt to elide constructors when possible. */ 379 380int flag_elide_constructors = 1; 381 382/* Nonzero means that member functions defined in class scope are 383 inline by default. */ 384 385int flag_default_inline = 1; 386 387/* Controls whether compiler generates 'type descriptor' that give 388 run-time type information. */ 389 390int flag_rtti = 1; 391 392/* Nonzero if we want to conserve space in the .o files. We do this 393 by putting uninitialized data and runtime initialized data into 394 .common instead of .data at the expense of not flagging multiple 395 definitions. */ 396 397int flag_conserve_space; 398 399/* Nonzero if we want to obey access control semantics. */ 400 401int flag_access_control = 1; 402 403/* Nonzero if we want to check the return value of new and avoid calling 404 constructors if it is a null pointer. */ 405 406int flag_check_new; 407 408/* Nonzero if we want the new ISO rules for pushing a new scope for `for' 409 initialization variables. 410 0: Old rules, set by -fno-for-scope. 411 2: New ISO rules, set by -ffor-scope. 412 1: Try to implement new ISO rules, but with backup compatibility 413 (and warnings). This is the default, for now. */ 414 415int flag_new_for_scope = 1; 416 417/* Nonzero if we want to emit defined symbols with common-like linkage as 418 weak symbols where possible, in order to conform to C++ semantics. 419 Otherwise, emit them as local symbols. */ 420 421int flag_weak = 1; 422 423/* 0 means we want the preprocessor to not emit line directives for 424 the current working directory. 1 means we want it to do it. -1 425 means we should decide depending on whether debugging information 426 is being emitted or not. */ 427 428int flag_working_directory = -1; 429 430/* Nonzero to use __cxa_atexit, rather than atexit, to register 431 destructors for local statics and global objects. '2' means it has been 432 set nonzero as a default, not by a command-line flag. */ 433 434int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT; 435 436/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling 437 code. '2' means it has not been set explicitly on the command line. */ 438 439int flag_use_cxa_get_exception_ptr = 2; 440 441/* Nonzero means make the default pedwarns warnings instead of errors. 442 The value of this flag is ignored if -pedantic is specified. */ 443 444int flag_permissive; 445 446/* Nonzero means to implement standard semantics for exception 447 specifications, calling unexpected if an exception is thrown that 448 doesn't match the specification. Zero means to treat them as 449 assertions and optimize accordingly, but not check them. */ 450 451int flag_enforce_eh_specs = 1; 452 453/* Nonzero means to generate thread-safe code for initializing local 454 statics. */ 455 456int flag_threadsafe_statics = 1; 457 458/* Nonzero means warn about implicit declarations. */ 459 460int warn_implicit = 1; 461 462/* Maximum template instantiation depth. This limit is rather 463 arbitrary, but it exists to limit the time it takes to notice 464 infinite template instantiations. */ 465 466int max_tinst_depth = 500; 467 468 469 470/* The elements of `ridpointers' are identifier nodes for the reserved 471 type names and storage classes. It is indexed by a RID_... value. */ 472tree *ridpointers; 473 474tree (*make_fname_decl) (tree, int); 475 476/* Nonzero means the expression being parsed will never be evaluated. 477 This is a count, since unevaluated expressions can nest. */ 478int skip_evaluation; 479 480/* Information about how a function name is generated. */ 481struct fname_var_t 482{ 483 tree *const decl; /* pointer to the VAR_DECL. */ 484 const unsigned rid; /* RID number for the identifier. */ 485 const int pretty; /* How pretty is it? */ 486}; 487 488/* The three ways of getting then name of the current function. */ 489 490const struct fname_var_t fname_vars[] = 491{ 492 /* C99 compliant __func__, must be first. */ 493 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0}, 494 /* GCC __FUNCTION__ compliant. */ 495 {&function_name_decl_node, RID_FUNCTION_NAME, 0}, 496 /* GCC __PRETTY_FUNCTION__ compliant. */ 497 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1}, 498 {NULL, 0, 0}, 499}; 500 501static int constant_fits_type_p (tree, tree); 502static tree check_case_value (tree); 503static bool check_case_bounds (tree, tree, tree *, tree *); 504 505static tree handle_packed_attribute (tree *, tree, tree, int, bool *); 506static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *); 507static tree handle_common_attribute (tree *, tree, tree, int, bool *); 508static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *); 509static tree handle_noinline_attribute (tree *, tree, tree, int, bool *); 510static tree handle_always_inline_attribute (tree *, tree, tree, int, 511 bool *); 512static tree handle_gnu_inline_attribute (tree *, tree, tree, int, 513 bool *); 514static tree handle_flatten_attribute (tree *, tree, tree, int, bool *); 515static tree handle_used_attribute (tree *, tree, tree, int, bool *); 516static tree handle_unused_attribute (tree *, tree, tree, int, bool *); 517static tree handle_externally_visible_attribute (tree *, tree, tree, int, 518 bool *); 519static tree handle_const_attribute (tree *, tree, tree, int, bool *); 520static tree handle_transparent_union_attribute (tree *, tree, tree, 521 int, bool *); 522static tree handle_constructor_attribute (tree *, tree, tree, int, bool *); 523static tree handle_destructor_attribute (tree *, tree, tree, int, bool *); 524static tree handle_mode_attribute (tree *, tree, tree, int, bool *); 525static tree handle_section_attribute (tree *, tree, tree, int, bool *); 526static tree handle_aligned_attribute (tree *, tree, tree, int, bool *); 527static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ; 528static tree handle_alias_attribute (tree *, tree, tree, int, bool *); 529static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ; 530static tree handle_visibility_attribute (tree *, tree, tree, int, 531 bool *); 532static tree handle_tls_model_attribute (tree *, tree, tree, int, 533 bool *); 534static tree handle_no_instrument_function_attribute (tree *, tree, 535 tree, int, bool *); 536static tree handle_malloc_attribute (tree *, tree, tree, int, bool *); 537static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *); 538static tree handle_no_limit_stack_attribute (tree *, tree, tree, int, 539 bool *); 540static tree handle_pure_attribute (tree *, tree, tree, int, bool *); 541static tree handle_novops_attribute (tree *, tree, tree, int, bool *); 542static tree handle_deprecated_attribute (tree *, tree, tree, int, 543 bool *); 544/* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */ 545static tree handle_unavailable_attribute (tree *, tree, tree, int, bool *); 546/* APPLE LOCAL end "unavailable" attribute --ilr */ 547static tree handle_vector_size_attribute (tree *, tree, tree, int, 548 bool *); 549static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *); 550static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *); 551static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *); 552static tree handle_warn_unused_result_attribute (tree *, tree, tree, int, 553 bool *); 554static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *); 555/* APPLE LOCAL radar 5932809 - copyable byref blocks */ 556static tree handle_blocks_attribute (tree *, tree, tree, int, bool *); 557 558static void check_function_nonnull (tree, tree); 559static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT); 560static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT); 561static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *); 562static int resort_field_decl_cmp (const void *, const void *); 563 564/* Table of machine-independent attributes common to all C-like languages. */ 565const struct attribute_spec c_common_attribute_table[] = 566{ 567 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ 568 { "packed", 0, 0, false, false, false, 569 handle_packed_attribute }, 570 { "nocommon", 0, 0, true, false, false, 571 handle_nocommon_attribute }, 572 { "common", 0, 0, true, false, false, 573 handle_common_attribute }, 574 /* FIXME: logically, noreturn attributes should be listed as 575 "false, true, true" and apply to function types. But implementing this 576 would require all the places in the compiler that use TREE_THIS_VOLATILE 577 on a decl to identify non-returning functions to be located and fixed 578 to check the function type instead. */ 579 { "noreturn", 0, 0, true, false, false, 580 handle_noreturn_attribute }, 581 { "volatile", 0, 0, true, false, false, 582 handle_noreturn_attribute }, 583 { "noinline", 0, 0, true, false, false, 584 handle_noinline_attribute }, 585 { "always_inline", 0, 0, true, false, false, 586 handle_always_inline_attribute }, 587 { "gnu_inline", 0, 0, true, false, false, 588 handle_gnu_inline_attribute }, 589 { "flatten", 0, 0, true, false, false, 590 handle_flatten_attribute }, 591 { "used", 0, 0, true, false, false, 592 handle_used_attribute }, 593 { "unused", 0, 0, false, false, false, 594 handle_unused_attribute }, 595 { "externally_visible", 0, 0, true, false, false, 596 handle_externally_visible_attribute }, 597 /* The same comments as for noreturn attributes apply to const ones. */ 598 { "const", 0, 0, true, false, false, 599 handle_const_attribute }, 600 { "transparent_union", 0, 0, false, false, false, 601 handle_transparent_union_attribute }, 602 { "constructor", 0, 0, true, false, false, 603 handle_constructor_attribute }, 604 { "destructor", 0, 0, true, false, false, 605 handle_destructor_attribute }, 606 { "mode", 1, 1, false, true, false, 607 handle_mode_attribute }, 608 { "section", 1, 1, true, false, false, 609 handle_section_attribute }, 610 { "aligned", 0, 1, false, false, false, 611 handle_aligned_attribute }, 612 /* APPLE LOCAL weak types 5954418 */ 613 { "weak", 0, 0, false, false, false, 614 handle_weak_attribute }, 615 { "alias", 1, 1, true, false, false, 616 handle_alias_attribute }, 617 { "weakref", 0, 1, true, false, false, 618 handle_weakref_attribute }, 619 { "no_instrument_function", 0, 0, true, false, false, 620 handle_no_instrument_function_attribute }, 621 { "malloc", 0, 0, true, false, false, 622 handle_malloc_attribute }, 623 { "returns_twice", 0, 0, true, false, false, 624 handle_returns_twice_attribute }, 625 { "no_stack_limit", 0, 0, true, false, false, 626 handle_no_limit_stack_attribute }, 627 { "pure", 0, 0, true, false, false, 628 handle_pure_attribute }, 629 /* For internal use (marking of builtins) only. The name contains space 630 to prevent its usage in source code. */ 631 { "no vops", 0, 0, true, false, false, 632 handle_novops_attribute }, 633 { "deprecated", 0, 0, false, false, false, 634 handle_deprecated_attribute }, 635 /* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */ 636 { "unavailable", 0, 0, false, false, false, 637 handle_unavailable_attribute }, 638 /* APPLE LOCAL end "unavailable" attribute --ilr */ 639 { "vector_size", 1, 1, false, true, false, 640 handle_vector_size_attribute }, 641 { "visibility", 1, 1, false, false, false, 642 handle_visibility_attribute }, 643 { "tls_model", 1, 1, true, false, false, 644 handle_tls_model_attribute }, 645 { "nonnull", 0, -1, false, true, true, 646 handle_nonnull_attribute }, 647 { "nothrow", 0, 0, true, false, false, 648 handle_nothrow_attribute }, 649 { "may_alias", 0, 0, false, true, false, NULL }, 650 { "cleanup", 1, 1, true, false, false, 651 handle_cleanup_attribute }, 652 { "warn_unused_result", 0, 0, false, true, true, 653 handle_warn_unused_result_attribute }, 654 { "sentinel", 0, 1, false, true, true, 655 handle_sentinel_attribute }, 656 /* APPLE LOCAL radar 5932809 - copyable byref blocks */ 657 { "blocks", 1, 1, true, false, false, handle_blocks_attribute }, 658 { NULL, 0, 0, false, false, false, NULL } 659}; 660 661/* Give the specifications for the format attributes, used by C and all 662 descendants. */ 663 664const struct attribute_spec c_common_format_attribute_table[] = 665{ 666 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ 667 { "format", 3, 3, false, true, true, 668 handle_format_attribute }, 669 { "format_arg", 1, 1, false, true, true, 670 handle_format_arg_attribute }, 671 { NULL, 0, 0, false, false, false, NULL } 672}; 673 674/* Push current bindings for the function name VAR_DECLS. */ 675 676void 677start_fname_decls (void) 678{ 679 unsigned ix; 680 tree saved = NULL_TREE; 681 682 for (ix = 0; fname_vars[ix].decl; ix++) 683 { 684 tree decl = *fname_vars[ix].decl; 685 686 if (decl) 687 { 688 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved); 689 *fname_vars[ix].decl = NULL_TREE; 690 } 691 } 692 if (saved || saved_function_name_decls) 693 /* Normally they'll have been NULL, so only push if we've got a 694 stack, or they are non-NULL. */ 695 saved_function_name_decls = tree_cons (saved, NULL_TREE, 696 saved_function_name_decls); 697} 698 699/* Finish up the current bindings, adding them into the current function's 700 statement tree. This must be done _before_ finish_stmt_tree is called. 701 If there is no current function, we must be at file scope and no statements 702 are involved. Pop the previous bindings. */ 703 704void 705finish_fname_decls (void) 706{ 707 unsigned ix; 708 tree stmts = NULL_TREE; 709 tree stack = saved_function_name_decls; 710 711 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack)) 712 append_to_statement_list (TREE_VALUE (stack), &stmts); 713 714 if (stmts) 715 { 716 tree *bodyp = &DECL_SAVED_TREE (current_function_decl); 717 718 if (TREE_CODE (*bodyp) == BIND_EXPR) 719 bodyp = &BIND_EXPR_BODY (*bodyp); 720 721 append_to_statement_list_force (*bodyp, &stmts); 722 *bodyp = stmts; 723 } 724 725 for (ix = 0; fname_vars[ix].decl; ix++) 726 *fname_vars[ix].decl = NULL_TREE; 727 728 if (stack) 729 { 730 /* We had saved values, restore them. */ 731 tree saved; 732 733 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved)) 734 { 735 tree decl = TREE_PURPOSE (saved); 736 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved)); 737 738 *fname_vars[ix].decl = decl; 739 } 740 stack = TREE_CHAIN (stack); 741 } 742 saved_function_name_decls = stack; 743} 744 745/* Return the text name of the current function, suitably prettified 746 by PRETTY_P. Return string must be freed by caller. */ 747 748const char * 749fname_as_string (int pretty_p) 750{ 751 const char *name = "top level"; 752 char *namep; 753 int vrb = 2; 754 755 if (!pretty_p) 756 { 757 name = ""; 758 vrb = 0; 759 } 760 761 if (current_function_decl) 762 name = lang_hooks.decl_printable_name (current_function_decl, vrb); 763 764 if (c_lex_string_translate) 765 { 766 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */ 767 cpp_string cstr = { 0, 0 }, strname; 768 769 namep = XNEWVEC (char, len); 770 snprintf (namep, len, "\"%s\"", name); 771 strname.text = (unsigned char *) namep; 772 strname.len = len - 1; 773 774 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false)) 775 { 776 XDELETEVEC (namep); 777 return (char *) cstr.text; 778 } 779 } 780 else 781 namep = xstrdup (name); 782 783 return namep; 784} 785 786/* Expand DECL if it declares an entity not handled by the 787 common code. */ 788 789int 790c_expand_decl (tree decl) 791{ 792 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl)) 793 { 794 /* Let the back-end know about this variable. */ 795 if (!anon_aggr_type_p (TREE_TYPE (decl))) 796 emit_local_var (decl); 797 else 798 expand_anon_union_decl (decl, NULL_TREE, 799 DECL_ANON_UNION_ELEMS (decl)); 800 } 801 else 802 return 0; 803 804 return 1; 805} 806 807 808/* Return the VAR_DECL for a const char array naming the current 809 function. If the VAR_DECL has not yet been created, create it 810 now. RID indicates how it should be formatted and IDENTIFIER_NODE 811 ID is its name (unfortunately C and C++ hold the RID values of 812 keywords in different places, so we can't derive RID from ID in 813 this language independent code. */ 814 815tree 816fname_decl (unsigned int rid, tree id) 817{ 818 unsigned ix; 819 tree decl = NULL_TREE; 820 821 for (ix = 0; fname_vars[ix].decl; ix++) 822 if (fname_vars[ix].rid == rid) 823 break; 824 825 decl = *fname_vars[ix].decl; 826 if (!decl) 827 { 828 /* If a tree is built here, it would normally have the lineno of 829 the current statement. Later this tree will be moved to the 830 beginning of the function and this line number will be wrong. 831 To avoid this problem set the lineno to 0 here; that prevents 832 it from appearing in the RTL. */ 833 tree stmts; 834 location_t saved_location = input_location; 835#ifdef USE_MAPPED_LOCATION 836 input_location = UNKNOWN_LOCATION; 837#else 838 input_line = 0; 839#endif 840 841 stmts = push_stmt_list (); 842 decl = (*make_fname_decl) (id, fname_vars[ix].pretty); 843 stmts = pop_stmt_list (stmts); 844 if (!IS_EMPTY_STMT (stmts)) 845 saved_function_name_decls 846 = tree_cons (decl, stmts, saved_function_name_decls); 847 *fname_vars[ix].decl = decl; 848 input_location = saved_location; 849 } 850 if (!ix && !current_function_decl) 851 pedwarn ("%qD is not defined outside of function scope", decl); 852 853 return decl; 854} 855 856/* Given a STRING_CST, give it a suitable array-of-chars data type. */ 857 858tree 859fix_string_type (tree value) 860{ 861 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 862 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node; 863 int length = TREE_STRING_LENGTH (value); 864 int nchars; 865 tree e_type, i_type, a_type; 866 867 /* Compute the number of elements, for the array type. */ 868 nchars = wide_flag ? length / wchar_bytes : length; 869 870 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous 871 limit in C++98 Annex B is very large (65536) and is not normative, 872 so we do not diagnose it (warn_overlength_strings is forced off 873 in c_common_post_options). */ 874 if (warn_overlength_strings) 875 { 876 const int nchars_max = flag_isoc99 ? 4095 : 509; 877 const int relevant_std = flag_isoc99 ? 99 : 90; 878 if (nchars - 1 > nchars_max) 879 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not 880 separate the %d from the 'C'. 'ISO' should not be 881 translated, but it may be moved after 'C%d' in languages 882 where modifiers follow nouns. */ 883 pedwarn ("string length %qd is greater than the length %qd " 884 "ISO C%d compilers are required to support", 885 nchars - 1, nchars_max, relevant_std); 886 } 887 888 /* Create the array type for the string constant. The ISO C++ 889 standard says that a string literal has type `const char[N]' or 890 `const wchar_t[N]'. We use the same logic when invoked as a C 891 front-end with -Wwrite-strings. 892 ??? We should change the type of an expression depending on the 893 state of a warning flag. We should just be warning -- see how 894 this is handled in the C++ front-end for the deprecated implicit 895 conversion from string literals to `char*' or `wchar_t*'. 896 897 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified 898 array type being the unqualified version of that type. 899 Therefore, if we are constructing an array of const char, we must 900 construct the matching unqualified array type first. The C front 901 end does not require this, but it does no harm, so we do it 902 unconditionally. */ 903 e_type = wide_flag ? wchar_type_node : char_type_node; 904 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1)); 905 a_type = build_array_type (e_type, i_type); 906 if (c_dialect_cxx() || warn_write_strings) 907 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST); 908 909 TREE_TYPE (value) = a_type; 910 TREE_CONSTANT (value) = 1; 911 TREE_INVARIANT (value) = 1; 912 TREE_READONLY (value) = 1; 913 TREE_STATIC (value) = 1; 914 return value; 915} 916 917/* Print a warning if a constant expression had overflow in folding. 918 Invoke this function on every expression that the language 919 requires to be a constant expression. 920 Note the ANSI C standard says it is erroneous for a 921 constant expression to overflow. */ 922 923void 924constant_expression_warning (tree value) 925{ 926 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST 927 || TREE_CODE (value) == VECTOR_CST 928 || TREE_CODE (value) == COMPLEX_CST) 929 && TREE_CONSTANT_OVERFLOW (value) 930 && warn_overflow 931 && pedantic) 932 pedwarn ("overflow in constant expression"); 933} 934 935/* Print a warning if an expression had overflow in folding and its 936 operands hadn't. 937 938 Invoke this function on every expression that 939 (1) appears in the source code, and 940 (2) is a constant expression that overflowed, and 941 (3) is not already checked by convert_and_check; 942 however, do not invoke this function on operands of explicit casts 943 or when the expression is the result of an operator and any operand 944 already overflowed. */ 945 946void 947overflow_warning (tree value) 948{ 949 if (skip_evaluation) return; 950 951 switch (TREE_CODE (value)) 952 { 953 case INTEGER_CST: 954 warning (OPT_Woverflow, "integer overflow in expression"); 955 break; 956 957 case REAL_CST: 958 warning (OPT_Woverflow, "floating point overflow in expression"); 959 break; 960 961 case VECTOR_CST: 962 warning (OPT_Woverflow, "vector overflow in expression"); 963 break; 964 965 case COMPLEX_CST: 966 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST) 967 warning (OPT_Woverflow, "complex integer overflow in expression"); 968 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST) 969 warning (OPT_Woverflow, "complex floating point overflow in expression"); 970 break; 971 972 default: 973 break; 974 } 975} 976 977/* Print a warning if a large constant is truncated to unsigned, 978 or if -Wconversion is used and a constant < 0 is converted to unsigned. 979 Invoke this function on every expression that might be implicitly 980 converted to an unsigned type. */ 981 982static void 983unsigned_conversion_warning (tree result, tree operand) 984{ 985 tree type = TREE_TYPE (result); 986 987 if (TREE_CODE (operand) == INTEGER_CST 988 && TREE_CODE (type) == INTEGER_TYPE 989 && TYPE_UNSIGNED (type) 990 && skip_evaluation == 0 991 && !int_fits_type_p (operand, type)) 992 { 993 if (!int_fits_type_p (operand, c_common_signed_type (type))) 994 /* This detects cases like converting -129 or 256 to unsigned char. */ 995 warning (OPT_Woverflow, 996 "large integer implicitly truncated to unsigned type"); 997 else 998 warning (OPT_Wconversion, 999 "negative integer implicitly converted to unsigned type"); 1000 } 1001} 1002 1003/* Print a warning about casts that might indicate violation 1004 of strict aliasing rules if -Wstrict-aliasing is used and 1005 strict aliasing mode is in effect. OTYPE is the original 1006 TREE_TYPE of EXPR, and TYPE the type we're casting to. */ 1007 1008bool 1009strict_aliasing_warning (tree otype, tree type, tree expr) 1010{ 1011 if (!(flag_strict_aliasing && POINTER_TYPE_P (type) 1012 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type)))) 1013 return false; 1014 1015 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR 1016 && (DECL_P (TREE_OPERAND (expr, 0)) 1017 || handled_component_p (TREE_OPERAND (expr, 0)))) 1018 { 1019 /* Casting the address of an object to non void pointer. Warn 1020 if the cast breaks type based aliasing. */ 1021 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2) 1022 { 1023 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type " 1024 "might break strict-aliasing rules"); 1025 return true; 1026 } 1027 else 1028 { 1029 /* warn_strict_aliasing >= 3. This includes the default (3). 1030 Only warn if the cast is dereferenced immediately. */ 1031 HOST_WIDE_INT set1 = 1032 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))); 1033 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type)); 1034 1035 if (!alias_sets_conflict_p (set1, set2)) 1036 { 1037 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1038 "pointer will break strict-aliasing rules"); 1039 return true; 1040 } 1041 else if (warn_strict_aliasing == 2 1042 && !alias_sets_might_conflict_p (set1, set2)) 1043 { 1044 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1045 "pointer might break strict-aliasing rules"); 1046 return true; 1047 } 1048 } 1049 } 1050 else 1051 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype))) 1052 { 1053 /* At this level, warn for any conversions, even if an address is 1054 not taken in the same statement. This will likely produce many 1055 false positives, but could be useful to pinpoint problems that 1056 are not revealed at higher levels. */ 1057 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype)); 1058 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type)); 1059 if (!COMPLETE_TYPE_P(type) 1060 || !alias_sets_might_conflict_p (set1, set2)) 1061 { 1062 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1063 "pointer might break strict-aliasing rules"); 1064 return true; 1065 } 1066 } 1067 1068 return false; 1069} 1070 1071 1072/* Print a warning about if (); or if () .. else; constructs 1073 via the special empty statement node that we create. INNER_THEN 1074 and INNER_ELSE are the statement lists of the if and the else 1075 block. */ 1076 1077void 1078empty_body_warning (tree inner_then, tree inner_else) 1079{ 1080 if (extra_warnings) 1081 { 1082 if (TREE_CODE (inner_then) == STATEMENT_LIST 1083 && STATEMENT_LIST_TAIL (inner_then)) 1084 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt; 1085 1086 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST 1087 && STATEMENT_LIST_TAIL (inner_else)) 1088 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt; 1089 1090 if (IS_EMPTY_STMT (inner_then) && !inner_else) 1091 warning (OPT_Wextra, "%Hempty body in an if-statement", 1092 EXPR_LOCUS (inner_then)); 1093 1094 if (inner_else && IS_EMPTY_STMT (inner_else)) 1095 warning (OPT_Wextra, "%Hempty body in an else-statement", 1096 EXPR_LOCUS (inner_else)); 1097 } 1098} 1099 1100 1101/* Nonzero if constant C has a value that is permissible 1102 for type TYPE (an INTEGER_TYPE). */ 1103 1104static int 1105constant_fits_type_p (tree c, tree type) 1106{ 1107 if (TREE_CODE (c) == INTEGER_CST) 1108 return int_fits_type_p (c, type); 1109 1110 c = convert (type, c); 1111 return !TREE_OVERFLOW (c); 1112} 1113 1114 1115/* True if vector types T1 and T2 can be converted to each other 1116 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2 1117 can only be converted with -flax-vector-conversions yet that is not 1118 in effect, emit a note telling the user about that option if such 1119 a note has not previously been emitted. */ 1120bool 1121vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note) 1122{ 1123 static bool emitted_lax_note = false; 1124 bool convertible_lax; 1125 1126 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2)) 1127 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))) 1128 return true; 1129 1130 convertible_lax = 1131 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)) 1132 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE || 1133 TYPE_PRECISION (t1) == TYPE_PRECISION (t2)) 1134 && (INTEGRAL_TYPE_P (TREE_TYPE (t1)) 1135 == INTEGRAL_TYPE_P (TREE_TYPE (t2)))); 1136 1137 if (!convertible_lax || flag_lax_vector_conversions) 1138 return convertible_lax; 1139 1140 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 1141 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2))) 1142 return true; 1143 1144 if (emit_lax_note && !emitted_lax_note) 1145 { 1146 emitted_lax_note = true; 1147 inform ("use -flax-vector-conversions to permit " 1148 "conversions between vectors with differing " 1149 "element types or numbers of subparts"); 1150 } 1151 1152 return false; 1153} 1154 1155/* Convert EXPR to TYPE, warning about conversion problems with constants. 1156 Invoke this function on every expression that is converted implicitly, 1157 i.e. because of language rules and not because of an explicit cast. */ 1158 1159tree 1160convert_and_check (tree type, tree expr) 1161{ 1162 tree t = convert (type, expr); 1163 if (TREE_CODE (t) == INTEGER_CST) 1164 { 1165 if (TREE_OVERFLOW (t)) 1166 { 1167 TREE_OVERFLOW (t) = 0; 1168 1169 /* Do not diagnose overflow in a constant expression merely 1170 because a conversion overflowed. */ 1171 TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr) 1172 && TREE_CONSTANT_OVERFLOW (expr); 1173 1174 /* No warning for converting 0x80000000 to int. */ 1175 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr)) 1176 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE 1177 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr)))) 1178 /* If EXPR fits in the unsigned version of TYPE, 1179 don't warn unless pedantic. */ 1180 if ((pedantic 1181 || TYPE_UNSIGNED (type) 1182 || !constant_fits_type_p (expr, 1183 c_common_unsigned_type (type))) 1184 && skip_evaluation == 0) 1185 warning (OPT_Woverflow, 1186 "overflow in implicit constant conversion"); 1187 } 1188 else 1189 unsigned_conversion_warning (t, expr); 1190 } 1191 return t; 1192} 1193 1194/* A node in a list that describes references to variables (EXPR), which are 1195 either read accesses if WRITER is zero, or write accesses, in which case 1196 WRITER is the parent of EXPR. */ 1197struct tlist 1198{ 1199 struct tlist *next; 1200 tree expr, writer; 1201}; 1202 1203/* Used to implement a cache the results of a call to verify_tree. We only 1204 use this for SAVE_EXPRs. */ 1205struct tlist_cache 1206{ 1207 struct tlist_cache *next; 1208 struct tlist *cache_before_sp; 1209 struct tlist *cache_after_sp; 1210 tree expr; 1211}; 1212 1213/* Obstack to use when allocating tlist structures, and corresponding 1214 firstobj. */ 1215static struct obstack tlist_obstack; 1216static char *tlist_firstobj = 0; 1217 1218/* Keep track of the identifiers we've warned about, so we can avoid duplicate 1219 warnings. */ 1220static struct tlist *warned_ids; 1221/* SAVE_EXPRs need special treatment. We process them only once and then 1222 cache the results. */ 1223static struct tlist_cache *save_expr_cache; 1224 1225static void add_tlist (struct tlist **, struct tlist *, tree, int); 1226static void merge_tlist (struct tlist **, struct tlist *, int); 1227static void verify_tree (tree, struct tlist **, struct tlist **, tree); 1228static int warning_candidate_p (tree); 1229static void warn_for_collisions (struct tlist *); 1230static void warn_for_collisions_1 (tree, tree, struct tlist *, int); 1231static struct tlist *new_tlist (struct tlist *, tree, tree); 1232 1233/* Create a new struct tlist and fill in its fields. */ 1234static struct tlist * 1235new_tlist (struct tlist *next, tree t, tree writer) 1236{ 1237 struct tlist *l; 1238 l = XOBNEW (&tlist_obstack, struct tlist); 1239 l->next = next; 1240 l->expr = t; 1241 l->writer = writer; 1242 return l; 1243} 1244 1245/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER 1246 is nonnull, we ignore any node we find which has a writer equal to it. */ 1247 1248static void 1249add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy) 1250{ 1251 while (add) 1252 { 1253 struct tlist *next = add->next; 1254 if (!copy) 1255 add->next = *to; 1256 if (!exclude_writer || add->writer != exclude_writer) 1257 *to = copy ? new_tlist (*to, add->expr, add->writer) : add; 1258 add = next; 1259 } 1260} 1261 1262/* Merge the nodes of ADD into TO. This merging process is done so that for 1263 each variable that already exists in TO, no new node is added; however if 1264 there is a write access recorded in ADD, and an occurrence on TO is only 1265 a read access, then the occurrence in TO will be modified to record the 1266 write. */ 1267 1268static void 1269merge_tlist (struct tlist **to, struct tlist *add, int copy) 1270{ 1271 struct tlist **end = to; 1272 1273 while (*end) 1274 end = &(*end)->next; 1275 1276 while (add) 1277 { 1278 int found = 0; 1279 struct tlist *tmp2; 1280 struct tlist *next = add->next; 1281 1282 for (tmp2 = *to; tmp2; tmp2 = tmp2->next) 1283 if (tmp2->expr == add->expr) 1284 { 1285 found = 1; 1286 if (!tmp2->writer) 1287 tmp2->writer = add->writer; 1288 } 1289 if (!found) 1290 { 1291 *end = copy ? add : new_tlist (NULL, add->expr, add->writer); 1292 end = &(*end)->next; 1293 *end = 0; 1294 } 1295 add = next; 1296 } 1297} 1298 1299/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable 1300 references in list LIST conflict with it, excluding reads if ONLY writers 1301 is nonzero. */ 1302 1303static void 1304warn_for_collisions_1 (tree written, tree writer, struct tlist *list, 1305 int only_writes) 1306{ 1307 struct tlist *tmp; 1308 1309 /* Avoid duplicate warnings. */ 1310 for (tmp = warned_ids; tmp; tmp = tmp->next) 1311 if (tmp->expr == written) 1312 return; 1313 1314 while (list) 1315 { 1316 if (list->expr == written 1317 && list->writer != writer 1318 && (!only_writes || list->writer) 1319 && DECL_NAME (list->expr)) 1320 { 1321 warned_ids = new_tlist (warned_ids, written, NULL_TREE); 1322 warning (0, "operation on %qE may be undefined", list->expr); 1323 } 1324 list = list->next; 1325 } 1326} 1327 1328/* Given a list LIST of references to variables, find whether any of these 1329 can cause conflicts due to missing sequence points. */ 1330 1331static void 1332warn_for_collisions (struct tlist *list) 1333{ 1334 struct tlist *tmp; 1335 1336 for (tmp = list; tmp; tmp = tmp->next) 1337 { 1338 if (tmp->writer) 1339 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0); 1340 } 1341} 1342 1343/* Return nonzero if X is a tree that can be verified by the sequence point 1344 warnings. */ 1345static int 1346warning_candidate_p (tree x) 1347{ 1348 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL; 1349} 1350 1351/* Walk the tree X, and record accesses to variables. If X is written by the 1352 parent tree, WRITER is the parent. 1353 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this 1354 expression or its only operand forces a sequence point, then everything up 1355 to the sequence point is stored in PBEFORE_SP. Everything else gets stored 1356 in PNO_SP. 1357 Once we return, we will have emitted warnings if any subexpression before 1358 such a sequence point could be undefined. On a higher level, however, the 1359 sequence point may not be relevant, and we'll merge the two lists. 1360 1361 Example: (b++, a) + b; 1362 The call that processes the COMPOUND_EXPR will store the increment of B 1363 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that 1364 processes the PLUS_EXPR will need to merge the two lists so that 1365 eventually, all accesses end up on the same list (and we'll warn about the 1366 unordered subexpressions b++ and b. 1367 1368 A note on merging. If we modify the former example so that our expression 1369 becomes 1370 (b++, b) + a 1371 care must be taken not simply to add all three expressions into the final 1372 PNO_SP list. The function merge_tlist takes care of that by merging the 1373 before-SP list of the COMPOUND_EXPR into its after-SP list in a special 1374 way, so that no more than one access to B is recorded. */ 1375 1376static void 1377verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp, 1378 tree writer) 1379{ 1380 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3; 1381 enum tree_code code; 1382 enum tree_code_class cl; 1383 1384 /* X may be NULL if it is the operand of an empty statement expression 1385 ({ }). */ 1386 if (x == NULL) 1387 return; 1388 1389 restart: 1390 code = TREE_CODE (x); 1391 cl = TREE_CODE_CLASS (code); 1392 1393 if (warning_candidate_p (x)) 1394 { 1395 *pno_sp = new_tlist (*pno_sp, x, writer); 1396 return; 1397 } 1398 1399 switch (code) 1400 { 1401 case CONSTRUCTOR: 1402 return; 1403 1404 case COMPOUND_EXPR: 1405 case TRUTH_ANDIF_EXPR: 1406 case TRUTH_ORIF_EXPR: 1407 tmp_before = tmp_nosp = tmp_list3 = 0; 1408 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 1409 warn_for_collisions (tmp_nosp); 1410 merge_tlist (pbefore_sp, tmp_before, 0); 1411 merge_tlist (pbefore_sp, tmp_nosp, 0); 1412 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE); 1413 merge_tlist (pbefore_sp, tmp_list3, 0); 1414 return; 1415 1416 case COND_EXPR: 1417 tmp_before = tmp_list2 = 0; 1418 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE); 1419 warn_for_collisions (tmp_list2); 1420 merge_tlist (pbefore_sp, tmp_before, 0); 1421 merge_tlist (pbefore_sp, tmp_list2, 1); 1422 1423 tmp_list3 = tmp_nosp = 0; 1424 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE); 1425 warn_for_collisions (tmp_nosp); 1426 merge_tlist (pbefore_sp, tmp_list3, 0); 1427 1428 tmp_list3 = tmp_list2 = 0; 1429 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE); 1430 warn_for_collisions (tmp_list2); 1431 merge_tlist (pbefore_sp, tmp_list3, 0); 1432 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the 1433 two first, to avoid warning for (a ? b++ : b++). */ 1434 merge_tlist (&tmp_nosp, tmp_list2, 0); 1435 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1436 return; 1437 1438 case PREDECREMENT_EXPR: 1439 case PREINCREMENT_EXPR: 1440 case POSTDECREMENT_EXPR: 1441 case POSTINCREMENT_EXPR: 1442 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x); 1443 return; 1444 1445 case MODIFY_EXPR: 1446 tmp_before = tmp_nosp = tmp_list3 = 0; 1447 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE); 1448 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x); 1449 /* Expressions inside the LHS are not ordered wrt. the sequence points 1450 in the RHS. Example: 1451 *a = (a++, 2) 1452 Despite the fact that the modification of "a" is in the before_sp 1453 list (tmp_before), it conflicts with the use of "a" in the LHS. 1454 We can handle this by adding the contents of tmp_list3 1455 to those of tmp_before, and redoing the collision warnings for that 1456 list. */ 1457 add_tlist (&tmp_before, tmp_list3, x, 1); 1458 warn_for_collisions (tmp_before); 1459 /* Exclude the LHS itself here; we first have to merge it into the 1460 tmp_nosp list. This is done to avoid warning for "a = a"; if we 1461 didn't exclude the LHS, we'd get it twice, once as a read and once 1462 as a write. */ 1463 add_tlist (pno_sp, tmp_list3, x, 0); 1464 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1); 1465 1466 merge_tlist (pbefore_sp, tmp_before, 0); 1467 if (warning_candidate_p (TREE_OPERAND (x, 0))) 1468 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0); 1469 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1); 1470 return; 1471 1472 case CALL_EXPR: 1473 /* We need to warn about conflicts among arguments and conflicts between 1474 args and the function address. Side effects of the function address, 1475 however, are not ordered by the sequence point of the call. */ 1476 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0; 1477 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 1478 if (TREE_OPERAND (x, 1)) 1479 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE); 1480 merge_tlist (&tmp_list3, tmp_list2, 0); 1481 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0); 1482 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0); 1483 warn_for_collisions (tmp_before); 1484 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0); 1485 return; 1486 1487 case TREE_LIST: 1488 /* Scan all the list, e.g. indices of multi dimensional array. */ 1489 while (x) 1490 { 1491 tmp_before = tmp_nosp = 0; 1492 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE); 1493 merge_tlist (&tmp_nosp, tmp_before, 0); 1494 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1495 x = TREE_CHAIN (x); 1496 } 1497 return; 1498 1499 case SAVE_EXPR: 1500 { 1501 struct tlist_cache *t; 1502 for (t = save_expr_cache; t; t = t->next) 1503 if (t->expr == x) 1504 break; 1505 1506 if (!t) 1507 { 1508 t = XOBNEW (&tlist_obstack, struct tlist_cache); 1509 t->next = save_expr_cache; 1510 t->expr = x; 1511 save_expr_cache = t; 1512 1513 tmp_before = tmp_nosp = 0; 1514 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 1515 warn_for_collisions (tmp_nosp); 1516 1517 tmp_list3 = 0; 1518 while (tmp_nosp) 1519 { 1520 struct tlist *t = tmp_nosp; 1521 tmp_nosp = t->next; 1522 merge_tlist (&tmp_list3, t, 0); 1523 } 1524 t->cache_before_sp = tmp_before; 1525 t->cache_after_sp = tmp_list3; 1526 } 1527 merge_tlist (pbefore_sp, t->cache_before_sp, 1); 1528 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1); 1529 return; 1530 } 1531 1532 default: 1533 /* For other expressions, simply recurse on their operands. 1534 Manual tail recursion for unary expressions. 1535 Other non-expressions need not be processed. */ 1536 if (cl == tcc_unary) 1537 { 1538 x = TREE_OPERAND (x, 0); 1539 writer = 0; 1540 goto restart; 1541 } 1542 else if (IS_EXPR_CODE_CLASS (cl)) 1543 { 1544 int lp; 1545 int max = TREE_CODE_LENGTH (TREE_CODE (x)); 1546 for (lp = 0; lp < max; lp++) 1547 { 1548 tmp_before = tmp_nosp = 0; 1549 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0); 1550 merge_tlist (&tmp_nosp, tmp_before, 0); 1551 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1552 } 1553 } 1554 return; 1555 } 1556} 1557 1558/* Try to warn for undefined behavior in EXPR due to missing sequence 1559 points. */ 1560 1561void 1562verify_sequence_points (tree expr) 1563{ 1564 struct tlist *before_sp = 0, *after_sp = 0; 1565 1566 warned_ids = 0; 1567 save_expr_cache = 0; 1568 if (tlist_firstobj == 0) 1569 { 1570 gcc_obstack_init (&tlist_obstack); 1571 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0); 1572 } 1573 1574 verify_tree (expr, &before_sp, &after_sp, 0); 1575 warn_for_collisions (after_sp); 1576 obstack_free (&tlist_obstack, tlist_firstobj); 1577} 1578 1579/* Validate the expression after `case' and apply default promotions. */ 1580 1581static tree 1582check_case_value (tree value) 1583{ 1584 if (value == NULL_TREE) 1585 return value; 1586 1587 /* ??? Can we ever get nops here for a valid case value? We 1588 shouldn't for C. */ 1589 STRIP_TYPE_NOPS (value); 1590 /* In C++, the following is allowed: 1591 1592 const int i = 3; 1593 switch (...) { case i: ... } 1594 1595 So, we try to reduce the VALUE to a constant that way. */ 1596 if (c_dialect_cxx ()) 1597 { 1598 value = decl_constant_value (value); 1599 STRIP_TYPE_NOPS (value); 1600 value = fold (value); 1601 } 1602 1603 if (TREE_CODE (value) == INTEGER_CST) 1604 /* Promote char or short to int. */ 1605 value = perform_integral_promotions (value); 1606 else if (value != error_mark_node) 1607 { 1608 error ("case label does not reduce to an integer constant"); 1609 value = error_mark_node; 1610 } 1611 1612 constant_expression_warning (value); 1613 1614 return value; 1615} 1616 1617/* See if the case values LOW and HIGH are in the range of the original 1618 type (i.e. before the default conversion to int) of the switch testing 1619 expression. 1620 TYPE is the promoted type of the testing expression, and ORIG_TYPE is 1621 the type before promoting it. CASE_LOW_P is a pointer to the lower 1622 bound of the case label, and CASE_HIGH_P is the upper bound or NULL 1623 if the case is not a case range. 1624 The caller has to make sure that we are not called with NULL for 1625 CASE_LOW_P (i.e. the default case). 1626 Returns true if the case label is in range of ORIG_TYPE (saturated or 1627 untouched) or false if the label is out of range. */ 1628 1629static bool 1630check_case_bounds (tree type, tree orig_type, 1631 tree *case_low_p, tree *case_high_p) 1632{ 1633 tree min_value, max_value; 1634 tree case_low = *case_low_p; 1635 tree case_high = case_high_p ? *case_high_p : case_low; 1636 1637 /* If there was a problem with the original type, do nothing. */ 1638 if (orig_type == error_mark_node) 1639 return true; 1640 1641 min_value = TYPE_MIN_VALUE (orig_type); 1642 max_value = TYPE_MAX_VALUE (orig_type); 1643 1644 /* Case label is less than minimum for type. */ 1645 if (tree_int_cst_compare (case_low, min_value) < 0 1646 && tree_int_cst_compare (case_high, min_value) < 0) 1647 { 1648 warning (0, "case label value is less than minimum value for type"); 1649 return false; 1650 } 1651 1652 /* Case value is greater than maximum for type. */ 1653 if (tree_int_cst_compare (case_low, max_value) > 0 1654 && tree_int_cst_compare (case_high, max_value) > 0) 1655 { 1656 warning (0, "case label value exceeds maximum value for type"); 1657 return false; 1658 } 1659 1660 /* Saturate lower case label value to minimum. */ 1661 if (tree_int_cst_compare (case_high, min_value) >= 0 1662 && tree_int_cst_compare (case_low, min_value) < 0) 1663 { 1664 warning (0, "lower value in case label range" 1665 " less than minimum value for type"); 1666 case_low = min_value; 1667 } 1668 1669 /* Saturate upper case label value to maximum. */ 1670 if (tree_int_cst_compare (case_low, max_value) <= 0 1671 && tree_int_cst_compare (case_high, max_value) > 0) 1672 { 1673 warning (0, "upper value in case label range" 1674 " exceeds maximum value for type"); 1675 case_high = max_value; 1676 } 1677 1678 if (*case_low_p != case_low) 1679 *case_low_p = convert (type, case_low); 1680 if (case_high_p && *case_high_p != case_high) 1681 *case_high_p = convert (type, case_high); 1682 1683 return true; 1684} 1685 1686/* Return an integer type with BITS bits of precision, 1687 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 1688 1689tree 1690c_common_type_for_size (unsigned int bits, int unsignedp) 1691{ 1692 if (bits == TYPE_PRECISION (integer_type_node)) 1693 return unsignedp ? unsigned_type_node : integer_type_node; 1694 1695 if (bits == TYPE_PRECISION (signed_char_type_node)) 1696 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1697 1698 if (bits == TYPE_PRECISION (short_integer_type_node)) 1699 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1700 1701 if (bits == TYPE_PRECISION (long_integer_type_node)) 1702 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1703 1704 if (bits == TYPE_PRECISION (long_long_integer_type_node)) 1705 return (unsignedp ? long_long_unsigned_type_node 1706 : long_long_integer_type_node); 1707 1708 if (bits == TYPE_PRECISION (widest_integer_literal_type_node)) 1709 return (unsignedp ? widest_unsigned_literal_type_node 1710 : widest_integer_literal_type_node); 1711 1712 if (bits <= TYPE_PRECISION (intQI_type_node)) 1713 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1714 1715 if (bits <= TYPE_PRECISION (intHI_type_node)) 1716 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1717 1718 if (bits <= TYPE_PRECISION (intSI_type_node)) 1719 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1720 1721 if (bits <= TYPE_PRECISION (intDI_type_node)) 1722 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1723 1724 return 0; 1725} 1726 1727/* Used for communication between c_common_type_for_mode and 1728 c_register_builtin_type. */ 1729static GTY(()) tree registered_builtin_types; 1730 1731/* Return a data type that has machine mode MODE. 1732 If the mode is an integer, 1733 then UNSIGNEDP selects between signed and unsigned types. */ 1734 1735tree 1736c_common_type_for_mode (enum machine_mode mode, int unsignedp) 1737{ 1738 tree t; 1739 1740 if (mode == TYPE_MODE (integer_type_node)) 1741 return unsignedp ? unsigned_type_node : integer_type_node; 1742 1743 if (mode == TYPE_MODE (signed_char_type_node)) 1744 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1745 1746 if (mode == TYPE_MODE (short_integer_type_node)) 1747 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1748 1749 if (mode == TYPE_MODE (long_integer_type_node)) 1750 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1751 1752 if (mode == TYPE_MODE (long_long_integer_type_node)) 1753 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 1754 1755 if (mode == TYPE_MODE (widest_integer_literal_type_node)) 1756 return unsignedp ? widest_unsigned_literal_type_node 1757 : widest_integer_literal_type_node; 1758 1759 if (mode == QImode) 1760 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1761 1762 if (mode == HImode) 1763 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1764 1765 if (mode == SImode) 1766 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1767 1768 if (mode == DImode) 1769 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1770 1771#if HOST_BITS_PER_WIDE_INT >= 64 1772 if (mode == TYPE_MODE (intTI_type_node)) 1773 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 1774#endif 1775 1776 if (mode == TYPE_MODE (float_type_node)) 1777 return float_type_node; 1778 1779 if (mode == TYPE_MODE (double_type_node)) 1780 return double_type_node; 1781 1782 if (mode == TYPE_MODE (long_double_type_node)) 1783 return long_double_type_node; 1784 1785 if (mode == TYPE_MODE (void_type_node)) 1786 return void_type_node; 1787 1788 if (mode == TYPE_MODE (build_pointer_type (char_type_node))) 1789 return (unsignedp 1790 ? make_unsigned_type (GET_MODE_PRECISION (mode)) 1791 : make_signed_type (GET_MODE_PRECISION (mode))); 1792 1793 if (mode == TYPE_MODE (build_pointer_type (integer_type_node))) 1794 return (unsignedp 1795 ? make_unsigned_type (GET_MODE_PRECISION (mode)) 1796 : make_signed_type (GET_MODE_PRECISION (mode))); 1797 1798 if (COMPLEX_MODE_P (mode)) 1799 { 1800 enum machine_mode inner_mode; 1801 tree inner_type; 1802 1803 if (mode == TYPE_MODE (complex_float_type_node)) 1804 return complex_float_type_node; 1805 if (mode == TYPE_MODE (complex_double_type_node)) 1806 return complex_double_type_node; 1807 if (mode == TYPE_MODE (complex_long_double_type_node)) 1808 return complex_long_double_type_node; 1809 1810 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp) 1811 return complex_integer_type_node; 1812 1813 inner_mode = GET_MODE_INNER (mode); 1814 inner_type = c_common_type_for_mode (inner_mode, unsignedp); 1815 if (inner_type != NULL_TREE) 1816 return build_complex_type (inner_type); 1817 } 1818 else if (VECTOR_MODE_P (mode)) 1819 { 1820 enum machine_mode inner_mode = GET_MODE_INNER (mode); 1821 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp); 1822 if (inner_type != NULL_TREE) 1823 return build_vector_type_for_mode (inner_type, mode); 1824 } 1825 1826 if (mode == TYPE_MODE (dfloat32_type_node)) 1827 return dfloat32_type_node; 1828 if (mode == TYPE_MODE (dfloat64_type_node)) 1829 return dfloat64_type_node; 1830 if (mode == TYPE_MODE (dfloat128_type_node)) 1831 return dfloat128_type_node; 1832 1833 for (t = registered_builtin_types; t; t = TREE_CHAIN (t)) 1834 if (TYPE_MODE (TREE_VALUE (t)) == mode) 1835 return TREE_VALUE (t); 1836 1837 return 0; 1838} 1839 1840/* Return an unsigned type the same as TYPE in other respects. */ 1841tree 1842c_common_unsigned_type (tree type) 1843{ 1844 tree type1 = TYPE_MAIN_VARIANT (type); 1845 if (type1 == signed_char_type_node || type1 == char_type_node) 1846 return unsigned_char_type_node; 1847 if (type1 == integer_type_node) 1848 return unsigned_type_node; 1849 if (type1 == short_integer_type_node) 1850 return short_unsigned_type_node; 1851 if (type1 == long_integer_type_node) 1852 return long_unsigned_type_node; 1853 if (type1 == long_long_integer_type_node) 1854 return long_long_unsigned_type_node; 1855 if (type1 == widest_integer_literal_type_node) 1856 return widest_unsigned_literal_type_node; 1857#if HOST_BITS_PER_WIDE_INT >= 64 1858 if (type1 == intTI_type_node) 1859 return unsigned_intTI_type_node; 1860#endif 1861 if (type1 == intDI_type_node) 1862 return unsigned_intDI_type_node; 1863 if (type1 == intSI_type_node) 1864 return unsigned_intSI_type_node; 1865 if (type1 == intHI_type_node) 1866 return unsigned_intHI_type_node; 1867 if (type1 == intQI_type_node) 1868 return unsigned_intQI_type_node; 1869 1870 return c_common_signed_or_unsigned_type (1, type); 1871} 1872 1873/* Return a signed type the same as TYPE in other respects. */ 1874 1875tree 1876c_common_signed_type (tree type) 1877{ 1878 tree type1 = TYPE_MAIN_VARIANT (type); 1879 if (type1 == unsigned_char_type_node || type1 == char_type_node) 1880 return signed_char_type_node; 1881 if (type1 == unsigned_type_node) 1882 return integer_type_node; 1883 if (type1 == short_unsigned_type_node) 1884 return short_integer_type_node; 1885 if (type1 == long_unsigned_type_node) 1886 return long_integer_type_node; 1887 if (type1 == long_long_unsigned_type_node) 1888 return long_long_integer_type_node; 1889 if (type1 == widest_unsigned_literal_type_node) 1890 return widest_integer_literal_type_node; 1891#if HOST_BITS_PER_WIDE_INT >= 64 1892 if (type1 == unsigned_intTI_type_node) 1893 return intTI_type_node; 1894#endif 1895 if (type1 == unsigned_intDI_type_node) 1896 return intDI_type_node; 1897 if (type1 == unsigned_intSI_type_node) 1898 return intSI_type_node; 1899 if (type1 == unsigned_intHI_type_node) 1900 return intHI_type_node; 1901 if (type1 == unsigned_intQI_type_node) 1902 return intQI_type_node; 1903 1904 return c_common_signed_or_unsigned_type (0, type); 1905} 1906 1907/* Return a type the same as TYPE except unsigned or 1908 signed according to UNSIGNEDP. */ 1909 1910tree 1911c_common_signed_or_unsigned_type (int unsignedp, tree type) 1912{ 1913 if (!INTEGRAL_TYPE_P (type) 1914 || TYPE_UNSIGNED (type) == unsignedp) 1915 return type; 1916 1917 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not 1918 the precision; they have precision set to match their range, but 1919 may use a wider mode to match an ABI. If we change modes, we may 1920 wind up with bad conversions. For INTEGER_TYPEs in C, must check 1921 the precision as well, so as to yield correct results for 1922 bit-field types. C++ does not have these separate bit-field 1923 types, and producing a signed or unsigned variant of an 1924 ENUMERAL_TYPE may cause other problems as well. */ 1925 1926#define TYPE_OK(node) \ 1927 (TYPE_MODE (type) == TYPE_MODE (node) \ 1928 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node))) 1929 if (TYPE_OK (signed_char_type_node)) 1930 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1931 if (TYPE_OK (integer_type_node)) 1932 return unsignedp ? unsigned_type_node : integer_type_node; 1933 if (TYPE_OK (short_integer_type_node)) 1934 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1935 if (TYPE_OK (long_integer_type_node)) 1936 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1937 if (TYPE_OK (long_long_integer_type_node)) 1938 return (unsignedp ? long_long_unsigned_type_node 1939 : long_long_integer_type_node); 1940 if (TYPE_OK (widest_integer_literal_type_node)) 1941 return (unsignedp ? widest_unsigned_literal_type_node 1942 : widest_integer_literal_type_node); 1943 1944#if HOST_BITS_PER_WIDE_INT >= 64 1945 if (TYPE_OK (intTI_type_node)) 1946 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 1947#endif 1948 if (TYPE_OK (intDI_type_node)) 1949 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1950 if (TYPE_OK (intSI_type_node)) 1951 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1952 if (TYPE_OK (intHI_type_node)) 1953 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1954 if (TYPE_OK (intQI_type_node)) 1955 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1956#undef TYPE_OK 1957 1958 if (c_dialect_cxx ()) 1959 return type; 1960 else 1961 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp); 1962} 1963 1964/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */ 1965 1966tree 1967c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp) 1968{ 1969 /* Extended integer types of the same width as a standard type have 1970 lesser rank, so those of the same width as int promote to int or 1971 unsigned int and are valid for printf formats expecting int or 1972 unsigned int. To avoid such special cases, avoid creating 1973 extended integer types for bit-fields if a standard integer type 1974 is available. */ 1975 if (width == TYPE_PRECISION (integer_type_node)) 1976 return unsignedp ? unsigned_type_node : integer_type_node; 1977 if (width == TYPE_PRECISION (signed_char_type_node)) 1978 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1979 if (width == TYPE_PRECISION (short_integer_type_node)) 1980 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1981 if (width == TYPE_PRECISION (long_integer_type_node)) 1982 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1983 if (width == TYPE_PRECISION (long_long_integer_type_node)) 1984 return (unsignedp ? long_long_unsigned_type_node 1985 : long_long_integer_type_node); 1986 return build_nonstandard_integer_type (width, unsignedp); 1987} 1988 1989/* The C version of the register_builtin_type langhook. */ 1990 1991void 1992c_register_builtin_type (tree type, const char* name) 1993{ 1994 tree decl; 1995 1996 decl = build_decl (TYPE_DECL, get_identifier (name), type); 1997 DECL_ARTIFICIAL (decl) = 1; 1998 if (!TYPE_NAME (type)) 1999 TYPE_NAME (type) = decl; 2000 pushdecl (decl); 2001 2002 registered_builtin_types = tree_cons (0, type, registered_builtin_types); 2003} 2004 2005 2006/* Return the minimum number of bits needed to represent VALUE in a 2007 signed or unsigned type, UNSIGNEDP says which. */ 2008 2009unsigned int 2010min_precision (tree value, int unsignedp) 2011{ 2012 int log; 2013 2014 /* If the value is negative, compute its negative minus 1. The latter 2015 adjustment is because the absolute value of the largest negative value 2016 is one larger than the largest positive value. This is equivalent to 2017 a bit-wise negation, so use that operation instead. */ 2018 2019 if (tree_int_cst_sgn (value) < 0) 2020 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value); 2021 2022 /* Return the number of bits needed, taking into account the fact 2023 that we need one more bit for a signed than unsigned type. */ 2024 2025 if (integer_zerop (value)) 2026 log = 0; 2027 else 2028 log = tree_floor_log2 (value); 2029 2030 return log + 1 + !unsignedp; 2031} 2032 2033/* Print an error message for invalid operands to arith operation 2034 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */ 2035 2036void 2037binary_op_error (enum tree_code code, tree type0, tree type1) 2038{ 2039 const char *opname; 2040 2041 switch (code) 2042 { 2043 case PLUS_EXPR: 2044 opname = "+"; break; 2045 case MINUS_EXPR: 2046 opname = "-"; break; 2047 case MULT_EXPR: 2048 opname = "*"; break; 2049 case MAX_EXPR: 2050 opname = "max"; break; 2051 case MIN_EXPR: 2052 opname = "min"; break; 2053 case EQ_EXPR: 2054 opname = "=="; break; 2055 case NE_EXPR: 2056 opname = "!="; break; 2057 case LE_EXPR: 2058 opname = "<="; break; 2059 case GE_EXPR: 2060 opname = ">="; break; 2061 case LT_EXPR: 2062 opname = "<"; break; 2063 case GT_EXPR: 2064 opname = ">"; break; 2065 case LSHIFT_EXPR: 2066 opname = "<<"; break; 2067 case RSHIFT_EXPR: 2068 opname = ">>"; break; 2069 case TRUNC_MOD_EXPR: 2070 case FLOOR_MOD_EXPR: 2071 opname = "%"; break; 2072 case TRUNC_DIV_EXPR: 2073 case FLOOR_DIV_EXPR: 2074 opname = "/"; break; 2075 case BIT_AND_EXPR: 2076 opname = "&"; break; 2077 case BIT_IOR_EXPR: 2078 opname = "|"; break; 2079 case TRUTH_ANDIF_EXPR: 2080 opname = "&&"; break; 2081 case TRUTH_ORIF_EXPR: 2082 opname = "||"; break; 2083 case BIT_XOR_EXPR: 2084 opname = "^"; break; 2085 default: 2086 gcc_unreachable (); 2087 } 2088 error ("invalid operands to binary %s (have %qT and %qT)", opname, 2089 type0, type1); 2090} 2091 2092/* Subroutine of build_binary_op, used for comparison operations. 2093 See if the operands have both been converted from subword integer types 2094 and, if so, perhaps change them both back to their original type. 2095 This function is also responsible for converting the two operands 2096 to the proper common type for comparison. 2097 2098 The arguments of this function are all pointers to local variables 2099 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, 2100 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. 2101 2102 If this function returns nonzero, it means that the comparison has 2103 a constant value. What this function returns is an expression for 2104 that value. */ 2105 2106tree 2107shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr, 2108 enum tree_code *rescode_ptr) 2109{ 2110 tree type; 2111 tree op0 = *op0_ptr; 2112 tree op1 = *op1_ptr; 2113 int unsignedp0, unsignedp1; 2114 int real1, real2; 2115 tree primop0, primop1; 2116 enum tree_code code = *rescode_ptr; 2117 2118 /* Throw away any conversions to wider types 2119 already present in the operands. */ 2120 2121 primop0 = get_narrower (op0, &unsignedp0); 2122 primop1 = get_narrower (op1, &unsignedp1); 2123 2124 /* Handle the case that OP0 does not *contain* a conversion 2125 but it *requires* conversion to FINAL_TYPE. */ 2126 2127 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) 2128 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 2129 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) 2130 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 2131 2132 /* If one of the operands must be floated, we cannot optimize. */ 2133 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; 2134 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; 2135 2136 /* If first arg is constant, swap the args (changing operation 2137 so value is preserved), for canonicalization. Don't do this if 2138 the second arg is 0. */ 2139 2140 if (TREE_CONSTANT (primop0) 2141 && !integer_zerop (primop1) && !real_zerop (primop1)) 2142 { 2143 tree tem = primop0; 2144 int temi = unsignedp0; 2145 primop0 = primop1; 2146 primop1 = tem; 2147 tem = op0; 2148 op0 = op1; 2149 op1 = tem; 2150 *op0_ptr = op0; 2151 *op1_ptr = op1; 2152 unsignedp0 = unsignedp1; 2153 unsignedp1 = temi; 2154 temi = real1; 2155 real1 = real2; 2156 real2 = temi; 2157 2158 switch (code) 2159 { 2160 case LT_EXPR: 2161 code = GT_EXPR; 2162 break; 2163 case GT_EXPR: 2164 code = LT_EXPR; 2165 break; 2166 case LE_EXPR: 2167 code = GE_EXPR; 2168 break; 2169 case GE_EXPR: 2170 code = LE_EXPR; 2171 break; 2172 default: 2173 break; 2174 } 2175 *rescode_ptr = code; 2176 } 2177 2178 /* If comparing an integer against a constant more bits wide, 2179 maybe we can deduce a value of 1 or 0 independent of the data. 2180 Or else truncate the constant now 2181 rather than extend the variable at run time. 2182 2183 This is only interesting if the constant is the wider arg. 2184 Also, it is not safe if the constant is unsigned and the 2185 variable arg is signed, since in this case the variable 2186 would be sign-extended and then regarded as unsigned. 2187 Our technique fails in this case because the lowest/highest 2188 possible unsigned results don't follow naturally from the 2189 lowest/highest possible values of the variable operand. 2190 For just EQ_EXPR and NE_EXPR there is another technique that 2191 could be used: see if the constant can be faithfully represented 2192 in the other operand's type, by truncating it and reextending it 2193 and see if that preserves the constant's value. */ 2194 2195 if (!real1 && !real2 2196 && TREE_CODE (primop1) == INTEGER_CST 2197 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) 2198 { 2199 int min_gt, max_gt, min_lt, max_lt; 2200 tree maxval, minval; 2201 /* 1 if comparison is nominally unsigned. */ 2202 int unsignedp = TYPE_UNSIGNED (*restype_ptr); 2203 tree val; 2204 2205 type = c_common_signed_or_unsigned_type (unsignedp0, 2206 TREE_TYPE (primop0)); 2207 2208 maxval = TYPE_MAX_VALUE (type); 2209 minval = TYPE_MIN_VALUE (type); 2210 2211 if (unsignedp && !unsignedp0) 2212 *restype_ptr = c_common_signed_type (*restype_ptr); 2213 2214 if (TREE_TYPE (primop1) != *restype_ptr) 2215 { 2216 /* Convert primop1 to target type, but do not introduce 2217 additional overflow. We know primop1 is an int_cst. */ 2218 tree tmp = build_int_cst_wide (*restype_ptr, 2219 TREE_INT_CST_LOW (primop1), 2220 TREE_INT_CST_HIGH (primop1)); 2221 2222 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1), 2223 TREE_CONSTANT_OVERFLOW (primop1)); 2224 } 2225 if (type != *restype_ptr) 2226 { 2227 minval = convert (*restype_ptr, minval); 2228 maxval = convert (*restype_ptr, maxval); 2229 } 2230 2231 if (unsignedp && unsignedp0) 2232 { 2233 min_gt = INT_CST_LT_UNSIGNED (primop1, minval); 2234 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval); 2235 min_lt = INT_CST_LT_UNSIGNED (minval, primop1); 2236 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1); 2237 } 2238 else 2239 { 2240 min_gt = INT_CST_LT (primop1, minval); 2241 max_gt = INT_CST_LT (primop1, maxval); 2242 min_lt = INT_CST_LT (minval, primop1); 2243 max_lt = INT_CST_LT (maxval, primop1); 2244 } 2245 2246 val = 0; 2247 /* This used to be a switch, but Genix compiler can't handle that. */ 2248 if (code == NE_EXPR) 2249 { 2250 if (max_lt || min_gt) 2251 val = truthvalue_true_node; 2252 } 2253 else if (code == EQ_EXPR) 2254 { 2255 if (max_lt || min_gt) 2256 val = truthvalue_false_node; 2257 } 2258 else if (code == LT_EXPR) 2259 { 2260 if (max_lt) 2261 val = truthvalue_true_node; 2262 if (!min_lt) 2263 val = truthvalue_false_node; 2264 } 2265 else if (code == GT_EXPR) 2266 { 2267 if (min_gt) 2268 val = truthvalue_true_node; 2269 if (!max_gt) 2270 val = truthvalue_false_node; 2271 } 2272 else if (code == LE_EXPR) 2273 { 2274 if (!max_gt) 2275 val = truthvalue_true_node; 2276 if (min_gt) 2277 val = truthvalue_false_node; 2278 } 2279 else if (code == GE_EXPR) 2280 { 2281 if (!min_lt) 2282 val = truthvalue_true_node; 2283 if (max_lt) 2284 val = truthvalue_false_node; 2285 } 2286 2287 /* If primop0 was sign-extended and unsigned comparison specd, 2288 we did a signed comparison above using the signed type bounds. 2289 But the comparison we output must be unsigned. 2290 2291 Also, for inequalities, VAL is no good; but if the signed 2292 comparison had *any* fixed result, it follows that the 2293 unsigned comparison just tests the sign in reverse 2294 (positive values are LE, negative ones GE). 2295 So we can generate an unsigned comparison 2296 against an extreme value of the signed type. */ 2297 2298 if (unsignedp && !unsignedp0) 2299 { 2300 if (val != 0) 2301 switch (code) 2302 { 2303 case LT_EXPR: 2304 case GE_EXPR: 2305 primop1 = TYPE_MIN_VALUE (type); 2306 val = 0; 2307 break; 2308 2309 case LE_EXPR: 2310 case GT_EXPR: 2311 primop1 = TYPE_MAX_VALUE (type); 2312 val = 0; 2313 break; 2314 2315 default: 2316 break; 2317 } 2318 type = c_common_unsigned_type (type); 2319 } 2320 2321 if (TREE_CODE (primop0) != INTEGER_CST) 2322 { 2323 if (val == truthvalue_false_node) 2324 warning (0, "comparison is always false due to limited range of data type"); 2325 if (val == truthvalue_true_node) 2326 warning (0, "comparison is always true due to limited range of data type"); 2327 } 2328 2329 if (val != 0) 2330 { 2331 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 2332 if (TREE_SIDE_EFFECTS (primop0)) 2333 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); 2334 return val; 2335 } 2336 2337 /* Value is not predetermined, but do the comparison 2338 in the type of the operand that is not constant. 2339 TYPE is already properly set. */ 2340 } 2341 2342 /* If either arg is decimal float and the other is float, find the 2343 proper common type to use for comparison. */ 2344 else if (real1 && real2 2345 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0))) 2346 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1))))) 2347 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 2348 2349 else if (real1 && real2 2350 && (TYPE_PRECISION (TREE_TYPE (primop0)) 2351 == TYPE_PRECISION (TREE_TYPE (primop1)))) 2352 type = TREE_TYPE (primop0); 2353 2354 /* If args' natural types are both narrower than nominal type 2355 and both extend in the same manner, compare them 2356 in the type of the wider arg. 2357 Otherwise must actually extend both to the nominal 2358 common type lest different ways of extending 2359 alter the result. 2360 (eg, (short)-1 == (unsigned short)-1 should be 0.) */ 2361 2362 else if (unsignedp0 == unsignedp1 && real1 == real2 2363 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) 2364 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) 2365 { 2366 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 2367 type = c_common_signed_or_unsigned_type (unsignedp0 2368 || TYPE_UNSIGNED (*restype_ptr), 2369 type); 2370 /* Make sure shorter operand is extended the right way 2371 to match the longer operand. */ 2372 primop0 2373 = convert (c_common_signed_or_unsigned_type (unsignedp0, 2374 TREE_TYPE (primop0)), 2375 primop0); 2376 primop1 2377 = convert (c_common_signed_or_unsigned_type (unsignedp1, 2378 TREE_TYPE (primop1)), 2379 primop1); 2380 } 2381 else 2382 { 2383 /* Here we must do the comparison on the nominal type 2384 using the args exactly as we received them. */ 2385 type = *restype_ptr; 2386 primop0 = op0; 2387 primop1 = op1; 2388 2389 if (!real1 && !real2 && integer_zerop (primop1) 2390 && TYPE_UNSIGNED (*restype_ptr)) 2391 { 2392 tree value = 0; 2393 switch (code) 2394 { 2395 case GE_EXPR: 2396 /* All unsigned values are >= 0, so we warn if extra warnings 2397 are requested. However, if OP0 is a constant that is 2398 >= 0, the signedness of the comparison isn't an issue, 2399 so suppress the warning. */ 2400 if (extra_warnings && !in_system_header 2401 && !(TREE_CODE (primop0) == INTEGER_CST 2402 && !TREE_OVERFLOW (convert (c_common_signed_type (type), 2403 primop0)))) 2404 warning (0, "comparison of unsigned expression >= 0 is always true"); 2405 value = truthvalue_true_node; 2406 break; 2407 2408 case LT_EXPR: 2409 if (extra_warnings && !in_system_header 2410 && !(TREE_CODE (primop0) == INTEGER_CST 2411 && !TREE_OVERFLOW (convert (c_common_signed_type (type), 2412 primop0)))) 2413 warning (0, "comparison of unsigned expression < 0 is always false"); 2414 value = truthvalue_false_node; 2415 break; 2416 2417 default: 2418 break; 2419 } 2420 2421 if (value != 0) 2422 { 2423 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 2424 if (TREE_SIDE_EFFECTS (primop0)) 2425 return build2 (COMPOUND_EXPR, TREE_TYPE (value), 2426 primop0, value); 2427 return value; 2428 } 2429 } 2430 } 2431 2432 *op0_ptr = convert (type, primop0); 2433 *op1_ptr = convert (type, primop1); 2434 2435 *restype_ptr = truthvalue_type_node; 2436 2437 return 0; 2438} 2439 2440/* Return a tree for the sum or difference (RESULTCODE says which) 2441 of pointer PTROP and integer INTOP. */ 2442 2443tree 2444pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop) 2445{ 2446 tree size_exp, ret; 2447 2448 /* The result is a pointer of the same type that is being added. */ 2449 2450 tree result_type = TREE_TYPE (ptrop); 2451 2452 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) 2453 { 2454 if (pedantic || warn_pointer_arith) 2455 pedwarn ("pointer of type %<void *%> used in arithmetic"); 2456 size_exp = integer_one_node; 2457 } 2458 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) 2459 { 2460 if (pedantic || warn_pointer_arith) 2461 pedwarn ("pointer to a function used in arithmetic"); 2462 size_exp = integer_one_node; 2463 } 2464 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE) 2465 { 2466 if (pedantic || warn_pointer_arith) 2467 pedwarn ("pointer to member function used in arithmetic"); 2468 size_exp = integer_one_node; 2469 } 2470 else 2471 size_exp = size_in_bytes (TREE_TYPE (result_type)); 2472 2473 /* We are manipulating pointer values, so we don't need to warn 2474 about relying on undefined signed overflow. We disable the 2475 warning here because we use integer types so fold won't know that 2476 they are really pointers. */ 2477 fold_defer_overflow_warnings (); 2478 2479 /* If what we are about to multiply by the size of the elements 2480 contains a constant term, apply distributive law 2481 and multiply that constant term separately. 2482 This helps produce common subexpressions. */ 2483 2484 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR) 2485 && !TREE_CONSTANT (intop) 2486 && TREE_CONSTANT (TREE_OPERAND (intop, 1)) 2487 && TREE_CONSTANT (size_exp) 2488 /* If the constant comes from pointer subtraction, 2489 skip this optimization--it would cause an error. */ 2490 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE 2491 /* If the constant is unsigned, and smaller than the pointer size, 2492 then we must skip this optimization. This is because it could cause 2493 an overflow error if the constant is negative but INTOP is not. */ 2494 && (!TYPE_UNSIGNED (TREE_TYPE (intop)) 2495 || (TYPE_PRECISION (TREE_TYPE (intop)) 2496 == TYPE_PRECISION (TREE_TYPE (ptrop))))) 2497 { 2498 enum tree_code subcode = resultcode; 2499 tree int_type = TREE_TYPE (intop); 2500 if (TREE_CODE (intop) == MINUS_EXPR) 2501 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR); 2502 /* Convert both subexpression types to the type of intop, 2503 because weird cases involving pointer arithmetic 2504 can result in a sum or difference with different type args. */ 2505 ptrop = build_binary_op (subcode, ptrop, 2506 convert (int_type, TREE_OPERAND (intop, 1)), 1); 2507 intop = convert (int_type, TREE_OPERAND (intop, 0)); 2508 } 2509 2510 /* Convert the integer argument to a type the same size as sizetype 2511 so the multiply won't overflow spuriously. */ 2512 2513 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype) 2514 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype)) 2515 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype), 2516 TYPE_UNSIGNED (sizetype)), intop); 2517 2518 /* Replace the integer argument with a suitable product by the object size. 2519 Do this multiplication as signed, then convert to the appropriate 2520 pointer type (actually unsigned integral). */ 2521 2522 intop = convert (result_type, 2523 build_binary_op (MULT_EXPR, intop, 2524 convert (TREE_TYPE (intop), size_exp), 1)); 2525 2526 /* Create the sum or difference. */ 2527 ret = fold_build2 (resultcode, result_type, ptrop, intop); 2528 2529 fold_undefer_and_ignore_overflow_warnings (); 2530 2531 return ret; 2532} 2533 2534/* Prepare expr to be an argument of a TRUTH_NOT_EXPR, 2535 or for an `if' or `while' statement or ?..: exp. It should already 2536 have been validated to be of suitable type; otherwise, a bad 2537 diagnostic may result. 2538 2539 This preparation consists of taking the ordinary 2540 representation of an expression expr and producing a valid tree 2541 boolean expression describing whether expr is nonzero. We could 2542 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1), 2543 but we optimize comparisons, &&, ||, and !. 2544 2545 The resulting type should always be `truthvalue_type_node'. */ 2546 2547tree 2548c_common_truthvalue_conversion (tree expr) 2549{ 2550 switch (TREE_CODE (expr)) 2551 { 2552 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR: 2553 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 2554 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR: 2555 case ORDERED_EXPR: case UNORDERED_EXPR: 2556 if (TREE_TYPE (expr) == truthvalue_type_node) 2557 return expr; 2558 return build2 (TREE_CODE (expr), truthvalue_type_node, 2559 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1)); 2560 2561 case TRUTH_ANDIF_EXPR: 2562 case TRUTH_ORIF_EXPR: 2563 case TRUTH_AND_EXPR: 2564 case TRUTH_OR_EXPR: 2565 case TRUTH_XOR_EXPR: 2566 if (TREE_TYPE (expr) == truthvalue_type_node) 2567 return expr; 2568 return build2 (TREE_CODE (expr), truthvalue_type_node, 2569 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)), 2570 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1))); 2571 2572 case TRUTH_NOT_EXPR: 2573 if (TREE_TYPE (expr) == truthvalue_type_node) 2574 return expr; 2575 return build1 (TREE_CODE (expr), truthvalue_type_node, 2576 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0))); 2577 2578 case ERROR_MARK: 2579 return expr; 2580 2581 case INTEGER_CST: 2582 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */ 2583 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0) 2584 ? truthvalue_true_node 2585 : truthvalue_false_node; 2586 2587 case REAL_CST: 2588 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0) 2589 ? truthvalue_true_node 2590 : truthvalue_false_node; 2591 2592 case FUNCTION_DECL: 2593 expr = build_unary_op (ADDR_EXPR, expr, 0); 2594 /* Fall through. */ 2595 2596 case ADDR_EXPR: 2597 { 2598 tree inner = TREE_OPERAND (expr, 0); 2599 if (DECL_P (inner) 2600 && (TREE_CODE (inner) == PARM_DECL 2601 || TREE_CODE (inner) == LABEL_DECL 2602 || !DECL_WEAK (inner))) 2603 { 2604 /* Common Ada/Pascal programmer's mistake. We always warn 2605 about this since it is so bad. */ 2606 warning (OPT_Waddress, 2607 "the address of %qD will always evaluate as %<true%>", 2608 inner); 2609 return truthvalue_true_node; 2610 } 2611 2612 /* If we are taking the address of an external decl, it might be 2613 zero if it is weak, so we cannot optimize. */ 2614 if (DECL_P (inner) 2615 && DECL_EXTERNAL (inner)) 2616 break; 2617 2618 if (TREE_SIDE_EFFECTS (inner)) 2619 return build2 (COMPOUND_EXPR, truthvalue_type_node, 2620 inner, truthvalue_true_node); 2621 else 2622 return truthvalue_true_node; 2623 } 2624 2625 case COMPLEX_EXPR: 2626 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) 2627 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 2628 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)), 2629 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)), 2630 0); 2631 2632 case NEGATE_EXPR: 2633 case ABS_EXPR: 2634 case FLOAT_EXPR: 2635 /* These don't change whether an object is nonzero or zero. */ 2636 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); 2637 2638 case LROTATE_EXPR: 2639 case RROTATE_EXPR: 2640 /* These don't change whether an object is zero or nonzero, but 2641 we can't ignore them if their second arg has side-effects. */ 2642 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 2643 return build2 (COMPOUND_EXPR, truthvalue_type_node, 2644 TREE_OPERAND (expr, 1), 2645 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0))); 2646 else 2647 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); 2648 2649 case COND_EXPR: 2650 /* Distribute the conversion into the arms of a COND_EXPR. */ 2651 return fold_build3 (COND_EXPR, truthvalue_type_node, 2652 TREE_OPERAND (expr, 0), 2653 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)), 2654 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))); 2655 2656 case CONVERT_EXPR: 2657 case NOP_EXPR: 2658 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, 2659 since that affects how `default_conversion' will behave. */ 2660 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE 2661 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) 2662 break; 2663 /* If this is widening the argument, we can ignore it. */ 2664 if (TYPE_PRECISION (TREE_TYPE (expr)) 2665 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) 2666 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); 2667 break; 2668 2669 case MODIFY_EXPR: 2670 if (!TREE_NO_WARNING (expr) 2671 && warn_parentheses) 2672 { 2673 warning (OPT_Wparentheses, 2674 "suggest parentheses around assignment used as truth value"); 2675 TREE_NO_WARNING (expr) = 1; 2676 } 2677 break; 2678 2679 default: 2680 break; 2681 } 2682 2683 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE) 2684 { 2685 tree t = save_expr (expr); 2686 return (build_binary_op 2687 ((TREE_SIDE_EFFECTS (expr) 2688 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 2689 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)), 2690 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)), 2691 0)); 2692 } 2693 2694 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); 2695} 2696 2697static void def_builtin_1 (enum built_in_function fncode, 2698 const char *name, 2699 enum built_in_class fnclass, 2700 tree fntype, tree libtype, 2701 bool both_p, bool fallback_p, bool nonansi_p, 2702 tree fnattrs, bool implicit_p); 2703 2704/* Make a variant type in the proper way for C/C++, propagating qualifiers 2705 down to the element type of an array. */ 2706 2707tree 2708c_build_qualified_type (tree type, int type_quals) 2709{ 2710 if (type == error_mark_node) 2711 return type; 2712 2713 if (TREE_CODE (type) == ARRAY_TYPE) 2714 { 2715 tree t; 2716 tree element_type = c_build_qualified_type (TREE_TYPE (type), 2717 type_quals); 2718 2719 /* See if we already have an identically qualified type. */ 2720 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 2721 { 2722 if (TYPE_QUALS (strip_array_types (t)) == type_quals 2723 && TYPE_NAME (t) == TYPE_NAME (type) 2724 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type) 2725 && attribute_list_equal (TYPE_ATTRIBUTES (t), 2726 TYPE_ATTRIBUTES (type))) 2727 break; 2728 } 2729 if (!t) 2730 { 2731 t = build_variant_type_copy (type); 2732 TREE_TYPE (t) = element_type; 2733 } 2734 return t; 2735 } 2736 2737 /* A restrict-qualified pointer type must be a pointer to object or 2738 incomplete type. Note that the use of POINTER_TYPE_P also allows 2739 REFERENCE_TYPEs, which is appropriate for C++. */ 2740 if ((type_quals & TYPE_QUAL_RESTRICT) 2741 && (!POINTER_TYPE_P (type) 2742 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))) 2743 { 2744 error ("invalid use of %<restrict%>"); 2745 type_quals &= ~TYPE_QUAL_RESTRICT; 2746 } 2747 2748 return build_qualified_type (type, type_quals); 2749} 2750 2751/* Apply the TYPE_QUALS to the new DECL. */ 2752 2753void 2754c_apply_type_quals_to_decl (int type_quals, tree decl) 2755{ 2756 tree type = TREE_TYPE (decl); 2757 2758 if (type == error_mark_node) 2759 return; 2760 2761 if (((type_quals & TYPE_QUAL_CONST) 2762 || (type && TREE_CODE (type) == REFERENCE_TYPE)) 2763 /* An object declared 'const' is only readonly after it is 2764 initialized. We don't have any way of expressing this currently, 2765 so we need to be conservative and unset TREE_READONLY for types 2766 with constructors. Otherwise aliasing code will ignore stores in 2767 an inline constructor. */ 2768 && !(type && TYPE_NEEDS_CONSTRUCTING (type))) 2769 TREE_READONLY (decl) = 1; 2770 if (type_quals & TYPE_QUAL_VOLATILE) 2771 { 2772 TREE_SIDE_EFFECTS (decl) = 1; 2773 TREE_THIS_VOLATILE (decl) = 1; 2774 } 2775 if (type_quals & TYPE_QUAL_RESTRICT) 2776 { 2777 while (type && TREE_CODE (type) == ARRAY_TYPE) 2778 /* Allow 'restrict' on arrays of pointers. 2779 FIXME currently we just ignore it. */ 2780 type = TREE_TYPE (type); 2781 if (!type 2782 || !POINTER_TYPE_P (type) 2783 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))) 2784 error ("invalid use of %<restrict%>"); 2785 else if (flag_strict_aliasing && type == TREE_TYPE (decl)) 2786 /* Indicate we need to make a unique alias set for this pointer. 2787 We can't do it here because it might be pointing to an 2788 incomplete type. */ 2789 DECL_POINTER_ALIAS_SET (decl) = -2; 2790 } 2791} 2792 2793/* Hash function for the problem of multiple type definitions in 2794 different files. This must hash all types that will compare 2795 equal via comptypes to the same value. In practice it hashes 2796 on some of the simple stuff and leaves the details to comptypes. */ 2797 2798static hashval_t 2799c_type_hash (const void *p) 2800{ 2801 int i = 0; 2802 int shift, size; 2803 tree t = (tree) p; 2804 tree t2; 2805 switch (TREE_CODE (t)) 2806 { 2807 /* For pointers, hash on pointee type plus some swizzling. */ 2808 case POINTER_TYPE: 2809 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003; 2810 /* Hash on number of elements and total size. */ 2811 case ENUMERAL_TYPE: 2812 shift = 3; 2813 t2 = TYPE_VALUES (t); 2814 break; 2815 case RECORD_TYPE: 2816 shift = 0; 2817 t2 = TYPE_FIELDS (t); 2818 break; 2819 case QUAL_UNION_TYPE: 2820 shift = 1; 2821 t2 = TYPE_FIELDS (t); 2822 break; 2823 case UNION_TYPE: 2824 shift = 2; 2825 t2 = TYPE_FIELDS (t); 2826 break; 2827 default: 2828 gcc_unreachable (); 2829 } 2830 for (; t2; t2 = TREE_CHAIN (t2)) 2831 i++; 2832 size = TREE_INT_CST_LOW (TYPE_SIZE (t)); 2833 return ((size << 24) | (i << shift)); 2834} 2835 2836static GTY((param_is (union tree_node))) htab_t type_hash_table; 2837 2838/* Return the typed-based alias set for T, which may be an expression 2839 or a type. Return -1 if we don't do anything special. */ 2840 2841HOST_WIDE_INT 2842c_common_get_alias_set (tree t) 2843{ 2844 tree u; 2845 PTR *slot; 2846 2847 /* Permit type-punning when accessing a union, provided the access 2848 is directly through the union. For example, this code does not 2849 permit taking the address of a union member and then storing 2850 through it. Even the type-punning allowed here is a GCC 2851 extension, albeit a common and useful one; the C standard says 2852 that such accesses have implementation-defined behavior. */ 2853 for (u = t; 2854 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF; 2855 u = TREE_OPERAND (u, 0)) 2856 if (TREE_CODE (u) == COMPONENT_REF 2857 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE) 2858 return 0; 2859 2860 /* That's all the expressions we handle specially. */ 2861 if (!TYPE_P (t)) 2862 return -1; 2863 2864 /* The C standard guarantees that any object may be accessed via an 2865 lvalue that has character type. */ 2866 if (t == char_type_node 2867 || t == signed_char_type_node 2868 || t == unsigned_char_type_node) 2869 return 0; 2870 2871 /* If it has the may_alias attribute, it can alias anything. */ 2872 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t))) 2873 return 0; 2874 2875 /* The C standard specifically allows aliasing between signed and 2876 unsigned variants of the same type. We treat the signed 2877 variant as canonical. */ 2878 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t)) 2879 { 2880 tree t1 = c_common_signed_type (t); 2881 2882 /* t1 == t can happen for boolean nodes which are always unsigned. */ 2883 if (t1 != t) 2884 return get_alias_set (t1); 2885 } 2886 else if (POINTER_TYPE_P (t)) 2887 { 2888 tree t1; 2889 2890 /* Unfortunately, there is no canonical form of a pointer type. 2891 In particular, if we have `typedef int I', then `int *', and 2892 `I *' are different types. So, we have to pick a canonical 2893 representative. We do this below. 2894 2895 Technically, this approach is actually more conservative that 2896 it needs to be. In particular, `const int *' and `int *' 2897 should be in different alias sets, according to the C and C++ 2898 standard, since their types are not the same, and so, 2899 technically, an `int **' and `const int **' cannot point at 2900 the same thing. 2901 2902 But, the standard is wrong. In particular, this code is 2903 legal C++: 2904 2905 int *ip; 2906 int **ipp = &ip; 2907 const int* const* cipp = ipp; 2908 2909 And, it doesn't make sense for that to be legal unless you 2910 can dereference IPP and CIPP. So, we ignore cv-qualifiers on 2911 the pointed-to types. This issue has been reported to the 2912 C++ committee. */ 2913 t1 = build_type_no_quals (t); 2914 if (t1 != t) 2915 return get_alias_set (t1); 2916 } 2917 2918 /* Handle the case of multiple type nodes referring to "the same" type, 2919 which occurs with IMA. These share an alias set. FIXME: Currently only 2920 C90 is handled. (In C99 type compatibility is not transitive, which 2921 complicates things mightily. The alias set splay trees can theoretically 2922 represent this, but insertion is tricky when you consider all the 2923 different orders things might arrive in.) */ 2924 2925 if (c_language != clk_c || flag_isoc99) 2926 return -1; 2927 2928 /* Save time if there's only one input file. */ 2929 if (num_in_fnames == 1) 2930 return -1; 2931 2932 /* Pointers need special handling if they point to any type that 2933 needs special handling (below). */ 2934 if (TREE_CODE (t) == POINTER_TYPE) 2935 { 2936 tree t2; 2937 /* Find bottom type under any nested POINTERs. */ 2938 for (t2 = TREE_TYPE (t); 2939 TREE_CODE (t2) == POINTER_TYPE; 2940 t2 = TREE_TYPE (t2)) 2941 ; 2942 if (TREE_CODE (t2) != RECORD_TYPE 2943 && TREE_CODE (t2) != ENUMERAL_TYPE 2944 && TREE_CODE (t2) != QUAL_UNION_TYPE 2945 && TREE_CODE (t2) != UNION_TYPE) 2946 return -1; 2947 if (TYPE_SIZE (t2) == 0) 2948 return -1; 2949 } 2950 /* These are the only cases that need special handling. */ 2951 if (TREE_CODE (t) != RECORD_TYPE 2952 && TREE_CODE (t) != ENUMERAL_TYPE 2953 && TREE_CODE (t) != QUAL_UNION_TYPE 2954 && TREE_CODE (t) != UNION_TYPE 2955 && TREE_CODE (t) != POINTER_TYPE) 2956 return -1; 2957 /* Undefined? */ 2958 if (TYPE_SIZE (t) == 0) 2959 return -1; 2960 2961 /* Look up t in hash table. Only one of the compatible types within each 2962 alias set is recorded in the table. */ 2963 if (!type_hash_table) 2964 type_hash_table = htab_create_ggc (1021, c_type_hash, 2965 (htab_eq) lang_hooks.types_compatible_p, 2966 NULL); 2967 slot = htab_find_slot (type_hash_table, t, INSERT); 2968 if (*slot != NULL) 2969 { 2970 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot); 2971 return TYPE_ALIAS_SET ((tree)*slot); 2972 } 2973 else 2974 /* Our caller will assign and record (in t) a new alias set; all we need 2975 to do is remember t in the hash table. */ 2976 *slot = t; 2977 2978 return -1; 2979} 2980 2981/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the 2982 second parameter indicates which OPERATOR is being applied. The COMPLAIN 2983 flag controls whether we should diagnose possibly ill-formed 2984 constructs or not. */ 2985 2986tree 2987c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain) 2988{ 2989 const char *op_name; 2990 tree value = NULL; 2991 enum tree_code type_code = TREE_CODE (type); 2992 2993 op_name = is_sizeof ? "sizeof" : "__alignof__"; 2994 2995 if (type_code == FUNCTION_TYPE) 2996 { 2997 if (is_sizeof) 2998 { 2999 if (complain && (pedantic || warn_pointer_arith)) 3000 pedwarn ("invalid application of %<sizeof%> to a function type"); 3001 value = size_one_node; 3002 } 3003 else 3004 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); 3005 } 3006 else if (type_code == VOID_TYPE || type_code == ERROR_MARK) 3007 { 3008 if (type_code == VOID_TYPE 3009 && complain && (pedantic || warn_pointer_arith)) 3010 pedwarn ("invalid application of %qs to a void type", op_name); 3011 value = size_one_node; 3012 } 3013 else if (!COMPLETE_TYPE_P (type)) 3014 { 3015 if (complain) 3016 error ("invalid application of %qs to incomplete type %qT ", 3017 op_name, type); 3018 value = size_zero_node; 3019 } 3020 else 3021 { 3022 if (is_sizeof) 3023 /* Convert in case a char is more than one unit. */ 3024 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 3025 size_int (TYPE_PRECISION (char_type_node) 3026 / BITS_PER_UNIT)); 3027 else 3028 value = size_int (TYPE_ALIGN_UNIT (type)); 3029 } 3030 3031 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set. 3032 TYPE_IS_SIZETYPE means that certain things (like overflow) will 3033 never happen. However, this node should really have type 3034 `size_t', which is just a typedef for an ordinary integer type. */ 3035 value = fold_convert (size_type_node, value); 3036 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value))); 3037 3038 return value; 3039} 3040 3041/* Implement the __alignof keyword: Return the minimum required 3042 alignment of EXPR, measured in bytes. For VAR_DECLs, 3043 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set 3044 from an "aligned" __attribute__ specification). */ 3045 3046tree 3047c_alignof_expr (tree expr) 3048{ 3049 tree t; 3050 3051 if (VAR_OR_FUNCTION_DECL_P (expr)) 3052 t = size_int (DECL_ALIGN_UNIT (expr)); 3053 3054 else if (TREE_CODE (expr) == COMPONENT_REF 3055 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1))) 3056 { 3057 error ("%<__alignof%> applied to a bit-field"); 3058 t = size_one_node; 3059 } 3060 else if (TREE_CODE (expr) == COMPONENT_REF 3061 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL) 3062 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1))); 3063 3064 else if (TREE_CODE (expr) == INDIRECT_REF) 3065 { 3066 tree t = TREE_OPERAND (expr, 0); 3067 tree best = t; 3068 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 3069 3070 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR) 3071 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) 3072 { 3073 int thisalign; 3074 3075 t = TREE_OPERAND (t, 0); 3076 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 3077 if (thisalign > bestalign) 3078 best = t, bestalign = thisalign; 3079 } 3080 return c_alignof (TREE_TYPE (TREE_TYPE (best))); 3081 } 3082 else 3083 return c_alignof (TREE_TYPE (expr)); 3084 3085 return fold_convert (size_type_node, t); 3086} 3087 3088/* Handle C and C++ default attributes. */ 3089 3090enum built_in_attribute 3091{ 3092#define DEF_ATTR_NULL_TREE(ENUM) ENUM, 3093#define DEF_ATTR_INT(ENUM, VALUE) ENUM, 3094#define DEF_ATTR_IDENT(ENUM, STRING) ENUM, 3095#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM, 3096#include "builtin-attrs.def" 3097#undef DEF_ATTR_NULL_TREE 3098#undef DEF_ATTR_INT 3099#undef DEF_ATTR_IDENT 3100#undef DEF_ATTR_TREE_LIST 3101 ATTR_LAST 3102}; 3103 3104static GTY(()) tree built_in_attributes[(int) ATTR_LAST]; 3105 3106static void c_init_attributes (void); 3107 3108enum c_builtin_type 3109{ 3110#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME, 3111#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME, 3112#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME, 3113#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME, 3114#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 3115#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 3116#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME, 3117#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME, 3118#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME, 3119#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME, 3120#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME, 3121#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME, 3122#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 3123#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 3124#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \ 3125 NAME, 3126#define DEF_POINTER_TYPE(NAME, TYPE) NAME, 3127#include "builtin-types.def" 3128#undef DEF_PRIMITIVE_TYPE 3129#undef DEF_FUNCTION_TYPE_0 3130#undef DEF_FUNCTION_TYPE_1 3131#undef DEF_FUNCTION_TYPE_2 3132#undef DEF_FUNCTION_TYPE_3 3133#undef DEF_FUNCTION_TYPE_4 3134#undef DEF_FUNCTION_TYPE_5 3135#undef DEF_FUNCTION_TYPE_6 3136#undef DEF_FUNCTION_TYPE_7 3137#undef DEF_FUNCTION_TYPE_VAR_0 3138#undef DEF_FUNCTION_TYPE_VAR_1 3139#undef DEF_FUNCTION_TYPE_VAR_2 3140#undef DEF_FUNCTION_TYPE_VAR_3 3141#undef DEF_FUNCTION_TYPE_VAR_4 3142#undef DEF_FUNCTION_TYPE_VAR_5 3143#undef DEF_POINTER_TYPE 3144 BT_LAST 3145}; 3146 3147typedef enum c_builtin_type builtin_type; 3148 3149/* A temporary array for c_common_nodes_and_builtins. Used in 3150 communication with def_fn_type. */ 3151static tree builtin_types[(int) BT_LAST + 1]; 3152 3153/* A helper function for c_common_nodes_and_builtins. Build function type 3154 for DEF with return type RET and N arguments. If VAR is true, then the 3155 function should be variadic after those N arguments. 3156 3157 Takes special care not to ICE if any of the types involved are 3158 error_mark_node, which indicates that said type is not in fact available 3159 (see builtin_type_for_size). In which case the function type as a whole 3160 should be error_mark_node. */ 3161 3162static void 3163def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...) 3164{ 3165 tree args = NULL, t; 3166 va_list list; 3167 int i; 3168 3169 va_start (list, n); 3170 for (i = 0; i < n; ++i) 3171 { 3172 builtin_type a = va_arg (list, builtin_type); 3173 t = builtin_types[a]; 3174 if (t == error_mark_node) 3175 goto egress; 3176 args = tree_cons (NULL_TREE, t, args); 3177 } 3178 va_end (list); 3179 3180 args = nreverse (args); 3181 if (!var) 3182 args = chainon (args, void_list_node); 3183 3184 t = builtin_types[ret]; 3185 if (t == error_mark_node) 3186 goto egress; 3187 t = build_function_type (t, args); 3188 3189 egress: 3190 builtin_types[def] = t; 3191} 3192 3193/* Build builtin functions common to both C and C++ language 3194 frontends. */ 3195 3196static void 3197c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node) 3198{ 3199#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \ 3200 builtin_types[ENUM] = VALUE; 3201#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \ 3202 def_fn_type (ENUM, RETURN, 0, 0); 3203#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \ 3204 def_fn_type (ENUM, RETURN, 0, 1, ARG1); 3205#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \ 3206 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2); 3207#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 3208 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3); 3209#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 3210 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4); 3211#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 3212 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 3213#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3214 ARG6) \ 3215 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 3216#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3217 ARG6, ARG7) \ 3218 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7); 3219#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \ 3220 def_fn_type (ENUM, RETURN, 1, 0); 3221#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \ 3222 def_fn_type (ENUM, RETURN, 1, 1, ARG1); 3223#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \ 3224 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2); 3225#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 3226 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3); 3227#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 3228 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4); 3229#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 3230 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 3231#define DEF_POINTER_TYPE(ENUM, TYPE) \ 3232 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]); 3233 3234#include "builtin-types.def" 3235 3236#undef DEF_PRIMITIVE_TYPE 3237#undef DEF_FUNCTION_TYPE_1 3238#undef DEF_FUNCTION_TYPE_2 3239#undef DEF_FUNCTION_TYPE_3 3240#undef DEF_FUNCTION_TYPE_4 3241#undef DEF_FUNCTION_TYPE_5 3242#undef DEF_FUNCTION_TYPE_6 3243#undef DEF_FUNCTION_TYPE_VAR_0 3244#undef DEF_FUNCTION_TYPE_VAR_1 3245#undef DEF_FUNCTION_TYPE_VAR_2 3246#undef DEF_FUNCTION_TYPE_VAR_3 3247#undef DEF_FUNCTION_TYPE_VAR_4 3248#undef DEF_FUNCTION_TYPE_VAR_5 3249#undef DEF_POINTER_TYPE 3250 builtin_types[(int) BT_LAST] = NULL_TREE; 3251 3252 c_init_attributes (); 3253 3254#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \ 3255 NONANSI_P, ATTRS, IMPLICIT, COND) \ 3256 if (NAME && COND) \ 3257 def_builtin_1 (ENUM, NAME, CLASS, \ 3258 builtin_types[(int) TYPE], \ 3259 builtin_types[(int) LIBTYPE], \ 3260 BOTH_P, FALLBACK_P, NONANSI_P, \ 3261 built_in_attributes[(int) ATTRS], IMPLICIT); 3262#include "builtins.def" 3263#undef DEF_BUILTIN 3264 3265 build_common_builtin_nodes (); 3266 3267 targetm.init_builtins (); 3268 if (flag_mudflap) 3269 mudflap_init (); 3270} 3271 3272/* Build tree nodes and builtin functions common to both C and C++ language 3273 frontends. */ 3274 3275void 3276c_common_nodes_and_builtins (void) 3277{ 3278 int wchar_type_size; 3279 tree array_domain_type; 3280 tree va_list_ref_type_node; 3281 tree va_list_arg_type_node; 3282 3283 /* Define `int' and `char' first so that dbx will output them first. */ 3284 record_builtin_type (RID_INT, NULL, integer_type_node); 3285 record_builtin_type (RID_CHAR, "char", char_type_node); 3286 3287 /* `signed' is the same as `int'. FIXME: the declarations of "signed", 3288 "unsigned long", "long long unsigned" and "unsigned short" were in C++ 3289 but not C. Are the conditionals here needed? */ 3290 if (c_dialect_cxx ()) 3291 record_builtin_type (RID_SIGNED, NULL, integer_type_node); 3292 record_builtin_type (RID_LONG, "long int", long_integer_type_node); 3293 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node); 3294 record_builtin_type (RID_MAX, "long unsigned int", 3295 long_unsigned_type_node); 3296 if (c_dialect_cxx ()) 3297 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node); 3298 record_builtin_type (RID_MAX, "long long int", 3299 long_long_integer_type_node); 3300 record_builtin_type (RID_MAX, "long long unsigned int", 3301 long_long_unsigned_type_node); 3302 if (c_dialect_cxx ()) 3303 record_builtin_type (RID_MAX, "long long unsigned", 3304 long_long_unsigned_type_node); 3305 record_builtin_type (RID_SHORT, "short int", short_integer_type_node); 3306 record_builtin_type (RID_MAX, "short unsigned int", 3307 short_unsigned_type_node); 3308 if (c_dialect_cxx ()) 3309 record_builtin_type (RID_MAX, "unsigned short", 3310 short_unsigned_type_node); 3311 3312 /* Define both `signed char' and `unsigned char'. */ 3313 record_builtin_type (RID_MAX, "signed char", signed_char_type_node); 3314 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node); 3315 3316 /* These are types that c_common_type_for_size and 3317 c_common_type_for_mode use. */ 3318 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3319 intQI_type_node)); 3320 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3321 intHI_type_node)); 3322 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3323 intSI_type_node)); 3324 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3325 intDI_type_node)); 3326#if HOST_BITS_PER_WIDE_INT >= 64 3327 if (targetm.scalar_mode_supported_p (TImode)) 3328 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, 3329 get_identifier ("__int128_t"), 3330 intTI_type_node)); 3331#endif 3332 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3333 unsigned_intQI_type_node)); 3334 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3335 unsigned_intHI_type_node)); 3336 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3337 unsigned_intSI_type_node)); 3338 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3339 unsigned_intDI_type_node)); 3340#if HOST_BITS_PER_WIDE_INT >= 64 3341 if (targetm.scalar_mode_supported_p (TImode)) 3342 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, 3343 get_identifier ("__uint128_t"), 3344 unsigned_intTI_type_node)); 3345#endif 3346 3347 /* Create the widest literal types. */ 3348 widest_integer_literal_type_node 3349 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2); 3350 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3351 widest_integer_literal_type_node)); 3352 3353 widest_unsigned_literal_type_node 3354 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2); 3355 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, 3356 widest_unsigned_literal_type_node)); 3357 3358 /* `unsigned long' is the standard type for sizeof. 3359 Note that stddef.h uses `unsigned long', 3360 and this must agree, even if long and int are the same size. */ 3361 size_type_node = 3362 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE))); 3363 signed_size_type_node = c_common_signed_type (size_type_node); 3364 set_sizetype (size_type_node); 3365 3366 pid_type_node = 3367 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE))); 3368 3369 build_common_tree_nodes_2 (flag_short_double); 3370 3371 record_builtin_type (RID_FLOAT, NULL, float_type_node); 3372 record_builtin_type (RID_DOUBLE, NULL, double_type_node); 3373 record_builtin_type (RID_MAX, "long double", long_double_type_node); 3374 3375 /* Only supported decimal floating point extension if the target 3376 actually supports underlying modes. */ 3377 if (targetm.scalar_mode_supported_p (SDmode) 3378 && targetm.scalar_mode_supported_p (DDmode) 3379 && targetm.scalar_mode_supported_p (TDmode)) 3380 { 3381 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node); 3382 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node); 3383 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node); 3384 } 3385 3386 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, 3387 get_identifier ("complex int"), 3388 complex_integer_type_node)); 3389 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, 3390 get_identifier ("complex float"), 3391 complex_float_type_node)); 3392 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, 3393 get_identifier ("complex double"), 3394 complex_double_type_node)); 3395 lang_hooks.decls.pushdecl 3396 (build_decl (TYPE_DECL, get_identifier ("complex long double"), 3397 complex_long_double_type_node)); 3398 3399 if (c_dialect_cxx ()) 3400 /* For C++, make fileptr_type_node a distinct void * type until 3401 FILE type is defined. */ 3402 fileptr_type_node = build_variant_type_copy (ptr_type_node); 3403 3404 record_builtin_type (RID_VOID, NULL, void_type_node); 3405 3406 /* This node must not be shared. */ 3407 void_zero_node = make_node (INTEGER_CST); 3408 TREE_TYPE (void_zero_node) = void_type_node; 3409 3410 void_list_node = build_void_list_node (); 3411 3412 /* Make a type to be the domain of a few array types 3413 whose domains don't really matter. 3414 200 is small enough that it always fits in size_t 3415 and large enough that it can hold most function names for the 3416 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */ 3417 array_domain_type = build_index_type (size_int (200)); 3418 3419 /* Make a type for arrays of characters. 3420 With luck nothing will ever really depend on the length of this 3421 array type. */ 3422 char_array_type_node 3423 = build_array_type (char_type_node, array_domain_type); 3424 3425 /* Likewise for arrays of ints. */ 3426 int_array_type_node 3427 = build_array_type (integer_type_node, array_domain_type); 3428 3429 string_type_node = build_pointer_type (char_type_node); 3430 const_string_type_node 3431 = build_pointer_type (build_qualified_type 3432 (char_type_node, TYPE_QUAL_CONST)); 3433 3434 /* This is special for C++ so functions can be overloaded. */ 3435 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE); 3436 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node)); 3437 wchar_type_size = TYPE_PRECISION (wchar_type_node); 3438 if (c_dialect_cxx ()) 3439 { 3440 if (TYPE_UNSIGNED (wchar_type_node)) 3441 wchar_type_node = make_unsigned_type (wchar_type_size); 3442 else 3443 wchar_type_node = make_signed_type (wchar_type_size); 3444 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node); 3445 } 3446 else 3447 { 3448 signed_wchar_type_node = c_common_signed_type (wchar_type_node); 3449 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node); 3450 } 3451 3452 /* This is for wide string constants. */ 3453 wchar_array_type_node 3454 = build_array_type (wchar_type_node, array_domain_type); 3455 3456 wint_type_node = 3457 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE))); 3458 3459 intmax_type_node = 3460 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE))); 3461 uintmax_type_node = 3462 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE))); 3463 3464 default_function_type = build_function_type (integer_type_node, NULL_TREE); 3465 ptrdiff_type_node 3466 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE))); 3467 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node); 3468 3469 lang_hooks.decls.pushdecl 3470 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"), 3471 va_list_type_node)); 3472 3473 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE) 3474 { 3475 va_list_arg_type_node = va_list_ref_type_node = 3476 build_pointer_type (TREE_TYPE (va_list_type_node)); 3477 } 3478 else 3479 { 3480 va_list_arg_type_node = va_list_type_node; 3481 va_list_ref_type_node = build_reference_type (va_list_type_node); 3482 } 3483 3484 if (!flag_preprocess_only) 3485 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node); 3486 3487 main_identifier_node = get_identifier ("main"); 3488 3489 /* Create the built-in __null node. It is important that this is 3490 not shared. */ 3491 null_node = make_node (INTEGER_CST); 3492 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); 3493 3494 /* Since builtin_types isn't gc'ed, don't export these nodes. */ 3495 memset (builtin_types, 0, sizeof (builtin_types)); 3496} 3497 3498/* Look up the function in built_in_decls that corresponds to DECL 3499 and set ASMSPEC as its user assembler name. DECL must be a 3500 function decl that declares a builtin. */ 3501 3502void 3503set_builtin_user_assembler_name (tree decl, const char *asmspec) 3504{ 3505 tree builtin; 3506 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 3507 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 3508 && asmspec != 0); 3509 3510 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)]; 3511 set_user_assembler_name (builtin, asmspec); 3512 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY) 3513 init_block_move_fn (asmspec); 3514 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET) 3515 init_block_clear_fn (asmspec); 3516} 3517 3518/* The number of named compound-literals generated thus far. */ 3519static GTY(()) int compound_literal_number; 3520 3521/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */ 3522 3523void 3524set_compound_literal_name (tree decl) 3525{ 3526 char *name; 3527 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", 3528 compound_literal_number); 3529 compound_literal_number++; 3530 DECL_NAME (decl) = get_identifier (name); 3531} 3532 3533tree 3534build_va_arg (tree expr, tree type) 3535{ 3536 return build1 (VA_ARG_EXPR, type, expr); 3537} 3538 3539 3540/* Linked list of disabled built-in functions. */ 3541 3542typedef struct disabled_builtin 3543{ 3544 const char *name; 3545 struct disabled_builtin *next; 3546} disabled_builtin; 3547static disabled_builtin *disabled_builtins = NULL; 3548 3549static bool builtin_function_disabled_p (const char *); 3550 3551/* Disable a built-in function specified by -fno-builtin-NAME. If NAME 3552 begins with "__builtin_", give an error. */ 3553 3554void 3555disable_builtin_function (const char *name) 3556{ 3557 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0) 3558 error ("cannot disable built-in function %qs", name); 3559 else 3560 { 3561 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin); 3562 new_disabled_builtin->name = name; 3563 new_disabled_builtin->next = disabled_builtins; 3564 disabled_builtins = new_disabled_builtin; 3565 } 3566} 3567 3568 3569/* Return true if the built-in function NAME has been disabled, false 3570 otherwise. */ 3571 3572static bool 3573builtin_function_disabled_p (const char *name) 3574{ 3575 disabled_builtin *p; 3576 for (p = disabled_builtins; p != NULL; p = p->next) 3577 { 3578 if (strcmp (name, p->name) == 0) 3579 return true; 3580 } 3581 return false; 3582} 3583 3584 3585/* Worker for DEF_BUILTIN. 3586 Possibly define a builtin function with one or two names. 3587 Does not declare a non-__builtin_ function if flag_no_builtin, or if 3588 nonansi_p and flag_no_nonansi_builtin. */ 3589 3590static void 3591def_builtin_1 (enum built_in_function fncode, 3592 const char *name, 3593 enum built_in_class fnclass, 3594 tree fntype, tree libtype, 3595 bool both_p, bool fallback_p, bool nonansi_p, 3596 tree fnattrs, bool implicit_p) 3597{ 3598 tree decl; 3599 const char *libname; 3600 3601 if (fntype == error_mark_node) 3602 return; 3603 3604 gcc_assert ((!both_p && !fallback_p) 3605 || !strncmp (name, "__builtin_", 3606 strlen ("__builtin_"))); 3607 3608 libname = name + strlen ("__builtin_"); 3609 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass, 3610 (fallback_p ? libname : NULL), 3611 fnattrs); 3612 if (both_p 3613 && !flag_no_builtin && !builtin_function_disabled_p (libname) 3614 && !(nonansi_p && flag_no_nonansi_builtin)) 3615 lang_hooks.builtin_function (libname, libtype, fncode, fnclass, 3616 NULL, fnattrs); 3617 3618 built_in_decls[(int) fncode] = decl; 3619 if (implicit_p) 3620 implicit_built_in_decls[(int) fncode] = decl; 3621} 3622 3623/* Nonzero if the type T promotes to int. This is (nearly) the 3624 integral promotions defined in ISO C99 6.3.1.1/2. */ 3625 3626bool 3627c_promoting_integer_type_p (tree t) 3628{ 3629 switch (TREE_CODE (t)) 3630 { 3631 case INTEGER_TYPE: 3632 return (TYPE_MAIN_VARIANT (t) == char_type_node 3633 || TYPE_MAIN_VARIANT (t) == signed_char_type_node 3634 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node 3635 || TYPE_MAIN_VARIANT (t) == short_integer_type_node 3636 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node 3637 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node)); 3638 3639 case ENUMERAL_TYPE: 3640 /* ??? Technically all enumerations not larger than an int 3641 promote to an int. But this is used along code paths 3642 that only want to notice a size change. */ 3643 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node); 3644 3645 case BOOLEAN_TYPE: 3646 return 1; 3647 3648 default: 3649 return 0; 3650 } 3651} 3652 3653/* Return 1 if PARMS specifies a fixed number of parameters 3654 and none of their types is affected by default promotions. */ 3655 3656int 3657self_promoting_args_p (tree parms) 3658{ 3659 tree t; 3660 for (t = parms; t; t = TREE_CHAIN (t)) 3661 { 3662 tree type = TREE_VALUE (t); 3663 3664 if (type == error_mark_node) 3665 continue; 3666 3667 if (TREE_CHAIN (t) == 0 && type != void_type_node) 3668 return 0; 3669 3670 if (type == 0) 3671 return 0; 3672 3673 if (TYPE_MAIN_VARIANT (type) == float_type_node) 3674 return 0; 3675 3676 if (c_promoting_integer_type_p (type)) 3677 return 0; 3678 } 3679 return 1; 3680} 3681 3682/* Recursively examines the array elements of TYPE, until a non-array 3683 element type is found. */ 3684 3685tree 3686strip_array_types (tree type) 3687{ 3688 while (TREE_CODE (type) == ARRAY_TYPE) 3689 type = TREE_TYPE (type); 3690 3691 return type; 3692} 3693 3694/* Recursively remove any '*' or '&' operator from TYPE. */ 3695tree 3696strip_pointer_operator (tree t) 3697{ 3698 while (POINTER_TYPE_P (t)) 3699 t = TREE_TYPE (t); 3700 return t; 3701} 3702 3703/* Used to compare case labels. K1 and K2 are actually tree nodes 3704 representing case labels, or NULL_TREE for a `default' label. 3705 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after 3706 K2, and 0 if K1 and K2 are equal. */ 3707 3708int 3709case_compare (splay_tree_key k1, splay_tree_key k2) 3710{ 3711 /* Consider a NULL key (such as arises with a `default' label) to be 3712 smaller than anything else. */ 3713 if (!k1) 3714 return k2 ? -1 : 0; 3715 else if (!k2) 3716 return k1 ? 1 : 0; 3717 3718 return tree_int_cst_compare ((tree) k1, (tree) k2); 3719} 3720 3721/* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If 3722 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is 3723 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then 3724 case label was declared using the usual C/C++ syntax, rather than 3725 the GNU case range extension. CASES is a tree containing all the 3726 case ranges processed so far; COND is the condition for the 3727 switch-statement itself. Returns the CASE_LABEL_EXPR created, or 3728 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */ 3729 3730tree 3731c_add_case_label (splay_tree cases, tree cond, tree orig_type, 3732 tree low_value, tree high_value) 3733{ 3734 tree type; 3735 tree label; 3736 tree case_label; 3737 splay_tree_node node; 3738 3739 /* Create the LABEL_DECL itself. */ 3740 label = create_artificial_label (); 3741 3742 /* If there was an error processing the switch condition, bail now 3743 before we get more confused. */ 3744 if (!cond || cond == error_mark_node) 3745 goto error_out; 3746 3747 if ((low_value && TREE_TYPE (low_value) 3748 && POINTER_TYPE_P (TREE_TYPE (low_value))) 3749 || (high_value && TREE_TYPE (high_value) 3750 && POINTER_TYPE_P (TREE_TYPE (high_value)))) 3751 { 3752 error ("pointers are not permitted as case values"); 3753 goto error_out; 3754 } 3755 3756 /* Case ranges are a GNU extension. */ 3757 if (high_value && pedantic) 3758 pedwarn ("range expressions in switch statements are non-standard"); 3759 3760 type = TREE_TYPE (cond); 3761 if (low_value) 3762 { 3763 low_value = check_case_value (low_value); 3764 low_value = convert_and_check (type, low_value); 3765 if (low_value == error_mark_node) 3766 goto error_out; 3767 } 3768 if (high_value) 3769 { 3770 high_value = check_case_value (high_value); 3771 high_value = convert_and_check (type, high_value); 3772 if (high_value == error_mark_node) 3773 goto error_out; 3774 } 3775 3776 if (low_value && high_value) 3777 { 3778 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't 3779 really a case range, even though it was written that way. 3780 Remove the HIGH_VALUE to simplify later processing. */ 3781 if (tree_int_cst_equal (low_value, high_value)) 3782 high_value = NULL_TREE; 3783 else if (!tree_int_cst_lt (low_value, high_value)) 3784 warning (0, "empty range specified"); 3785 } 3786 3787 /* See if the case is in range of the type of the original testing 3788 expression. If both low_value and high_value are out of range, 3789 don't insert the case label and return NULL_TREE. */ 3790 if (low_value 3791 && !check_case_bounds (type, orig_type, 3792 &low_value, high_value ? &high_value : NULL)) 3793 return NULL_TREE; 3794 3795 /* Look up the LOW_VALUE in the table of case labels we already 3796 have. */ 3797 node = splay_tree_lookup (cases, (splay_tree_key) low_value); 3798 /* If there was not an exact match, check for overlapping ranges. 3799 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE; 3800 that's a `default' label and the only overlap is an exact match. */ 3801 if (!node && (low_value || high_value)) 3802 { 3803 splay_tree_node low_bound; 3804 splay_tree_node high_bound; 3805 3806 /* Even though there wasn't an exact match, there might be an 3807 overlap between this case range and another case range. 3808 Since we've (inductively) not allowed any overlapping case 3809 ranges, we simply need to find the greatest low case label 3810 that is smaller that LOW_VALUE, and the smallest low case 3811 label that is greater than LOW_VALUE. If there is an overlap 3812 it will occur in one of these two ranges. */ 3813 low_bound = splay_tree_predecessor (cases, 3814 (splay_tree_key) low_value); 3815 high_bound = splay_tree_successor (cases, 3816 (splay_tree_key) low_value); 3817 3818 /* Check to see if the LOW_BOUND overlaps. It is smaller than 3819 the LOW_VALUE, so there is no need to check unless the 3820 LOW_BOUND is in fact itself a case range. */ 3821 if (low_bound 3822 && CASE_HIGH ((tree) low_bound->value) 3823 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value), 3824 low_value) >= 0) 3825 node = low_bound; 3826 /* Check to see if the HIGH_BOUND overlaps. The low end of that 3827 range is bigger than the low end of the current range, so we 3828 are only interested if the current range is a real range, and 3829 not an ordinary case label. */ 3830 else if (high_bound 3831 && high_value 3832 && (tree_int_cst_compare ((tree) high_bound->key, 3833 high_value) 3834 <= 0)) 3835 node = high_bound; 3836 } 3837 /* If there was an overlap, issue an error. */ 3838 if (node) 3839 { 3840 tree duplicate = CASE_LABEL ((tree) node->value); 3841 3842 if (high_value) 3843 { 3844 error ("duplicate (or overlapping) case value"); 3845 error ("%Jthis is the first entry overlapping that value", duplicate); 3846 } 3847 else if (low_value) 3848 { 3849 error ("duplicate case value") ; 3850 error ("%Jpreviously used here", duplicate); 3851 } 3852 else 3853 { 3854 error ("multiple default labels in one switch"); 3855 error ("%Jthis is the first default label", duplicate); 3856 } 3857 goto error_out; 3858 } 3859 3860 /* Add a CASE_LABEL to the statement-tree. */ 3861 case_label = add_stmt (build_case_label (low_value, high_value, label)); 3862 /* Register this case label in the splay tree. */ 3863 splay_tree_insert (cases, 3864 (splay_tree_key) low_value, 3865 (splay_tree_value) case_label); 3866 3867 return case_label; 3868 3869 error_out: 3870 /* Add a label so that the back-end doesn't think that the beginning of 3871 the switch is unreachable. Note that we do not add a case label, as 3872 that just leads to duplicates and thence to failure later on. */ 3873 if (!cases->root) 3874 { 3875 tree t = create_artificial_label (); 3876 add_stmt (build_stmt (LABEL_EXPR, t)); 3877 } 3878 return error_mark_node; 3879} 3880 3881/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach. 3882 Used to verify that case values match up with enumerator values. */ 3883 3884static void 3885match_case_to_enum_1 (tree key, tree type, tree label) 3886{ 3887 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1]; 3888 3889 /* ??? Not working too hard to print the double-word value. 3890 Should perhaps be done with %lwd in the diagnostic routines? */ 3891 if (TREE_INT_CST_HIGH (key) == 0) 3892 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED, 3893 TREE_INT_CST_LOW (key)); 3894 else if (!TYPE_UNSIGNED (type) 3895 && TREE_INT_CST_HIGH (key) == -1 3896 && TREE_INT_CST_LOW (key) != 0) 3897 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED, 3898 -TREE_INT_CST_LOW (key)); 3899 else 3900 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX, 3901 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key)); 3902 3903 if (TYPE_NAME (type) == 0) 3904 warning (0, "%Jcase value %qs not in enumerated type", 3905 CASE_LABEL (label), buf); 3906 else 3907 warning (0, "%Jcase value %qs not in enumerated type %qT", 3908 CASE_LABEL (label), buf, type); 3909} 3910 3911/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach. 3912 Used to verify that case values match up with enumerator values. */ 3913 3914static int 3915match_case_to_enum (splay_tree_node node, void *data) 3916{ 3917 tree label = (tree) node->value; 3918 tree type = (tree) data; 3919 3920 /* Skip default case. */ 3921 if (!CASE_LOW (label)) 3922 return 0; 3923 3924 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear 3925 when we did our enum->case scan. Reset our scratch bit after. */ 3926 if (!CASE_LOW_SEEN (label)) 3927 match_case_to_enum_1 (CASE_LOW (label), type, label); 3928 else 3929 CASE_LOW_SEEN (label) = 0; 3930 3931 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is 3932 not set, that means that CASE_HIGH did not appear when we did our 3933 enum->case scan. Reset our scratch bit after. */ 3934 if (CASE_HIGH (label)) 3935 { 3936 if (!CASE_HIGH_SEEN (label)) 3937 match_case_to_enum_1 (CASE_HIGH (label), type, label); 3938 else 3939 CASE_HIGH_SEEN (label) = 0; 3940 } 3941 3942 return 0; 3943} 3944 3945/* Handle -Wswitch*. Called from the front end after parsing the 3946 switch construct. */ 3947/* ??? Should probably be somewhere generic, since other languages 3948 besides C and C++ would want this. At the moment, however, C/C++ 3949 are the only tree-ssa languages that support enumerations at all, 3950 so the point is moot. */ 3951 3952void 3953c_do_switch_warnings (splay_tree cases, location_t switch_location, 3954 tree type, tree cond) 3955{ 3956 splay_tree_node default_node; 3957 splay_tree_node node; 3958 tree chain; 3959 3960 if (!warn_switch && !warn_switch_enum && !warn_switch_default) 3961 return; 3962 3963 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL); 3964 if (!default_node) 3965 warning (OPT_Wswitch_default, "%Hswitch missing default case", 3966 &switch_location); 3967 3968 /* From here on, we only care about about enumerated types. */ 3969 if (!type || TREE_CODE (type) != ENUMERAL_TYPE) 3970 return; 3971 3972 /* If the switch expression was an enumerated type, check that 3973 exactly all enumeration literals are covered by the cases. 3974 The check is made when -Wswitch was specified and there is no 3975 default case, or when -Wswitch-enum was specified. */ 3976 3977 if (!warn_switch_enum 3978 && !(warn_switch && !default_node)) 3979 return; 3980 3981 /* Clearing COND if it is not an integer constant simplifies 3982 the tests inside the loop below. */ 3983 if (TREE_CODE (cond) != INTEGER_CST) 3984 cond = NULL_TREE; 3985 3986 /* The time complexity here is O(N*lg(N)) worst case, but for the 3987 common case of monotonically increasing enumerators, it is 3988 O(N), since the nature of the splay tree will keep the next 3989 element adjacent to the root at all times. */ 3990 3991 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain)) 3992 { 3993 tree value = TREE_VALUE (chain); 3994 node = splay_tree_lookup (cases, (splay_tree_key) value); 3995 if (node) 3996 { 3997 /* Mark the CASE_LOW part of the case entry as seen. */ 3998 tree label = (tree) node->value; 3999 CASE_LOW_SEEN (label) = 1; 4000 continue; 4001 } 4002 4003 /* Even though there wasn't an exact match, there might be a 4004 case range which includes the enumator's value. */ 4005 node = splay_tree_predecessor (cases, (splay_tree_key) value); 4006 if (node && CASE_HIGH ((tree) node->value)) 4007 { 4008 tree label = (tree) node->value; 4009 int cmp = tree_int_cst_compare (CASE_HIGH (label), value); 4010 if (cmp >= 0) 4011 { 4012 /* If we match the upper bound exactly, mark the CASE_HIGH 4013 part of the case entry as seen. */ 4014 if (cmp == 0) 4015 CASE_HIGH_SEEN (label) = 1; 4016 continue; 4017 } 4018 } 4019 4020 /* We've now determined that this enumerated literal isn't 4021 handled by the case labels of the switch statement. */ 4022 4023 /* If the switch expression is a constant, we only really care 4024 about whether that constant is handled by the switch. */ 4025 if (cond && tree_int_cst_compare (cond, value)) 4026 continue; 4027 4028 warning (0, "%Henumeration value %qE not handled in switch", 4029 &switch_location, TREE_PURPOSE (chain)); 4030 } 4031 4032 /* Warn if there are case expressions that don't correspond to 4033 enumerators. This can occur since C and C++ don't enforce 4034 type-checking of assignments to enumeration variables. 4035 4036 The time complexity here is now always O(N) worst case, since 4037 we should have marked both the lower bound and upper bound of 4038 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN 4039 above. This scan also resets those fields. */ 4040 splay_tree_foreach (cases, match_case_to_enum, type); 4041} 4042 4043/* Finish an expression taking the address of LABEL (an 4044 IDENTIFIER_NODE). Returns an expression for the address. */ 4045 4046tree 4047finish_label_address_expr (tree label) 4048{ 4049 tree result; 4050 4051 if (pedantic) 4052 pedwarn ("taking the address of a label is non-standard"); 4053 4054 if (label == error_mark_node) 4055 return error_mark_node; 4056 4057 label = lookup_label (label); 4058 if (label == NULL_TREE) 4059 result = null_pointer_node; 4060 else 4061 { 4062 TREE_USED (label) = 1; 4063 result = build1 (ADDR_EXPR, ptr_type_node, label); 4064 /* The current function in not necessarily uninlinable. 4065 Computed gotos are incompatible with inlining, but the value 4066 here could be used only in a diagnostic, for example. */ 4067 } 4068 4069 return result; 4070} 4071 4072/* Hook used by expand_expr to expand language-specific tree codes. */ 4073/* The only things that should go here are bits needed to expand 4074 constant initializers. Everything else should be handled by the 4075 gimplification routines. */ 4076 4077rtx 4078c_expand_expr (tree exp, rtx target, enum machine_mode tmode, 4079 int modifier /* Actually enum_modifier. */, 4080 rtx *alt_rtl) 4081{ 4082 switch (TREE_CODE (exp)) 4083 { 4084 case COMPOUND_LITERAL_EXPR: 4085 { 4086 /* Initialize the anonymous variable declared in the compound 4087 literal, then return the variable. */ 4088 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp); 4089 emit_local_var (decl); 4090 return expand_expr_real (decl, target, tmode, modifier, alt_rtl); 4091 } 4092 4093 default: 4094 gcc_unreachable (); 4095 } 4096} 4097 4098/* Hook used by staticp to handle language-specific tree codes. */ 4099 4100tree 4101c_staticp (tree exp) 4102{ 4103 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR 4104 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)) 4105 ? exp : NULL); 4106} 4107 4108 4109/* Given a boolean expression ARG, return a tree representing an increment 4110 or decrement (as indicated by CODE) of ARG. The front end must check for 4111 invalid cases (e.g., decrement in C++). */ 4112tree 4113boolean_increment (enum tree_code code, tree arg) 4114{ 4115 tree val; 4116 tree true_res = boolean_true_node; 4117 4118 arg = stabilize_reference (arg); 4119 switch (code) 4120 { 4121 case PREINCREMENT_EXPR: 4122 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 4123 break; 4124 case POSTINCREMENT_EXPR: 4125 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 4126 arg = save_expr (arg); 4127 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 4128 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 4129 break; 4130 case PREDECREMENT_EXPR: 4131 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 4132 invert_truthvalue (arg)); 4133 break; 4134 case POSTDECREMENT_EXPR: 4135 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 4136 invert_truthvalue (arg)); 4137 arg = save_expr (arg); 4138 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 4139 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 4140 break; 4141 default: 4142 gcc_unreachable (); 4143 } 4144 TREE_SIDE_EFFECTS (val) = 1; 4145 return val; 4146} 4147 4148/* Built-in macros for stddef.h, that require macros defined in this 4149 file. */ 4150void 4151c_stddef_cpp_builtins(void) 4152{ 4153 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0); 4154 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0); 4155 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0); 4156 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0); 4157 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0); 4158 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0); 4159} 4160 4161static void 4162c_init_attributes (void) 4163{ 4164 /* Fill in the built_in_attributes array. */ 4165#define DEF_ATTR_NULL_TREE(ENUM) \ 4166 built_in_attributes[(int) ENUM] = NULL_TREE; 4167#define DEF_ATTR_INT(ENUM, VALUE) \ 4168 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE); 4169#define DEF_ATTR_IDENT(ENUM, STRING) \ 4170 built_in_attributes[(int) ENUM] = get_identifier (STRING); 4171#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \ 4172 built_in_attributes[(int) ENUM] \ 4173 = tree_cons (built_in_attributes[(int) PURPOSE], \ 4174 built_in_attributes[(int) VALUE], \ 4175 built_in_attributes[(int) CHAIN]); 4176#include "builtin-attrs.def" 4177#undef DEF_ATTR_NULL_TREE 4178#undef DEF_ATTR_INT 4179#undef DEF_ATTR_IDENT 4180#undef DEF_ATTR_TREE_LIST 4181} 4182 4183/* Attribute handlers common to C front ends. */ 4184 4185/* Handle a "packed" attribute; arguments as in 4186 struct attribute_spec.handler. */ 4187 4188static tree 4189handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args), 4190 int flags, bool *no_add_attrs) 4191{ 4192 if (TYPE_P (*node)) 4193 { 4194 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 4195 *node = build_variant_type_copy (*node); 4196 TYPE_PACKED (*node) = 1; 4197 } 4198 else if (TREE_CODE (*node) == FIELD_DECL) 4199 { 4200 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT) 4201 warning (OPT_Wattributes, 4202 "%qE attribute ignored for field of type %qT", 4203 name, TREE_TYPE (*node)); 4204 else 4205 DECL_PACKED (*node) = 1; 4206 } 4207 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is 4208 used for DECL_REGISTER. It wouldn't mean anything anyway. 4209 We can't set DECL_PACKED on the type of a TYPE_DECL, because 4210 that changes what the typedef is typing. */ 4211 else 4212 { 4213 warning (OPT_Wattributes, "%qE attribute ignored", name); 4214 *no_add_attrs = true; 4215 } 4216 4217 return NULL_TREE; 4218} 4219 4220/* Handle a "nocommon" attribute; arguments as in 4221 struct attribute_spec.handler. */ 4222 4223static tree 4224handle_nocommon_attribute (tree *node, tree name, 4225 tree ARG_UNUSED (args), 4226 int ARG_UNUSED (flags), bool *no_add_attrs) 4227{ 4228 if (TREE_CODE (*node) == VAR_DECL) 4229 DECL_COMMON (*node) = 0; 4230 else 4231 { 4232 warning (OPT_Wattributes, "%qE attribute ignored", name); 4233 *no_add_attrs = true; 4234 } 4235 4236 return NULL_TREE; 4237} 4238 4239/* Handle a "common" attribute; arguments as in 4240 struct attribute_spec.handler. */ 4241 4242static tree 4243handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args), 4244 int ARG_UNUSED (flags), bool *no_add_attrs) 4245{ 4246 if (TREE_CODE (*node) == VAR_DECL) 4247 DECL_COMMON (*node) = 1; 4248 else 4249 { 4250 warning (OPT_Wattributes, "%qE attribute ignored", name); 4251 *no_add_attrs = true; 4252 } 4253 4254 return NULL_TREE; 4255} 4256 4257/* Handle a "noreturn" attribute; arguments as in 4258 struct attribute_spec.handler. */ 4259 4260static tree 4261handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args), 4262 int ARG_UNUSED (flags), bool *no_add_attrs) 4263{ 4264 tree type = TREE_TYPE (*node); 4265 4266 /* See FIXME comment in c_common_attribute_table. */ 4267 /* APPLE LOCAL begin radar 4727659 */ 4268 if (TREE_CODE (*node) == FUNCTION_DECL 4269 || objc_method_decl (TREE_CODE (*node))) 4270 /* APPLE LOCAL end radar 4727659 */ 4271 TREE_THIS_VOLATILE (*node) = 1; 4272 else if (TREE_CODE (type) == POINTER_TYPE 4273 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 4274 TREE_TYPE (*node) 4275 = build_pointer_type 4276 (build_type_variant (TREE_TYPE (type), 4277 TYPE_READONLY (TREE_TYPE (type)), 1)); 4278 /* APPLE LOCAL begin radar 6237713 */ 4279 else if (TREE_CODE (type) == BLOCK_POINTER_TYPE 4280 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 4281 TREE_TYPE (*node) 4282 = build_block_pointer_type 4283 (build_type_variant (TREE_TYPE (type), 4284 TYPE_READONLY (TREE_TYPE (type)), 1)); 4285 /* APPLE LOCAL end radar 6237713 */ 4286 else 4287 { 4288 warning (OPT_Wattributes, "%qE attribute ignored", name); 4289 *no_add_attrs = true; 4290 } 4291 4292 return NULL_TREE; 4293} 4294 4295/* Handle a "noinline" attribute; arguments as in 4296 struct attribute_spec.handler. */ 4297 4298static tree 4299handle_noinline_attribute (tree *node, tree name, 4300 tree ARG_UNUSED (args), 4301 int ARG_UNUSED (flags), bool *no_add_attrs) 4302{ 4303 if (TREE_CODE (*node) == FUNCTION_DECL) 4304 DECL_UNINLINABLE (*node) = 1; 4305 else 4306 { 4307 warning (OPT_Wattributes, "%qE attribute ignored", name); 4308 *no_add_attrs = true; 4309 } 4310 4311 return NULL_TREE; 4312} 4313 4314/* Handle a "always_inline" attribute; arguments as in 4315 struct attribute_spec.handler. */ 4316 4317static tree 4318handle_always_inline_attribute (tree *node, tree name, 4319 tree ARG_UNUSED (args), 4320 int ARG_UNUSED (flags), 4321 bool *no_add_attrs) 4322{ 4323 if (TREE_CODE (*node) == FUNCTION_DECL) 4324 { 4325 /* Do nothing else, just set the attribute. We'll get at 4326 it later with lookup_attribute. */ 4327 } 4328 else 4329 { 4330 warning (OPT_Wattributes, "%qE attribute ignored", name); 4331 *no_add_attrs = true; 4332 } 4333 4334 return NULL_TREE; 4335} 4336 4337/* Handle a "gnu_inline" attribute; arguments as in 4338 struct attribute_spec.handler. */ 4339 4340static tree 4341handle_gnu_inline_attribute (tree *node, tree name, 4342 tree ARG_UNUSED (args), 4343 int ARG_UNUSED (flags), 4344 bool *no_add_attrs) 4345{ 4346 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node)) 4347 { 4348 /* Do nothing else, just set the attribute. We'll get at 4349 it later with lookup_attribute. */ 4350 } 4351 else 4352 { 4353 warning (OPT_Wattributes, "%qE attribute ignored", name); 4354 *no_add_attrs = true; 4355 } 4356 4357 return NULL_TREE; 4358} 4359 4360/* Handle a "flatten" attribute; arguments as in 4361 struct attribute_spec.handler. */ 4362 4363static tree 4364handle_flatten_attribute (tree *node, tree name, 4365 tree args ATTRIBUTE_UNUSED, 4366 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs) 4367{ 4368 if (TREE_CODE (*node) == FUNCTION_DECL) 4369 /* Do nothing else, just set the attribute. We'll get at 4370 it later with lookup_attribute. */ 4371 ; 4372 else 4373 { 4374 warning (OPT_Wattributes, "%qE attribute ignored", name); 4375 *no_add_attrs = true; 4376 } 4377 4378 return NULL_TREE; 4379} 4380 4381 4382/* Handle a "used" attribute; arguments as in 4383 struct attribute_spec.handler. */ 4384 4385static tree 4386handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args), 4387 int ARG_UNUSED (flags), bool *no_add_attrs) 4388{ 4389 tree node = *pnode; 4390 4391 if (TREE_CODE (node) == FUNCTION_DECL 4392 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node))) 4393 { 4394 TREE_USED (node) = 1; 4395 DECL_PRESERVE_P (node) = 1; 4396 } 4397 else 4398 { 4399 warning (OPT_Wattributes, "%qE attribute ignored", name); 4400 *no_add_attrs = true; 4401 } 4402 4403 return NULL_TREE; 4404} 4405 4406/* Handle a "unused" attribute; arguments as in 4407 struct attribute_spec.handler. */ 4408 4409static tree 4410handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args), 4411 int flags, bool *no_add_attrs) 4412{ 4413 if (DECL_P (*node)) 4414 { 4415 tree decl = *node; 4416 4417 if (TREE_CODE (decl) == PARM_DECL 4418 || TREE_CODE (decl) == VAR_DECL 4419 || TREE_CODE (decl) == FUNCTION_DECL 4420/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4421 || (TREE_CODE (decl) == LABEL_DECL 4422 && ! DECL_ARTIFICIAL (decl)) 4423/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4424 || TREE_CODE (decl) == TYPE_DECL) 4425 TREE_USED (decl) = 1; 4426 else 4427 { 4428 warning (OPT_Wattributes, "%qE attribute ignored", name); 4429 *no_add_attrs = true; 4430 } 4431 } 4432 else 4433 { 4434 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 4435 *node = build_variant_type_copy (*node); 4436 TREE_USED (*node) = 1; 4437 } 4438 4439 return NULL_TREE; 4440} 4441 4442/* Handle a "externally_visible" attribute; arguments as in 4443 struct attribute_spec.handler. */ 4444 4445static tree 4446handle_externally_visible_attribute (tree *pnode, tree name, 4447 tree ARG_UNUSED (args), 4448 int ARG_UNUSED (flags), 4449 bool *no_add_attrs) 4450{ 4451 tree node = *pnode; 4452 4453 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL) 4454 { 4455 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL 4456 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node)) 4457 { 4458 warning (OPT_Wattributes, 4459 "%qE attribute have effect only on public objects", name); 4460 *no_add_attrs = true; 4461 } 4462 } 4463 else 4464 { 4465 warning (OPT_Wattributes, "%qE attribute ignored", name); 4466 *no_add_attrs = true; 4467 } 4468 4469 return NULL_TREE; 4470} 4471 4472/* Handle a "const" attribute; arguments as in 4473 struct attribute_spec.handler. */ 4474 4475static tree 4476handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args), 4477 int ARG_UNUSED (flags), bool *no_add_attrs) 4478{ 4479 tree type = TREE_TYPE (*node); 4480 4481 /* See FIXME comment on noreturn in c_common_attribute_table. */ 4482 if (TREE_CODE (*node) == FUNCTION_DECL) 4483 TREE_READONLY (*node) = 1; 4484 else if (TREE_CODE (type) == POINTER_TYPE 4485 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 4486 TREE_TYPE (*node) 4487 = build_pointer_type 4488 (build_type_variant (TREE_TYPE (type), 1, 4489 TREE_THIS_VOLATILE (TREE_TYPE (type)))); 4490 else 4491 { 4492 warning (OPT_Wattributes, "%qE attribute ignored", name); 4493 *no_add_attrs = true; 4494 } 4495 4496 return NULL_TREE; 4497} 4498 4499/* Handle a "transparent_union" attribute; arguments as in 4500 struct attribute_spec.handler. */ 4501 4502static tree 4503handle_transparent_union_attribute (tree *node, tree name, 4504 tree ARG_UNUSED (args), int flags, 4505 bool *no_add_attrs) 4506{ 4507 tree type = NULL; 4508 4509 *no_add_attrs = true; 4510 4511 if (DECL_P (*node)) 4512 { 4513 if (TREE_CODE (*node) != TYPE_DECL) 4514 goto ignored; 4515 node = &TREE_TYPE (*node); 4516 type = *node; 4517 } 4518 else if (TYPE_P (*node)) 4519 type = *node; 4520 else 4521 goto ignored; 4522 4523 if (TREE_CODE (type) == UNION_TYPE) 4524 { 4525 /* When IN_PLACE is set, leave the check for FIELDS and MODE to 4526 the code in finish_struct. */ 4527 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 4528 { 4529 if (TYPE_FIELDS (type) == NULL_TREE 4530 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type))) 4531 goto ignored; 4532 4533 /* A type variant isn't good enough, since we don't a cast 4534 to such a type removed as a no-op. */ 4535 *node = type = build_duplicate_type (type); 4536 } 4537 4538 TYPE_TRANSPARENT_UNION (type) = 1; 4539 return NULL_TREE; 4540 } 4541 4542 ignored: 4543 warning (OPT_Wattributes, "%qE attribute ignored", name); 4544 return NULL_TREE; 4545} 4546 4547/* Handle a "constructor" attribute; arguments as in 4548 struct attribute_spec.handler. */ 4549 4550static tree 4551handle_constructor_attribute (tree *node, tree name, 4552 tree ARG_UNUSED (args), 4553 int ARG_UNUSED (flags), 4554 bool *no_add_attrs) 4555{ 4556 tree decl = *node; 4557 tree type = TREE_TYPE (decl); 4558 4559 if (TREE_CODE (decl) == FUNCTION_DECL 4560 && TREE_CODE (type) == FUNCTION_TYPE 4561 && decl_function_context (decl) == 0) 4562 { 4563 DECL_STATIC_CONSTRUCTOR (decl) = 1; 4564 TREE_USED (decl) = 1; 4565 } 4566 else 4567 { 4568 warning (OPT_Wattributes, "%qE attribute ignored", name); 4569 *no_add_attrs = true; 4570 } 4571 4572 return NULL_TREE; 4573} 4574 4575/* Handle a "destructor" attribute; arguments as in 4576 struct attribute_spec.handler. */ 4577 4578static tree 4579handle_destructor_attribute (tree *node, tree name, 4580 tree ARG_UNUSED (args), 4581 int ARG_UNUSED (flags), 4582 bool *no_add_attrs) 4583{ 4584 tree decl = *node; 4585 tree type = TREE_TYPE (decl); 4586 4587 if (TREE_CODE (decl) == FUNCTION_DECL 4588 && TREE_CODE (type) == FUNCTION_TYPE 4589 && decl_function_context (decl) == 0) 4590 { 4591 DECL_STATIC_DESTRUCTOR (decl) = 1; 4592 TREE_USED (decl) = 1; 4593 } 4594 else 4595 { 4596 warning (OPT_Wattributes, "%qE attribute ignored", name); 4597 *no_add_attrs = true; 4598 } 4599 4600 return NULL_TREE; 4601} 4602 4603/* Handle a "mode" attribute; arguments as in 4604 struct attribute_spec.handler. */ 4605 4606static tree 4607handle_mode_attribute (tree *node, tree name, tree args, 4608 int ARG_UNUSED (flags), bool *no_add_attrs) 4609{ 4610 tree type = *node; 4611 4612 *no_add_attrs = true; 4613 4614 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE) 4615 warning (OPT_Wattributes, "%qE attribute ignored", name); 4616 else 4617 { 4618 int j; 4619 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args)); 4620 int len = strlen (p); 4621 enum machine_mode mode = VOIDmode; 4622 tree typefm; 4623 bool valid_mode; 4624 4625 if (len > 4 && p[0] == '_' && p[1] == '_' 4626 && p[len - 1] == '_' && p[len - 2] == '_') 4627 { 4628 char *newp = (char *) alloca (len - 1); 4629 4630 strcpy (newp, &p[2]); 4631 newp[len - 4] = '\0'; 4632 p = newp; 4633 } 4634 4635 /* Change this type to have a type with the specified mode. 4636 First check for the special modes. */ 4637 if (!strcmp (p, "byte")) 4638 mode = byte_mode; 4639 else if (!strcmp (p, "word")) 4640 mode = word_mode; 4641 else if (!strcmp (p, "pointer")) 4642 mode = ptr_mode; 4643 else 4644 for (j = 0; j < NUM_MACHINE_MODES; j++) 4645 if (!strcmp (p, GET_MODE_NAME (j))) 4646 { 4647 mode = (enum machine_mode) j; 4648 break; 4649 } 4650 4651 if (mode == VOIDmode) 4652 { 4653 error ("unknown machine mode %qs", p); 4654 return NULL_TREE; 4655 } 4656 4657 valid_mode = false; 4658 switch (GET_MODE_CLASS (mode)) 4659 { 4660 case MODE_INT: 4661 case MODE_PARTIAL_INT: 4662 case MODE_FLOAT: 4663 case MODE_DECIMAL_FLOAT: 4664 valid_mode = targetm.scalar_mode_supported_p (mode); 4665 break; 4666 4667 case MODE_COMPLEX_INT: 4668 case MODE_COMPLEX_FLOAT: 4669 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode)); 4670 break; 4671 4672 case MODE_VECTOR_INT: 4673 case MODE_VECTOR_FLOAT: 4674 warning (OPT_Wattributes, "specifying vector types with " 4675 "__attribute__ ((mode)) is deprecated"); 4676 warning (OPT_Wattributes, 4677 "use __attribute__ ((vector_size)) instead"); 4678 valid_mode = vector_mode_valid_p (mode); 4679 break; 4680 4681 default: 4682 break; 4683 } 4684 if (!valid_mode) 4685 { 4686 error ("unable to emulate %qs", p); 4687 return NULL_TREE; 4688 } 4689 4690 if (POINTER_TYPE_P (type)) 4691 { 4692 tree (*fn)(tree, enum machine_mode, bool); 4693 4694 if (!targetm.valid_pointer_mode (mode)) 4695 { 4696 error ("invalid pointer mode %qs", p); 4697 return NULL_TREE; 4698 } 4699 4700 if (TREE_CODE (type) == POINTER_TYPE) 4701 fn = build_pointer_type_for_mode; 4702 else 4703 fn = build_reference_type_for_mode; 4704 typefm = fn (TREE_TYPE (type), mode, false); 4705 } 4706 else 4707 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type)); 4708 4709 if (typefm == NULL_TREE) 4710 { 4711 error ("no data type for mode %qs", p); 4712 return NULL_TREE; 4713 } 4714 else if (TREE_CODE (type) == ENUMERAL_TYPE) 4715 { 4716 /* For enumeral types, copy the precision from the integer 4717 type returned above. If not an INTEGER_TYPE, we can't use 4718 this mode for this type. */ 4719 if (TREE_CODE (typefm) != INTEGER_TYPE) 4720 { 4721 error ("cannot use mode %qs for enumeral types", p); 4722 return NULL_TREE; 4723 } 4724 4725 if (flags & ATTR_FLAG_TYPE_IN_PLACE) 4726 { 4727 TYPE_PRECISION (type) = TYPE_PRECISION (typefm); 4728 typefm = type; 4729 } 4730 else 4731 { 4732 /* We cannot build a type variant, as there's code that assumes 4733 that TYPE_MAIN_VARIANT has the same mode. This includes the 4734 debug generators. Instead, create a subrange type. This 4735 results in all of the enumeral values being emitted only once 4736 in the original, and the subtype gets them by reference. */ 4737 if (TYPE_UNSIGNED (type)) 4738 typefm = make_unsigned_type (TYPE_PRECISION (typefm)); 4739 else 4740 typefm = make_signed_type (TYPE_PRECISION (typefm)); 4741 TREE_TYPE (typefm) = type; 4742 } 4743 } 4744 else if (VECTOR_MODE_P (mode) 4745 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm)) 4746 : TREE_CODE (type) != TREE_CODE (typefm)) 4747 { 4748 error ("mode %qs applied to inappropriate type", p); 4749 return NULL_TREE; 4750 } 4751 4752 *node = typefm; 4753 } 4754 4755 return NULL_TREE; 4756} 4757 4758/* Handle a "section" attribute; arguments as in 4759 struct attribute_spec.handler. */ 4760 4761static tree 4762handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args, 4763 int ARG_UNUSED (flags), bool *no_add_attrs) 4764{ 4765 tree decl = *node; 4766 4767 if (targetm.have_named_sections) 4768 { 4769 user_defined_section_attribute = true; 4770 4771 if ((TREE_CODE (decl) == FUNCTION_DECL 4772 || TREE_CODE (decl) == VAR_DECL) 4773 && TREE_CODE (TREE_VALUE (args)) == STRING_CST) 4774 { 4775 if (TREE_CODE (decl) == VAR_DECL 4776 && current_function_decl != NULL_TREE 4777 && !TREE_STATIC (decl)) 4778 { 4779 error ("%Jsection attribute cannot be specified for " 4780 "local variables", decl); 4781 *no_add_attrs = true; 4782 } 4783 4784 /* The decl may have already been given a section attribute 4785 from a previous declaration. Ensure they match. */ 4786 else if (DECL_SECTION_NAME (decl) != NULL_TREE 4787 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), 4788 TREE_STRING_POINTER (TREE_VALUE (args))) != 0) 4789 { 4790 error ("section of %q+D conflicts with previous declaration", 4791 *node); 4792 *no_add_attrs = true; 4793 } 4794 else 4795 DECL_SECTION_NAME (decl) = TREE_VALUE (args); 4796 } 4797 else 4798 { 4799 error ("section attribute not allowed for %q+D", *node); 4800 *no_add_attrs = true; 4801 } 4802 } 4803 else 4804 { 4805 error ("%Jsection attributes are not supported for this target", *node); 4806 *no_add_attrs = true; 4807 } 4808 4809 return NULL_TREE; 4810} 4811 4812/* Handle a "aligned" attribute; arguments as in 4813 struct attribute_spec.handler. */ 4814 4815static tree 4816handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args, 4817 int flags, bool *no_add_attrs) 4818{ 4819 tree decl = NULL_TREE; 4820 tree *type = NULL; 4821 int is_type = 0; 4822 tree align_expr = (args ? TREE_VALUE (args) 4823 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 4824 int i; 4825 4826 if (DECL_P (*node)) 4827 { 4828 decl = *node; 4829 type = &TREE_TYPE (decl); 4830 is_type = TREE_CODE (*node) == TYPE_DECL; 4831 } 4832 else if (TYPE_P (*node)) 4833 type = node, is_type = 1; 4834 4835 if (TREE_CODE (align_expr) != INTEGER_CST) 4836 { 4837 error ("requested alignment is not a constant"); 4838 *no_add_attrs = true; 4839 } 4840 else if ((i = tree_log2 (align_expr)) == -1) 4841 { 4842 error ("requested alignment is not a power of 2"); 4843 *no_add_attrs = true; 4844 } 4845 else if (i > HOST_BITS_PER_INT - 2) 4846 { 4847 error ("requested alignment is too large"); 4848 *no_add_attrs = true; 4849 } 4850 else if (is_type) 4851 { 4852 /* If we have a TYPE_DECL, then copy the type, so that we 4853 don't accidentally modify a builtin type. See pushdecl. */ 4854 if (decl && TREE_TYPE (decl) != error_mark_node 4855 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE) 4856 { 4857 tree tt = TREE_TYPE (decl); 4858 *type = build_variant_type_copy (*type); 4859 DECL_ORIGINAL_TYPE (decl) = tt; 4860 TYPE_NAME (*type) = decl; 4861 TREE_USED (*type) = TREE_USED (decl); 4862 TREE_TYPE (decl) = *type; 4863 } 4864 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 4865 *type = build_variant_type_copy (*type); 4866 4867 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT; 4868 TYPE_USER_ALIGN (*type) = 1; 4869 } 4870 else if (! VAR_OR_FUNCTION_DECL_P (decl) 4871/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4872 && TREE_CODE (decl) != FIELD_DECL 4873 && TREE_CODE (decl) != LABEL_DECL) 4874/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4875 { 4876 error ("alignment may not be specified for %q+D", decl); 4877 *no_add_attrs = true; 4878 } 4879 else if (TREE_CODE (decl) == FUNCTION_DECL 4880 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT) 4881 { 4882 if (DECL_USER_ALIGN (decl)) 4883 error ("alignment for %q+D was previously specified as %d " 4884 "and may not be decreased", decl, 4885 DECL_ALIGN (decl) / BITS_PER_UNIT); 4886 else 4887 error ("alignment for %q+D must be at least %d", decl, 4888 DECL_ALIGN (decl) / BITS_PER_UNIT); 4889 *no_add_attrs = true; 4890 } 4891 else 4892 { 4893 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT; 4894 DECL_USER_ALIGN (decl) = 1; 4895 } 4896 4897 return NULL_TREE; 4898} 4899 4900/* Handle a "weak" attribute; arguments as in 4901 struct attribute_spec.handler. */ 4902 4903static tree 4904handle_weak_attribute (tree *node, tree name, 4905 tree ARG_UNUSED (args), 4906 int ARG_UNUSED (flags), 4907 bool * ARG_UNUSED (no_add_attrs)) 4908{ 4909 if (TREE_CODE (*node) == FUNCTION_DECL 4910 || TREE_CODE (*node) == VAR_DECL) 4911 declare_weak (*node); 4912 /* APPLE LOCAL begin weak types 5954418 */ 4913 else if (!DECL_P (*node) 4914 /* If the weak flag can be associated with something else, 4915 prefer that. */ 4916 && (flags & (ATTR_FLAG_FUNCTION_NEXT 4917 |ATTR_FLAG_DECL_NEXT 4918 |ATTR_FLAG_ARRAY_NEXT))) 4919 { 4920 *no_add_attrs = true; 4921 return tree_cons (name, args, NULL_TREE); 4922 } 4923 else if (! targetm.cxx.class_data_always_comdat () 4924 && TREE_CODE (*node) == RECORD_TYPE) 4925 { 4926 /* Leave on the type for the C++ front end */ 4927 } 4928 /* APPLE LOCAL end weak types 5954418 */ 4929 else 4930 warning (OPT_Wattributes, "%qE attribute ignored", name); 4931 4932 4933 return NULL_TREE; 4934} 4935 4936/* Handle an "alias" attribute; arguments as in 4937 struct attribute_spec.handler. */ 4938 4939static tree 4940handle_alias_attribute (tree *node, tree name, tree args, 4941 int ARG_UNUSED (flags), bool *no_add_attrs) 4942{ 4943 tree decl = *node; 4944 4945 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl)) 4946 || (TREE_CODE (decl) != FUNCTION_DECL 4947 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) 4948 /* A static variable declaration is always a tentative definition, 4949 but the alias is a non-tentative definition which overrides. */ 4950 || (TREE_CODE (decl) != FUNCTION_DECL 4951 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl))) 4952 { 4953 error ("%q+D defined both normally and as an alias", decl); 4954 *no_add_attrs = true; 4955 } 4956 4957 /* Note that the very first time we process a nested declaration, 4958 decl_function_context will not be set. Indeed, *would* never 4959 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that 4960 we do below. After such frobbery, pushdecl would set the context. 4961 In any case, this is never what we want. */ 4962 else if (decl_function_context (decl) == 0 && current_function_decl == NULL) 4963 { 4964 tree id; 4965 4966 id = TREE_VALUE (args); 4967 if (TREE_CODE (id) != STRING_CST) 4968 { 4969 error ("alias argument not a string"); 4970 *no_add_attrs = true; 4971 return NULL_TREE; 4972 } 4973 id = get_identifier (TREE_STRING_POINTER (id)); 4974 /* This counts as a use of the object pointed to. */ 4975 TREE_USED (id) = 1; 4976 4977 if (TREE_CODE (decl) == FUNCTION_DECL) 4978 DECL_INITIAL (decl) = error_mark_node; 4979 else 4980 { 4981 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 4982 DECL_EXTERNAL (decl) = 1; 4983 else 4984 DECL_EXTERNAL (decl) = 0; 4985 TREE_STATIC (decl) = 1; 4986 } 4987 } 4988 else 4989 { 4990 warning (OPT_Wattributes, "%qE attribute ignored", name); 4991 *no_add_attrs = true; 4992 } 4993 4994 return NULL_TREE; 4995} 4996 4997/* Handle a "weakref" attribute; arguments as in struct 4998 attribute_spec.handler. */ 4999 5000static tree 5001handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args, 5002 int flags, bool *no_add_attrs) 5003{ 5004 tree attr = NULL_TREE; 5005 5006 /* We must ignore the attribute when it is associated with 5007 local-scoped decls, since attribute alias is ignored and many 5008 such symbols do not even have a DECL_WEAK field. */ 5009 if (decl_function_context (*node) || current_function_decl) 5010 { 5011 warning (OPT_Wattributes, "%qE attribute ignored", name); 5012 *no_add_attrs = true; 5013 return NULL_TREE; 5014 } 5015 5016 /* The idea here is that `weakref("name")' mutates into `weakref, 5017 alias("name")', and weakref without arguments, in turn, 5018 implicitly adds weak. */ 5019 5020 if (args) 5021 { 5022 attr = tree_cons (get_identifier ("alias"), args, attr); 5023 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr); 5024 5025 *no_add_attrs = true; 5026 5027 decl_attributes (node, attr, flags); 5028 } 5029 else 5030 { 5031 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node))) 5032 error ("%Jweakref attribute must appear before alias attribute", 5033 *node); 5034 5035 /* Can't call declare_weak because it wants this to be TREE_PUBLIC, 5036 and that isn't supported; and because it wants to add it to 5037 the list of weak decls, which isn't helpful. */ 5038 DECL_WEAK (*node) = 1; 5039 } 5040 5041 return NULL_TREE; 5042} 5043 5044/* Handle an "visibility" attribute; arguments as in 5045 struct attribute_spec.handler. */ 5046 5047static tree 5048handle_visibility_attribute (tree *node, tree name, tree args, 5049 int ARG_UNUSED (flags), 5050 bool *ARG_UNUSED (no_add_attrs)) 5051{ 5052 tree decl = *node; 5053 tree id = TREE_VALUE (args); 5054 enum symbol_visibility vis; 5055 5056 if (TYPE_P (*node)) 5057 { 5058 if (TREE_CODE (*node) == ENUMERAL_TYPE) 5059 /* OK */; 5060 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE) 5061 { 5062 warning (OPT_Wattributes, "%qE attribute ignored on non-class types", 5063 name); 5064 return NULL_TREE; 5065 } 5066 else if (TYPE_FIELDS (*node)) 5067 { 5068 error ("%qE attribute ignored because %qT is already defined", 5069 name, *node); 5070 return NULL_TREE; 5071 } 5072 } 5073 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl)) 5074 { 5075 warning (OPT_Wattributes, "%qE attribute ignored", name); 5076 return NULL_TREE; 5077 } 5078 5079 if (TREE_CODE (id) != STRING_CST) 5080 { 5081 error ("visibility argument not a string"); 5082 return NULL_TREE; 5083 } 5084 5085 /* If this is a type, set the visibility on the type decl. */ 5086 if (TYPE_P (decl)) 5087 { 5088 decl = TYPE_NAME (decl); 5089 if (!decl) 5090 return NULL_TREE; 5091 if (TREE_CODE (decl) == IDENTIFIER_NODE) 5092 { 5093 warning (OPT_Wattributes, "%qE attribute ignored on types", 5094 name); 5095 return NULL_TREE; 5096 } 5097 } 5098 5099 if (strcmp (TREE_STRING_POINTER (id), "default") == 0) 5100 vis = VISIBILITY_DEFAULT; 5101 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0) 5102 vis = VISIBILITY_INTERNAL; 5103 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0) 5104 vis = VISIBILITY_HIDDEN; 5105 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0) 5106 vis = VISIBILITY_PROTECTED; 5107 else 5108 { 5109 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\""); 5110 vis = VISIBILITY_DEFAULT; 5111 } 5112 5113 if (DECL_VISIBILITY_SPECIFIED (decl) 5114 && vis != DECL_VISIBILITY (decl) 5115 && lookup_attribute ("visibility", (TYPE_P (*node) 5116 ? TYPE_ATTRIBUTES (*node) 5117 : DECL_ATTRIBUTES (decl)))) 5118 error ("%qD redeclared with different visibility", decl); 5119 5120 DECL_VISIBILITY (decl) = vis; 5121 DECL_VISIBILITY_SPECIFIED (decl) = 1; 5122 5123 /* Go ahead and attach the attribute to the node as well. This is needed 5124 so we can determine whether we have VISIBILITY_DEFAULT because the 5125 visibility was not specified, or because it was explicitly overridden 5126 from the containing scope. */ 5127 5128 return NULL_TREE; 5129} 5130 5131/* Determine the ELF symbol visibility for DECL, which is either a 5132 variable or a function. It is an error to use this function if a 5133 definition of DECL is not available in this translation unit. 5134 Returns true if the final visibility has been determined by this 5135 function; false if the caller is free to make additional 5136 modifications. */ 5137 5138bool 5139c_determine_visibility (tree decl) 5140{ 5141 gcc_assert (TREE_CODE (decl) == VAR_DECL 5142 || TREE_CODE (decl) == FUNCTION_DECL); 5143 5144 /* If the user explicitly specified the visibility with an 5145 attribute, honor that. DECL_VISIBILITY will have been set during 5146 the processing of the attribute. We check for an explicit 5147 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED, 5148 to distinguish the use of an attribute from the use of a "#pragma 5149 GCC visibility push(...)"; in the latter case we still want other 5150 considerations to be able to overrule the #pragma. */ 5151 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))) 5152 return true; 5153 5154 /* Anything that is exported must have default visibility. */ 5155 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES 5156 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))) 5157 { 5158 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; 5159 DECL_VISIBILITY_SPECIFIED (decl) = 1; 5160 return true; 5161 } 5162 5163 /* Set default visibility to whatever the user supplied with 5164 visibility_specified depending on #pragma GCC visibility. */ 5165 if (!DECL_VISIBILITY_SPECIFIED (decl)) 5166 { 5167 DECL_VISIBILITY (decl) = default_visibility; 5168 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma; 5169 } 5170 return false; 5171} 5172 5173/* Handle an "tls_model" attribute; arguments as in 5174 struct attribute_spec.handler. */ 5175 5176static tree 5177handle_tls_model_attribute (tree *node, tree name, tree args, 5178 int ARG_UNUSED (flags), bool *no_add_attrs) 5179{ 5180 tree id; 5181 tree decl = *node; 5182 enum tls_model kind; 5183 5184 *no_add_attrs = true; 5185 5186 if (!DECL_THREAD_LOCAL_P (decl)) 5187 { 5188 warning (OPT_Wattributes, "%qE attribute ignored", name); 5189 return NULL_TREE; 5190 } 5191 5192 kind = DECL_TLS_MODEL (decl); 5193 id = TREE_VALUE (args); 5194 if (TREE_CODE (id) != STRING_CST) 5195 { 5196 error ("tls_model argument not a string"); 5197 return NULL_TREE; 5198 } 5199 5200 if (!strcmp (TREE_STRING_POINTER (id), "local-exec")) 5201 kind = TLS_MODEL_LOCAL_EXEC; 5202 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec")) 5203 kind = TLS_MODEL_INITIAL_EXEC; 5204 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic")) 5205 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC; 5206 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic")) 5207 kind = TLS_MODEL_GLOBAL_DYNAMIC; 5208 else 5209 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\""); 5210 5211 DECL_TLS_MODEL (decl) = kind; 5212 return NULL_TREE; 5213} 5214 5215/* Handle a "no_instrument_function" attribute; arguments as in 5216 struct attribute_spec.handler. */ 5217 5218static tree 5219handle_no_instrument_function_attribute (tree *node, tree name, 5220 tree ARG_UNUSED (args), 5221 int ARG_UNUSED (flags), 5222 bool *no_add_attrs) 5223{ 5224 tree decl = *node; 5225 5226 if (TREE_CODE (decl) != FUNCTION_DECL) 5227 { 5228 error ("%J%qE attribute applies only to functions", decl, name); 5229 *no_add_attrs = true; 5230 } 5231 else if (DECL_INITIAL (decl)) 5232 { 5233 error ("%Jcan%'t set %qE attribute after definition", decl, name); 5234 *no_add_attrs = true; 5235 } 5236 else 5237 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1; 5238 5239 return NULL_TREE; 5240} 5241 5242/* Handle a "malloc" attribute; arguments as in 5243 struct attribute_spec.handler. */ 5244 5245static tree 5246handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5247 int ARG_UNUSED (flags), bool *no_add_attrs) 5248{ 5249 if (TREE_CODE (*node) == FUNCTION_DECL 5250 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node)))) 5251 DECL_IS_MALLOC (*node) = 1; 5252 else 5253 { 5254 warning (OPT_Wattributes, "%qE attribute ignored", name); 5255 *no_add_attrs = true; 5256 } 5257 5258 return NULL_TREE; 5259} 5260 5261/* Handle a "returns_twice" attribute; arguments as in 5262 struct attribute_spec.handler. */ 5263 5264static tree 5265handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5266 int ARG_UNUSED (flags), bool *no_add_attrs) 5267{ 5268 if (TREE_CODE (*node) == FUNCTION_DECL) 5269 DECL_IS_RETURNS_TWICE (*node) = 1; 5270 else 5271 { 5272 warning (OPT_Wattributes, "%qE attribute ignored", name); 5273 *no_add_attrs = true; 5274 } 5275 5276 return NULL_TREE; 5277} 5278 5279/* Handle a "no_limit_stack" attribute; arguments as in 5280 struct attribute_spec.handler. */ 5281 5282static tree 5283handle_no_limit_stack_attribute (tree *node, tree name, 5284 tree ARG_UNUSED (args), 5285 int ARG_UNUSED (flags), 5286 bool *no_add_attrs) 5287{ 5288 tree decl = *node; 5289 5290 if (TREE_CODE (decl) != FUNCTION_DECL) 5291 { 5292 error ("%J%qE attribute applies only to functions", decl, name); 5293 *no_add_attrs = true; 5294 } 5295 else if (DECL_INITIAL (decl)) 5296 { 5297 error ("%Jcan%'t set %qE attribute after definition", decl, name); 5298 *no_add_attrs = true; 5299 } 5300 else 5301 DECL_NO_LIMIT_STACK (decl) = 1; 5302 5303 return NULL_TREE; 5304} 5305 5306/* Handle a "pure" attribute; arguments as in 5307 struct attribute_spec.handler. */ 5308 5309static tree 5310handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5311 int ARG_UNUSED (flags), bool *no_add_attrs) 5312{ 5313 if (TREE_CODE (*node) == FUNCTION_DECL) 5314 DECL_IS_PURE (*node) = 1; 5315 /* ??? TODO: Support types. */ 5316 else 5317 { 5318 warning (OPT_Wattributes, "%qE attribute ignored", name); 5319 *no_add_attrs = true; 5320 } 5321 5322 return NULL_TREE; 5323} 5324 5325/* Handle a "no vops" attribute; arguments as in 5326 struct attribute_spec.handler. */ 5327 5328static tree 5329handle_novops_attribute (tree *node, tree ARG_UNUSED (name), 5330 tree ARG_UNUSED (args), int ARG_UNUSED (flags), 5331 bool *ARG_UNUSED (no_add_attrs)) 5332{ 5333 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL); 5334 DECL_IS_NOVOPS (*node) = 1; 5335 return NULL_TREE; 5336} 5337 5338/* Handle a "deprecated" attribute; arguments as in 5339 struct attribute_spec.handler. */ 5340 5341static tree 5342handle_deprecated_attribute (tree *node, tree name, 5343 tree ARG_UNUSED (args), int flags, 5344 bool *no_add_attrs) 5345{ 5346 tree type = NULL_TREE; 5347 int warn = 0; 5348 tree what = NULL_TREE; 5349 5350 if (DECL_P (*node)) 5351 { 5352 tree decl = *node; 5353 type = TREE_TYPE (decl); 5354 5355 if (TREE_CODE (decl) == TYPE_DECL 5356 || TREE_CODE (decl) == PARM_DECL 5357 || TREE_CODE (decl) == VAR_DECL 5358 || TREE_CODE (decl) == FUNCTION_DECL 5359 || TREE_CODE (decl) == FIELD_DECL) 5360 TREE_DEPRECATED (decl) = 1; 5361 else 5362 warn = 1; 5363 } 5364 else if (TYPE_P (*node)) 5365 { 5366 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 5367 *node = build_variant_type_copy (*node); 5368 TREE_DEPRECATED (*node) = 1; 5369 type = *node; 5370 } 5371 else 5372 warn = 1; 5373 5374 if (warn) 5375 { 5376 *no_add_attrs = true; 5377 if (type && TYPE_NAME (type)) 5378 { 5379 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 5380 what = TYPE_NAME (*node); 5381 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 5382 && DECL_NAME (TYPE_NAME (type))) 5383 what = DECL_NAME (TYPE_NAME (type)); 5384 } 5385 if (what) 5386 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what); 5387 else 5388 warning (OPT_Wattributes, "%qE attribute ignored", name); 5389 } 5390 5391 return NULL_TREE; 5392} 5393 5394/* APPLE LOCAL begin "unavailable" attribute (Radar 2809697) --ilr */ 5395/* Handle a "unavailable" attribute; arguments as in 5396 struct attribute_spec.handler. */ 5397 5398static tree 5399handle_unavailable_attribute (tree *node, tree name, 5400 tree args ATTRIBUTE_UNUSED, 5401 int flags ATTRIBUTE_UNUSED, 5402 bool *no_add_attrs) 5403{ 5404 tree type = NULL_TREE; 5405 int warn = 0; 5406 const char *what = NULL; 5407 5408 if (DECL_P (*node)) 5409 { 5410 tree decl = *node; 5411 type = TREE_TYPE (decl); 5412 5413 if (TREE_CODE (decl) == TYPE_DECL 5414 || TREE_CODE (decl) == PARM_DECL 5415 || TREE_CODE (decl) == VAR_DECL 5416 || TREE_CODE (decl) == FUNCTION_DECL 5417 /* APPLE LOCAL begin radar 3803157 - objc attribute */ 5418 || TREE_CODE (decl) == FIELD_DECL 5419 || objc_method_decl (TREE_CODE (decl))) 5420 /* APPLE LOCAL end radar 3803157 - objc attribute */ 5421 { 5422 TREE_UNAVAILABLE (decl) = 1; 5423 } 5424 else 5425 warn = 1; 5426 } 5427 else if (TYPE_P (*node)) 5428 { 5429 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 5430 *node = build_variant_type_copy (*node); 5431 TREE_UNAVAILABLE (*node) = 1; 5432 type = *node; 5433 } 5434 else 5435 warn = 1; 5436 5437 if (warn) 5438 { 5439 *no_add_attrs = true; 5440 if (type && TYPE_NAME (type)) 5441 { 5442 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 5443 what = IDENTIFIER_POINTER (TYPE_NAME (*node)); 5444 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 5445 && DECL_NAME (TYPE_NAME (type))) 5446 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 5447 } 5448 if (what) 5449 warning (0, "`%s' attribute ignored for `%s'", 5450 IDENTIFIER_POINTER (name), what); 5451 else 5452 warning (0, "`%s' attribute ignored", IDENTIFIER_POINTER (name)); 5453 } 5454 5455 return NULL_TREE; 5456} 5457/* APPLE LOCAL end "unavailable" attribute --ilr */ 5458 5459/* Handle a "vector_size" attribute; arguments as in 5460 struct attribute_spec.handler. */ 5461 5462static tree 5463handle_vector_size_attribute (tree *node, tree name, tree args, 5464 int ARG_UNUSED (flags), 5465 bool *no_add_attrs) 5466{ 5467 unsigned HOST_WIDE_INT vecsize, nunits; 5468 enum machine_mode orig_mode; 5469 tree type = *node, new_type, size; 5470 5471 *no_add_attrs = true; 5472 5473 size = TREE_VALUE (args); 5474 5475 if (!host_integerp (size, 1)) 5476 { 5477 warning (OPT_Wattributes, "%qE attribute ignored", name); 5478 return NULL_TREE; 5479 } 5480 5481 /* Get the vector size (in bytes). */ 5482 vecsize = tree_low_cst (size, 1); 5483 5484 /* We need to provide for vector pointers, vector arrays, and 5485 functions returning vectors. For example: 5486 5487 __attribute__((vector_size(16))) short *foo; 5488 5489 In this case, the mode is SI, but the type being modified is 5490 HI, so we need to look further. */ 5491 5492 while (POINTER_TYPE_P (type) 5493 || TREE_CODE (type) == FUNCTION_TYPE 5494 || TREE_CODE (type) == METHOD_TYPE 5495 || TREE_CODE (type) == ARRAY_TYPE) 5496 type = TREE_TYPE (type); 5497 5498 /* Get the mode of the type being modified. */ 5499 orig_mode = TYPE_MODE (type); 5500 5501 if (TREE_CODE (type) == RECORD_TYPE 5502 || TREE_CODE (type) == UNION_TYPE 5503 || TREE_CODE (type) == VECTOR_TYPE 5504 || (!SCALAR_FLOAT_MODE_P (orig_mode) 5505 && GET_MODE_CLASS (orig_mode) != MODE_INT) 5506 || !host_integerp (TYPE_SIZE_UNIT (type), 1)) 5507 { 5508 error ("invalid vector type for attribute %qE", name); 5509 return NULL_TREE; 5510 } 5511 5512 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1)) 5513 { 5514 error ("vector size not an integral multiple of component size"); 5515 return NULL; 5516 } 5517 5518 if (vecsize == 0) 5519 { 5520 error ("zero vector size"); 5521 return NULL; 5522 } 5523 5524 /* Calculate how many units fit in the vector. */ 5525 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1); 5526 if (nunits & (nunits - 1)) 5527 { 5528 error ("number of components of the vector not a power of two"); 5529 return NULL_TREE; 5530 } 5531 5532 new_type = build_vector_type (type, nunits); 5533 5534 /* Build back pointers if needed. */ 5535 *node = reconstruct_complex_type (*node, new_type); 5536 5537 return NULL_TREE; 5538} 5539 5540/* Handle the "nonnull" attribute. */ 5541static tree 5542handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name), 5543 tree args, int ARG_UNUSED (flags), 5544 bool *no_add_attrs) 5545{ 5546 tree type = *node; 5547 unsigned HOST_WIDE_INT attr_arg_num; 5548 5549 /* If no arguments are specified, all pointer arguments should be 5550 non-null. Verify a full prototype is given so that the arguments 5551 will have the correct types when we actually check them later. */ 5552 if (!args) 5553 { 5554 if (!TYPE_ARG_TYPES (type)) 5555 { 5556 error ("nonnull attribute without arguments on a non-prototype"); 5557 *no_add_attrs = true; 5558 } 5559 return NULL_TREE; 5560 } 5561 5562 /* Argument list specified. Verify that each argument number references 5563 a pointer argument. */ 5564 for (attr_arg_num = 1; args; args = TREE_CHAIN (args)) 5565 { 5566 tree argument; 5567 unsigned HOST_WIDE_INT arg_num = 0, ck_num; 5568 5569 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num)) 5570 { 5571 error ("nonnull argument has invalid operand number (argument %lu)", 5572 (unsigned long) attr_arg_num); 5573 *no_add_attrs = true; 5574 return NULL_TREE; 5575 } 5576 5577 argument = TYPE_ARG_TYPES (type); 5578 if (argument) 5579 { 5580 for (ck_num = 1; ; ck_num++) 5581 { 5582 if (!argument || ck_num == arg_num) 5583 break; 5584 argument = TREE_CHAIN (argument); 5585 } 5586 5587 if (!argument 5588 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE) 5589 { 5590 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)", 5591 (unsigned long) attr_arg_num, (unsigned long) arg_num); 5592 *no_add_attrs = true; 5593 return NULL_TREE; 5594 } 5595 5596 /* APPLE LOCAL begin blocks 5925781 */ 5597 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE && 5598 TREE_CODE (TREE_VALUE (argument)) != BLOCK_POINTER_TYPE) 5599 /* APPLE LOCAL end blocks 5925781 */ 5600 { 5601 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)", 5602 (unsigned long) attr_arg_num, (unsigned long) arg_num); 5603 *no_add_attrs = true; 5604 return NULL_TREE; 5605 } 5606 } 5607 } 5608 5609 return NULL_TREE; 5610} 5611 5612/* Check the argument list of a function call for null in argument slots 5613 that are marked as requiring a non-null pointer argument. */ 5614 5615static void 5616check_function_nonnull (tree attrs, tree params) 5617{ 5618 tree a, args, param; 5619 int param_num; 5620 5621 for (a = attrs; a; a = TREE_CHAIN (a)) 5622 { 5623 if (is_attribute_p ("nonnull", TREE_PURPOSE (a))) 5624 { 5625 args = TREE_VALUE (a); 5626 5627 /* Walk the argument list. If we encounter an argument number we 5628 should check for non-null, do it. If the attribute has no args, 5629 then every pointer argument is checked (in which case the check 5630 for pointer type is done in check_nonnull_arg). */ 5631 for (param = params, param_num = 1; ; 5632 param_num++, param = TREE_CHAIN (param)) 5633 { 5634 if (!param) 5635 break; 5636 if (!args || nonnull_check_p (args, param_num)) 5637 check_function_arguments_recurse (check_nonnull_arg, NULL, 5638 TREE_VALUE (param), 5639 param_num); 5640 } 5641 } 5642 } 5643} 5644 5645/* Check that the Nth argument of a function call (counting backwards 5646 from the end) is a (pointer)0. */ 5647 5648static void 5649check_function_sentinel (tree attrs, tree params, tree typelist) 5650{ 5651 tree attr = lookup_attribute ("sentinel", attrs); 5652 5653 if (attr) 5654 { 5655 /* Skip over the named arguments. */ 5656 while (typelist && params) 5657 { 5658 typelist = TREE_CHAIN (typelist); 5659 params = TREE_CHAIN (params); 5660 } 5661 5662 if (typelist || !params) 5663 warning (OPT_Wformat, 5664 "not enough variable arguments to fit a sentinel"); 5665 else 5666 { 5667 tree sentinel, end; 5668 unsigned pos = 0; 5669 5670 if (TREE_VALUE (attr)) 5671 { 5672 tree p = TREE_VALUE (TREE_VALUE (attr)); 5673 pos = TREE_INT_CST_LOW (p); 5674 } 5675 5676 sentinel = end = params; 5677 5678 /* Advance `end' ahead of `sentinel' by `pos' positions. */ 5679 while (pos > 0 && TREE_CHAIN (end)) 5680 { 5681 pos--; 5682 end = TREE_CHAIN (end); 5683 } 5684 if (pos > 0) 5685 { 5686 warning (OPT_Wformat, 5687 "not enough variable arguments to fit a sentinel"); 5688 return; 5689 } 5690 5691 /* Now advance both until we find the last parameter. */ 5692 while (TREE_CHAIN (end)) 5693 { 5694 end = TREE_CHAIN (end); 5695 sentinel = TREE_CHAIN (sentinel); 5696 } 5697 5698 /* Validate the sentinel. */ 5699 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel))) 5700 || !integer_zerop (TREE_VALUE (sentinel))) 5701 /* Although __null (in C++) is only an integer we allow it 5702 nevertheless, as we are guaranteed that it's exactly 5703 as wide as a pointer, and we don't want to force 5704 users to cast the NULL they have written there. 5705 We warn with -Wstrict-null-sentinel, though. */ 5706 && (warn_strict_null_sentinel 5707 || null_node != TREE_VALUE (sentinel))) 5708 warning (OPT_Wformat, "missing sentinel in function call"); 5709 } 5710 } 5711} 5712 5713/* Helper for check_function_nonnull; given a list of operands which 5714 must be non-null in ARGS, determine if operand PARAM_NUM should be 5715 checked. */ 5716 5717static bool 5718nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num) 5719{ 5720 unsigned HOST_WIDE_INT arg_num = 0; 5721 5722 for (; args; args = TREE_CHAIN (args)) 5723 { 5724 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num); 5725 5726 gcc_assert (found); 5727 5728 if (arg_num == param_num) 5729 return true; 5730 } 5731 return false; 5732} 5733 5734/* Check that the function argument PARAM (which is operand number 5735 PARAM_NUM) is non-null. This is called by check_function_nonnull 5736 via check_function_arguments_recurse. */ 5737 5738static void 5739check_nonnull_arg (void * ARG_UNUSED (ctx), tree param, 5740 unsigned HOST_WIDE_INT param_num) 5741{ 5742 /* Just skip checking the argument if it's not a pointer. This can 5743 happen if the "nonnull" attribute was given without an operand 5744 list (which means to check every pointer argument). */ 5745 5746 /* APPLE LOCAL begin blocks 5925781 */ 5747 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE && 5748 TREE_CODE (TREE_TYPE (param)) != BLOCK_POINTER_TYPE) 5749 /* APPLE LOCAL end blocks 5925781 */ 5750 return; 5751 5752 if (integer_zerop (param)) 5753 warning (OPT_Wnonnull, "null argument where non-null required " 5754 "(argument %lu)", (unsigned long) param_num); 5755} 5756 5757/* Helper for nonnull attribute handling; fetch the operand number 5758 from the attribute argument list. */ 5759 5760static bool 5761get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp) 5762{ 5763 /* Verify the arg number is a constant. */ 5764 if (TREE_CODE (arg_num_expr) != INTEGER_CST 5765 || TREE_INT_CST_HIGH (arg_num_expr) != 0) 5766 return false; 5767 5768 *valp = TREE_INT_CST_LOW (arg_num_expr); 5769 return true; 5770} 5771 5772/* Handle a "nothrow" attribute; arguments as in 5773 struct attribute_spec.handler. */ 5774 5775static tree 5776handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5777 int ARG_UNUSED (flags), bool *no_add_attrs) 5778{ 5779 if (TREE_CODE (*node) == FUNCTION_DECL) 5780 TREE_NOTHROW (*node) = 1; 5781 /* ??? TODO: Support types. */ 5782 else 5783 { 5784 warning (OPT_Wattributes, "%qE attribute ignored", name); 5785 *no_add_attrs = true; 5786 } 5787 5788 return NULL_TREE; 5789} 5790 5791/* Handle a "cleanup" attribute; arguments as in 5792 struct attribute_spec.handler. */ 5793 5794static tree 5795handle_cleanup_attribute (tree *node, tree name, tree args, 5796 int ARG_UNUSED (flags), bool *no_add_attrs) 5797{ 5798 tree decl = *node; 5799 tree cleanup_id, cleanup_decl; 5800 5801 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do 5802 for global destructors in C++. This requires infrastructure that 5803 we don't have generically at the moment. It's also not a feature 5804 we'd be missing too much, since we do have attribute constructor. */ 5805 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)) 5806 { 5807 warning (OPT_Wattributes, "%qE attribute ignored", name); 5808 *no_add_attrs = true; 5809 return NULL_TREE; 5810 } 5811 5812 /* Verify that the argument is a function in scope. */ 5813 /* ??? We could support pointers to functions here as well, if 5814 that was considered desirable. */ 5815 cleanup_id = TREE_VALUE (args); 5816 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE) 5817 { 5818 error ("cleanup argument not an identifier"); 5819 *no_add_attrs = true; 5820 return NULL_TREE; 5821 } 5822 cleanup_decl = lookup_name (cleanup_id); 5823 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL) 5824 { 5825 error ("cleanup argument not a function"); 5826 *no_add_attrs = true; 5827 return NULL_TREE; 5828 } 5829 5830 /* That the function has proper type is checked with the 5831 eventual call to build_function_call. */ 5832 5833 return NULL_TREE; 5834} 5835 5836/* Handle a "warn_unused_result" attribute. No special handling. */ 5837 5838static tree 5839handle_warn_unused_result_attribute (tree *node, tree name, 5840 tree ARG_UNUSED (args), 5841 int ARG_UNUSED (flags), bool *no_add_attrs) 5842{ 5843 /* Ignore the attribute for functions not returning any value. */ 5844 if (VOID_TYPE_P (TREE_TYPE (*node))) 5845 { 5846 warning (OPT_Wattributes, "%qE attribute ignored", name); 5847 *no_add_attrs = true; 5848 } 5849 5850 return NULL_TREE; 5851} 5852 5853/* APPLE LOCAL begin radar 5932809 - copyable byref blocks */ 5854/* Handle "blocks" attribute. */ 5855static tree 5856handle_blocks_attribute (tree *node, tree name, 5857 tree args, 5858 int ARG_UNUSED (flags), bool *no_add_attrs) 5859{ 5860 tree arg_ident; 5861 /* APPLE LOCAL radar 6217257 */ 5862 tree type; 5863 *no_add_attrs = true; 5864 if (!(*node) || TREE_CODE (*node) != VAR_DECL) 5865 { 5866 error ("__block attribute can be specified on variables only"); 5867 return NULL_TREE; 5868 } 5869 arg_ident = TREE_VALUE (args); 5870 gcc_assert (TREE_CODE (arg_ident) == IDENTIFIER_NODE); 5871 /* APPLE LOCAL radar 6096219 */ 5872 if (strcmp (IDENTIFIER_POINTER (arg_ident), "byref")) 5873 { 5874 /* APPLE LOCAL radar 6096219 */ 5875 warning (OPT_Wattributes, "Only \"byref\" is allowed - %qE attribute ignored", 5876 name); 5877 return NULL_TREE; 5878 } 5879 /* APPLE LOCAL begin radar 6217257 */ 5880 type = TREE_TYPE (*node); 5881 if (TREE_CODE (type) == ERROR_MARK) 5882 return NULL_TREE; 5883 if (TREE_CODE (type) == ARRAY_TYPE) 5884 { 5885 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 5886 { 5887 error ("__block not allowed on a variable length array declaration"); 5888 return NULL_TREE; 5889 } 5890 } 5891 /* APPLE LOCAL end radar 6217257 */ 5892 COPYABLE_BYREF_LOCAL_VAR (*node) = 1; 5893 COPYABLE_BYREF_LOCAL_NONPOD (*node) = block_requires_copying (*node); 5894 return NULL_TREE; 5895} 5896/* APPLE LOCAL end radar 5932809 - copyable byref blocks */ 5897 5898/* APPLE LOCAL begin blocks 6040305 */ 5899 5900/* This routine builds: 5901 *(void **)(EXP+20) expression which references the object pointer. 5902*/ 5903tree 5904build_indirect_object_id_exp (tree exp) 5905{ 5906 tree dst_obj; 5907 int int_size = int_cst_value (TYPE_SIZE_UNIT (unsigned_type_node)); 5908 int offset; 5909 /* dst->object In thid case 'object' is the field 5910 of the object passed offset by: void * + void* + int + int + void* + void * 5911 This must match definition of Block_byref structs. */ 5912 /* APPLE LOCAL radar 6244520 */ 5913 offset = GET_MODE_SIZE (Pmode) + GET_MODE_SIZE (Pmode) 5914 + int_size + int_size + GET_MODE_SIZE (Pmode) + 5915 GET_MODE_SIZE (Pmode); 5916 dst_obj = build2 (PLUS_EXPR, ptr_type_node, exp, 5917 build_int_cst (NULL_TREE, offset)); 5918 /* APPLE LOCAL begin radar 6180456 */ 5919 /* Type case to: 'void **' */ 5920 dst_obj = build_c_cast (build_pointer_type (ptr_type_node), dst_obj); 5921 dst_obj = build_indirect_ref (dst_obj, "unary *"); 5922 /* APPLE LOCAL end radar 6180456 */ 5923 return dst_obj; 5924} 5925 5926/* This routine builds call to: 5927 _Block_object_dispose(VAR_DECL.__forwarding, BLOCK_FIELD_IS_BYREF); 5928 and adds it to the statement list. 5929 */ 5930tree 5931build_block_byref_release_exp (tree var_decl) 5932{ 5933 tree exp = var_decl, call_exp; 5934 tree type = TREE_TYPE (var_decl); 5935 /* __block variables imported into Blocks are not _Block_object_dispose() 5936 from within the Block statement itself; otherwise, each envokation of 5937 the block causes a release. Make sure to release __block variables declared 5938 and used locally in the block though. */ 5939 if (cur_block 5940 && (BLOCK_DECL_COPIED (var_decl) || BLOCK_DECL_BYREF (var_decl))) 5941 return NULL_TREE; 5942 if (BLOCK_DECL_BYREF (var_decl)) { 5943 /* This is a "struct Block_byref_X *" type. Get its pointee. */ 5944 gcc_assert (POINTER_TYPE_P (type)); 5945 type = TREE_TYPE (type); 5946 exp = build_indirect_ref (exp, "unary *"); 5947 } 5948 TREE_USED (var_decl) = 1; 5949 5950 /* Declare: _Block_object_dispose(void*, BLOCK_FIELD_IS_BYREF) if not done already. */ 5951 exp = build_component_ref (exp, get_identifier ("__forwarding")); 5952 call_exp = build_block_object_dispose_call_exp (exp, BLOCK_FIELD_IS_BYREF); 5953 return call_exp; 5954} 5955/* APPLE LOCAL end blocks 6040305 */ 5956/* APPLE LOCAL begin radar 5803600 */ 5957/** add_block_global_byref_list - Adds global variable decl to the list of 5958 byref global declarations in the current block. 5959*/ 5960void add_block_global_byref_list (tree decl) 5961{ 5962 cur_block->block_byref_global_decl_list = 5963 tree_cons (NULL_TREE, decl, cur_block->block_byref_global_decl_list); 5964} 5965 5966/** in_block_global_byref_list - returns TRUE if global variable is 5967 in the list of 'byref' declarations. 5968*/ 5969bool in_block_global_byref_list (tree decl) 5970{ 5971 tree chain; 5972 if (TREE_STATIC (decl)) { 5973 for (chain = cur_block->block_byref_global_decl_list; chain; 5974 chain = TREE_CHAIN (chain)) 5975 if (TREE_VALUE (chain) == decl) 5976 return true; 5977 } 5978 return false; 5979} 5980/* APPLE LOCAL end radar 5803600 */ 5981 5982/* APPLE LOCAL begin radar 6160536 */ 5983tree 5984build_block_helper_name (int unique_count) 5985{ 5986 char *buf; 5987 if (!current_function_decl) 5988 { 5989 /* APPLE LOCAL begin radar 6411649 */ 5990 static int global_count; 5991 buf = (char *)alloca (32); 5992 sprintf (buf, "__block_global_%d", ++global_count); 5993 /* APPLE LOCAL end radar 6411649 */ 5994 } 5995 else 5996 { 5997 tree outer_decl = current_function_decl; 5998 /* APPLE LOCAL begin radar 6169580 */ 5999 while (outer_decl && 6000 DECL_CONTEXT (outer_decl) && TREE_CODE (DECL_CONTEXT (outer_decl)) == FUNCTION_DECL) 6001 /* APPLE LOCAL end radar 6169580 */ 6002 outer_decl = DECL_CONTEXT (outer_decl); 6003 /* APPLE LOCAL begin radar 6411649 */ 6004 if (!unique_count) 6005 unique_count = ++DECL_STRUCT_FUNCTION(outer_decl)->unqiue_block_number; 6006 /* APPLE LOCAL end radar 6411649 */ 6007 buf = (char *)alloca (IDENTIFIER_LENGTH (DECL_NAME (outer_decl)) + 32); 6008 sprintf (buf, "__%s_block_invoke_%d", 6009 IDENTIFIER_POINTER (DECL_NAME (outer_decl)), unique_count); 6010 } 6011 return get_identifier (buf); 6012} 6013/* APPLE LOCAL end radar 6160536 */ 6014 6015/* Handle a "sentinel" attribute. */ 6016 6017static tree 6018handle_sentinel_attribute (tree *node, tree name, tree args, 6019 int ARG_UNUSED (flags), bool *no_add_attrs) 6020{ 6021 tree params = TYPE_ARG_TYPES (*node); 6022 6023 if (!params) 6024 { 6025 warning (OPT_Wattributes, 6026 "%qE attribute requires prototypes with named arguments", name); 6027 *no_add_attrs = true; 6028 } 6029 else 6030 { 6031 while (TREE_CHAIN (params)) 6032 params = TREE_CHAIN (params); 6033 6034 if (VOID_TYPE_P (TREE_VALUE (params))) 6035 { 6036 warning (OPT_Wattributes, 6037 "%qE attribute only applies to variadic functions", name); 6038 *no_add_attrs = true; 6039 } 6040 } 6041 6042 if (args) 6043 { 6044 tree position = TREE_VALUE (args); 6045 6046 if (TREE_CODE (position) != INTEGER_CST) 6047 { 6048 warning (0, "requested position is not an integer constant"); 6049 *no_add_attrs = true; 6050 } 6051 else 6052 { 6053 if (tree_int_cst_lt (position, integer_zero_node)) 6054 { 6055 warning (0, "requested position is less than zero"); 6056 *no_add_attrs = true; 6057 } 6058 } 6059 } 6060 6061 return NULL_TREE; 6062} 6063 6064/* Check for valid arguments being passed to a function. */ 6065void 6066check_function_arguments (tree attrs, tree params, tree typelist) 6067{ 6068 /* Check for null being passed in a pointer argument that must be 6069 non-null. We also need to do this if format checking is enabled. */ 6070 6071 if (warn_nonnull) 6072 check_function_nonnull (attrs, params); 6073 6074 /* Check for errors in format strings. */ 6075 6076 if (warn_format || warn_missing_format_attribute) 6077 check_function_format (attrs, params); 6078 6079 if (warn_format) 6080 check_function_sentinel (attrs, params, typelist); 6081} 6082 6083/* Generic argument checking recursion routine. PARAM is the argument to 6084 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked 6085 once the argument is resolved. CTX is context for the callback. */ 6086void 6087check_function_arguments_recurse (void (*callback) 6088 (void *, tree, unsigned HOST_WIDE_INT), 6089 void *ctx, tree param, 6090 unsigned HOST_WIDE_INT param_num) 6091{ 6092 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR) 6093 && (TYPE_PRECISION (TREE_TYPE (param)) 6094 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0))))) 6095 { 6096 /* Strip coercion. */ 6097 check_function_arguments_recurse (callback, ctx, 6098 TREE_OPERAND (param, 0), param_num); 6099 return; 6100 } 6101 6102 if (TREE_CODE (param) == CALL_EXPR) 6103 { 6104 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0))); 6105 tree attrs; 6106 bool found_format_arg = false; 6107 6108 /* See if this is a call to a known internationalization function 6109 that modifies a format arg. Such a function may have multiple 6110 format_arg attributes (for example, ngettext). */ 6111 6112 for (attrs = TYPE_ATTRIBUTES (type); 6113 attrs; 6114 attrs = TREE_CHAIN (attrs)) 6115 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs))) 6116 { 6117 tree inner_args; 6118 tree format_num_expr; 6119 int format_num; 6120 int i; 6121 6122 /* Extract the argument number, which was previously checked 6123 to be valid. */ 6124 format_num_expr = TREE_VALUE (TREE_VALUE (attrs)); 6125 6126 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST 6127 && !TREE_INT_CST_HIGH (format_num_expr)); 6128 6129 format_num = TREE_INT_CST_LOW (format_num_expr); 6130 6131 for (inner_args = TREE_OPERAND (param, 1), i = 1; 6132 inner_args != 0; 6133 inner_args = TREE_CHAIN (inner_args), i++) 6134 if (i == format_num) 6135 { 6136 check_function_arguments_recurse (callback, ctx, 6137 TREE_VALUE (inner_args), 6138 param_num); 6139 found_format_arg = true; 6140 break; 6141 } 6142 } 6143 6144 /* If we found a format_arg attribute and did a recursive check, 6145 we are done with checking this argument. Otherwise, we continue 6146 and this will be considered a non-literal. */ 6147 if (found_format_arg) 6148 return; 6149 } 6150 6151 if (TREE_CODE (param) == COND_EXPR) 6152 { 6153 /* Check both halves of the conditional expression. */ 6154 check_function_arguments_recurse (callback, ctx, 6155 TREE_OPERAND (param, 1), param_num); 6156 check_function_arguments_recurse (callback, ctx, 6157 TREE_OPERAND (param, 2), param_num); 6158 return; 6159 } 6160 6161 (*callback) (ctx, param, param_num); 6162} 6163 6164/* Function to help qsort sort FIELD_DECLs by name order. */ 6165 6166int 6167field_decl_cmp (const void *x_p, const void *y_p) 6168{ 6169 const tree *const x = (const tree *const) x_p; 6170 const tree *const y = (const tree *const) y_p; 6171 6172 if (DECL_NAME (*x) == DECL_NAME (*y)) 6173 /* A nontype is "greater" than a type. */ 6174 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL); 6175 if (DECL_NAME (*x) == NULL_TREE) 6176 return -1; 6177 if (DECL_NAME (*y) == NULL_TREE) 6178 return 1; 6179 if (DECL_NAME (*x) < DECL_NAME (*y)) 6180 return -1; 6181 return 1; 6182} 6183 6184static struct { 6185 gt_pointer_operator new_value; 6186 void *cookie; 6187} resort_data; 6188 6189/* This routine compares two fields like field_decl_cmp but using the 6190pointer operator in resort_data. */ 6191 6192static int 6193resort_field_decl_cmp (const void *x_p, const void *y_p) 6194{ 6195 const tree *const x = (const tree *const) x_p; 6196 const tree *const y = (const tree *const) y_p; 6197 6198 if (DECL_NAME (*x) == DECL_NAME (*y)) 6199 /* A nontype is "greater" than a type. */ 6200 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL); 6201 if (DECL_NAME (*x) == NULL_TREE) 6202 return -1; 6203 if (DECL_NAME (*y) == NULL_TREE) 6204 return 1; 6205 { 6206 tree d1 = DECL_NAME (*x); 6207 tree d2 = DECL_NAME (*y); 6208 resort_data.new_value (&d1, resort_data.cookie); 6209 resort_data.new_value (&d2, resort_data.cookie); 6210 if (d1 < d2) 6211 return -1; 6212 } 6213 return 1; 6214} 6215 6216/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */ 6217 6218void 6219resort_sorted_fields (void *obj, 6220 void * ARG_UNUSED (orig_obj), 6221 gt_pointer_operator new_value, 6222 void *cookie) 6223{ 6224 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj; 6225 resort_data.new_value = new_value; 6226 resort_data.cookie = cookie; 6227 qsort (&sf->elts[0], sf->len, sizeof (tree), 6228 resort_field_decl_cmp); 6229} 6230 6231/* Subroutine of c_parse_error. 6232 Return the result of concatenating LHS and RHS. RHS is really 6233 a string literal, its first character is indicated by RHS_START and 6234 RHS_SIZE is its length (including the terminating NUL character). 6235 6236 The caller is responsible for deleting the returned pointer. */ 6237 6238static char * 6239catenate_strings (const char *lhs, const char *rhs_start, int rhs_size) 6240{ 6241 const int lhs_size = strlen (lhs); 6242 char *result = XNEWVEC (char, lhs_size + rhs_size); 6243 strncpy (result, lhs, lhs_size); 6244 strncpy (result + lhs_size, rhs_start, rhs_size); 6245 return result; 6246} 6247 6248/* Issue the error given by GMSGID, indicating that it occurred before 6249 TOKEN, which had the associated VALUE. */ 6250 6251void 6252c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value) 6253{ 6254#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2)) 6255 6256 char *message = NULL; 6257 6258 if (token == CPP_EOF) 6259 message = catenate_messages (gmsgid, " at end of input"); 6260 else if (token == CPP_CHAR || token == CPP_WCHAR) 6261 { 6262 unsigned int val = TREE_INT_CST_LOW (value); 6263 const char *const ell = (token == CPP_CHAR) ? "" : "L"; 6264 if (val <= UCHAR_MAX && ISGRAPH (val)) 6265 message = catenate_messages (gmsgid, " before %s'%c'"); 6266 else 6267 message = catenate_messages (gmsgid, " before %s'\\x%x'"); 6268 6269 error (message, ell, val); 6270 free (message); 6271 message = NULL; 6272 } 6273 else if (token == CPP_STRING || token == CPP_WSTRING) 6274 message = catenate_messages (gmsgid, " before string constant"); 6275 else if (token == CPP_NUMBER) 6276 message = catenate_messages (gmsgid, " before numeric constant"); 6277 else if (token == CPP_NAME) 6278 { 6279 message = catenate_messages (gmsgid, " before %qE"); 6280 error (message, value); 6281 free (message); 6282 message = NULL; 6283 } 6284 else if (token == CPP_PRAGMA) 6285 message = catenate_messages (gmsgid, " before %<#pragma%>"); 6286 else if (token == CPP_PRAGMA_EOL) 6287 message = catenate_messages (gmsgid, " before end of line"); 6288 else if (token < N_TTYPES) 6289 { 6290 message = catenate_messages (gmsgid, " before %qs token"); 6291 error (message, cpp_type2name (token)); 6292 free (message); 6293 message = NULL; 6294 } 6295 else 6296 error (gmsgid, ""); 6297 6298 if (message) 6299 { 6300 error (message, ""); 6301 free (message); 6302 } 6303#undef catenate_messages 6304} 6305 6306/* Walk a gimplified function and warn for functions whose return value is 6307 ignored and attribute((warn_unused_result)) is set. This is done before 6308 inlining, so we don't have to worry about that. */ 6309 6310void 6311c_warn_unused_result (tree *top_p) 6312{ 6313 tree t = *top_p; 6314 tree_stmt_iterator i; 6315 tree fdecl, ftype; 6316 6317 switch (TREE_CODE (t)) 6318 { 6319 case STATEMENT_LIST: 6320 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i)) 6321 c_warn_unused_result (tsi_stmt_ptr (i)); 6322 break; 6323 6324 case COND_EXPR: 6325 c_warn_unused_result (&COND_EXPR_THEN (t)); 6326 c_warn_unused_result (&COND_EXPR_ELSE (t)); 6327 break; 6328 case BIND_EXPR: 6329 c_warn_unused_result (&BIND_EXPR_BODY (t)); 6330 break; 6331 case TRY_FINALLY_EXPR: 6332 case TRY_CATCH_EXPR: 6333 c_warn_unused_result (&TREE_OPERAND (t, 0)); 6334 c_warn_unused_result (&TREE_OPERAND (t, 1)); 6335 break; 6336 case CATCH_EXPR: 6337 c_warn_unused_result (&CATCH_BODY (t)); 6338 break; 6339 case EH_FILTER_EXPR: 6340 c_warn_unused_result (&EH_FILTER_FAILURE (t)); 6341 break; 6342 6343 case CALL_EXPR: 6344 if (TREE_USED (t)) 6345 break; 6346 6347 /* This is a naked call, as opposed to a CALL_EXPR nested inside 6348 a MODIFY_EXPR. All calls whose value is ignored should be 6349 represented like this. Look for the attribute. */ 6350 fdecl = get_callee_fndecl (t); 6351 if (fdecl) 6352 ftype = TREE_TYPE (fdecl); 6353 else 6354 { 6355 ftype = TREE_TYPE (TREE_OPERAND (t, 0)); 6356 /* Look past pointer-to-function to the function type itself. */ 6357 ftype = TREE_TYPE (ftype); 6358 } 6359 6360 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype))) 6361 { 6362 if (fdecl) 6363 warning (0, "%Hignoring return value of %qD, " 6364 "declared with attribute warn_unused_result", 6365 EXPR_LOCUS (t), fdecl); 6366 else 6367 warning (0, "%Hignoring return value of function " 6368 "declared with attribute warn_unused_result", 6369 EXPR_LOCUS (t)); 6370 } 6371 break; 6372 6373 default: 6374 /* Not a container, not a call, or a call whose value is used. */ 6375 break; 6376 } 6377} 6378 6379/* Convert a character from the host to the target execution character 6380 set. cpplib handles this, mostly. */ 6381 6382HOST_WIDE_INT 6383c_common_to_target_charset (HOST_WIDE_INT c) 6384{ 6385 /* Character constants in GCC proper are sign-extended under -fsigned-char, 6386 zero-extended under -fno-signed-char. cpplib insists that characters 6387 and character constants are always unsigned. Hence we must convert 6388 back and forth. */ 6389 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1); 6390 6391 uc = cpp_host_to_exec_charset (parse_in, uc); 6392 6393 if (flag_signed_char) 6394 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE) 6395 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE); 6396 else 6397 return uc; 6398} 6399 6400/* Build the result of __builtin_offsetof. EXPR is a nested sequence of 6401 component references, with STOP_REF, or alternatively an INDIRECT_REF of 6402 NULL, at the bottom; much like the traditional rendering of offsetof as a 6403 macro. Returns the folded and properly cast result. */ 6404 6405static tree 6406fold_offsetof_1 (tree expr, tree stop_ref) 6407{ 6408 enum tree_code code = PLUS_EXPR; 6409 tree base, off, t; 6410 6411 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK) 6412 return size_zero_node; 6413 6414 switch (TREE_CODE (expr)) 6415 { 6416 case ERROR_MARK: 6417 return expr; 6418 6419 case VAR_DECL: 6420 error ("cannot apply %<offsetof%> to static data member %qD", expr); 6421 return error_mark_node; 6422 6423 case CALL_EXPR: 6424 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded"); 6425 return error_mark_node; 6426 6427 case INTEGER_CST: 6428 gcc_assert (integer_zerop (expr)); 6429 return size_zero_node; 6430 6431 case NOP_EXPR: 6432 case INDIRECT_REF: 6433 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref); 6434 gcc_assert (base == error_mark_node || base == size_zero_node); 6435 return base; 6436 6437 case COMPONENT_REF: 6438 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref); 6439 if (base == error_mark_node) 6440 return base; 6441 6442 t = TREE_OPERAND (expr, 1); 6443 if (DECL_C_BIT_FIELD (t)) 6444 { 6445 error ("attempt to take address of bit-field structure " 6446 "member %qD", t); 6447 return error_mark_node; 6448 } 6449 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t), 6450 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1) 6451 / BITS_PER_UNIT)); 6452 break; 6453 6454 case ARRAY_REF: 6455 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref); 6456 if (base == error_mark_node) 6457 return base; 6458 6459 t = TREE_OPERAND (expr, 1); 6460 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0) 6461 { 6462 code = MINUS_EXPR; 6463 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t); 6464 } 6465 t = convert (sizetype, t); 6466 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t); 6467 break; 6468 6469 case COMPOUND_EXPR: 6470 /* Handle static members of volatile structs. */ 6471 t = TREE_OPERAND (expr, 1); 6472 gcc_assert (TREE_CODE (t) == VAR_DECL); 6473 return fold_offsetof_1 (t, stop_ref); 6474 6475 default: 6476 gcc_unreachable (); 6477 } 6478 6479 return size_binop (code, base, off); 6480} 6481 6482tree 6483fold_offsetof (tree expr, tree stop_ref) 6484{ 6485 /* Convert back from the internal sizetype to size_t. */ 6486 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref)); 6487} 6488 6489/* Print an error message for an invalid lvalue. USE says 6490 how the lvalue is being used and so selects the error message. */ 6491 6492void 6493lvalue_error (enum lvalue_use use) 6494{ 6495 switch (use) 6496 { 6497 case lv_assign: 6498 error ("lvalue required as left operand of assignment"); 6499 break; 6500 case lv_increment: 6501 error ("lvalue required as increment operand"); 6502 break; 6503 case lv_decrement: 6504 error ("lvalue required as decrement operand"); 6505 break; 6506 case lv_addressof: 6507 error ("lvalue required as unary %<&%> operand"); 6508 break; 6509 case lv_asm: 6510 error ("lvalue required in asm statement"); 6511 break; 6512 default: 6513 gcc_unreachable (); 6514 } 6515} 6516 6517/* *PTYPE is an incomplete array. Complete it with a domain based on 6518 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT 6519 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 6520 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */ 6521 6522int 6523complete_array_type (tree *ptype, tree initial_value, bool do_default) 6524{ 6525 tree maxindex, type, main_type, elt, unqual_elt; 6526 int failure = 0, quals; 6527 6528 maxindex = size_zero_node; 6529 if (initial_value) 6530 { 6531 if (TREE_CODE (initial_value) == STRING_CST) 6532 { 6533 int eltsize 6534 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); 6535 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1); 6536 } 6537 else if (TREE_CODE (initial_value) == CONSTRUCTOR) 6538 { 6539 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value); 6540 6541 if (VEC_empty (constructor_elt, v)) 6542 { 6543 if (pedantic) 6544 failure = 3; 6545 maxindex = integer_minus_one_node; 6546 } 6547 else 6548 { 6549 tree curindex; 6550 unsigned HOST_WIDE_INT cnt; 6551 constructor_elt *ce; 6552 6553 if (VEC_index (constructor_elt, v, 0)->index) 6554 maxindex = fold_convert (sizetype, 6555 VEC_index (constructor_elt, 6556 v, 0)->index); 6557 curindex = maxindex; 6558 6559 for (cnt = 1; 6560 VEC_iterate (constructor_elt, v, cnt, ce); 6561 cnt++) 6562 { 6563 if (ce->index) 6564 curindex = fold_convert (sizetype, ce->index); 6565 else 6566 curindex = size_binop (PLUS_EXPR, curindex, size_one_node); 6567 6568 if (tree_int_cst_lt (maxindex, curindex)) 6569 maxindex = curindex; 6570 } 6571 } 6572 } 6573 else 6574 { 6575 /* Make an error message unless that happened already. */ 6576 if (initial_value != error_mark_node) 6577 failure = 1; 6578 } 6579 } 6580 else 6581 { 6582 failure = 2; 6583 if (!do_default) 6584 return failure; 6585 } 6586 6587 type = *ptype; 6588 elt = TREE_TYPE (type); 6589 quals = TYPE_QUALS (strip_array_types (elt)); 6590 if (quals == 0) 6591 unqual_elt = elt; 6592 else 6593 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED); 6594 6595 /* Using build_distinct_type_copy and modifying things afterward instead 6596 of using build_array_type to create a new type preserves all of the 6597 TYPE_LANG_FLAG_? bits that the front end may have set. */ 6598 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 6599 TREE_TYPE (main_type) = unqual_elt; 6600 TYPE_DOMAIN (main_type) = build_index_type (maxindex); 6601 layout_type (main_type); 6602 6603 if (quals == 0) 6604 type = main_type; 6605 else 6606 type = c_build_qualified_type (main_type, quals); 6607 6608 *ptype = type; 6609 return failure; 6610} 6611 6612 6613/* Used to help initialize the builtin-types.def table. When a type of 6614 the correct size doesn't exist, use error_mark_node instead of NULL. 6615 The later results in segfaults even when a decl using the type doesn't 6616 get invoked. */ 6617 6618tree 6619builtin_type_for_size (int size, bool unsignedp) 6620{ 6621 tree type = lang_hooks.types.type_for_size (size, unsignedp); 6622 return type ? type : error_mark_node; 6623} 6624 6625/* A helper function for resolve_overloaded_builtin in resolving the 6626 overloaded __sync_ builtins. Returns a positive power of 2 if the 6627 first operand of PARAMS is a pointer to a supported data type. 6628 Returns 0 if an error is encountered. */ 6629 6630static int 6631sync_resolve_size (tree function, tree params) 6632{ 6633 tree type; 6634 int size; 6635 6636 if (params == NULL) 6637 { 6638 error ("too few arguments to function %qE", function); 6639 return 0; 6640 } 6641 6642 type = TREE_TYPE (TREE_VALUE (params)); 6643 if (TREE_CODE (type) != POINTER_TYPE) 6644 goto incompatible; 6645 6646 type = TREE_TYPE (type); 6647 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type)) 6648 goto incompatible; 6649 6650 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1); 6651 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16) 6652 return size; 6653 6654 incompatible: 6655 error ("incompatible type for argument %d of %qE", 1, function); 6656 return 0; 6657} 6658 6659/* A helper function for resolve_overloaded_builtin. Adds casts to 6660 PARAMS to make arguments match up with those of FUNCTION. Drops 6661 the variadic arguments at the end. Returns false if some error 6662 was encountered; true on success. */ 6663 6664static bool 6665sync_resolve_params (tree orig_function, tree function, tree params) 6666{ 6667 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 6668 tree ptype; 6669 int number; 6670 6671 /* We've declared the implementation functions to use "volatile void *" 6672 as the pointer parameter, so we shouldn't get any complaints from the 6673 call to check_function_arguments what ever type the user used. */ 6674 arg_types = TREE_CHAIN (arg_types); 6675 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params))); 6676 number = 2; 6677 6678 /* For the rest of the values, we need to cast these to FTYPE, so that we 6679 don't get warnings for passing pointer types, etc. */ 6680 while (arg_types != void_list_node) 6681 { 6682 tree val; 6683 6684 params = TREE_CHAIN (params); 6685 if (params == NULL) 6686 { 6687 error ("too few arguments to function %qE", orig_function); 6688 return false; 6689 } 6690 6691 /* ??? Ideally for the first conversion we'd use convert_for_assignment 6692 so that we get warnings for anything that doesn't match the pointer 6693 type. This isn't portable across the C and C++ front ends atm. */ 6694 val = TREE_VALUE (params); 6695 val = convert (ptype, val); 6696 val = convert (TREE_VALUE (arg_types), val); 6697 TREE_VALUE (params) = val; 6698 6699 arg_types = TREE_CHAIN (arg_types); 6700 number++; 6701 } 6702 6703 /* The definition of these primitives is variadic, with the remaining 6704 being "an optional list of variables protected by the memory barrier". 6705 No clue what that's supposed to mean, precisely, but we consider all 6706 call-clobbered variables to be protected so we're safe. */ 6707 TREE_CHAIN (params) = NULL; 6708 6709 return true; 6710} 6711 6712/* A helper function for resolve_overloaded_builtin. Adds a cast to 6713 RESULT to make it match the type of the first pointer argument in 6714 PARAMS. */ 6715 6716static tree 6717sync_resolve_return (tree params, tree result) 6718{ 6719 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params))); 6720 ptype = TYPE_MAIN_VARIANT (ptype); 6721 return convert (ptype, result); 6722} 6723 6724/* Some builtin functions are placeholders for other expressions. This 6725 function should be called immediately after parsing the call expression 6726 before surrounding code has committed to the type of the expression. 6727 6728 FUNCTION is the DECL that has been invoked; it is known to be a builtin. 6729 PARAMS is the argument list for the call. The return value is non-null 6730 when expansion is complete, and null if normal processing should 6731 continue. */ 6732 6733tree 6734resolve_overloaded_builtin (tree function, tree params) 6735{ 6736 enum built_in_function orig_code = DECL_FUNCTION_CODE (function); 6737 switch (DECL_BUILT_IN_CLASS (function)) 6738 { 6739 case BUILT_IN_NORMAL: 6740 break; 6741 case BUILT_IN_MD: 6742 if (targetm.resolve_overloaded_builtin) 6743 return targetm.resolve_overloaded_builtin (function, params); 6744 else 6745 return NULL_TREE; 6746 default: 6747 return NULL_TREE; 6748 } 6749 6750 /* Handle BUILT_IN_NORMAL here. */ 6751 switch (orig_code) 6752 { 6753 case BUILT_IN_FETCH_AND_ADD_N: 6754 case BUILT_IN_FETCH_AND_SUB_N: 6755 case BUILT_IN_FETCH_AND_OR_N: 6756 case BUILT_IN_FETCH_AND_AND_N: 6757 case BUILT_IN_FETCH_AND_XOR_N: 6758 case BUILT_IN_FETCH_AND_NAND_N: 6759 case BUILT_IN_ADD_AND_FETCH_N: 6760 case BUILT_IN_SUB_AND_FETCH_N: 6761 case BUILT_IN_OR_AND_FETCH_N: 6762 case BUILT_IN_AND_AND_FETCH_N: 6763 case BUILT_IN_XOR_AND_FETCH_N: 6764 case BUILT_IN_NAND_AND_FETCH_N: 6765 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N: 6766 case BUILT_IN_VAL_COMPARE_AND_SWAP_N: 6767 case BUILT_IN_LOCK_TEST_AND_SET_N: 6768 case BUILT_IN_LOCK_RELEASE_N: 6769 { 6770 int n = sync_resolve_size (function, params); 6771 tree new_function, result; 6772 6773 if (n == 0) 6774 return error_mark_node; 6775 6776 new_function = built_in_decls[orig_code + exact_log2 (n) + 1]; 6777 if (!sync_resolve_params (function, new_function, params)) 6778 return error_mark_node; 6779 6780 result = build_function_call (new_function, params); 6781 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N 6782 && orig_code != BUILT_IN_LOCK_RELEASE_N) 6783 result = sync_resolve_return (params, result); 6784 6785 return result; 6786 } 6787 6788 default: 6789 return NULL_TREE; 6790 } 6791} 6792 6793/* Ignoring their sign, return true if two scalar types are the same. */ 6794bool 6795same_scalar_type_ignoring_signedness (tree t1, tree t2) 6796{ 6797 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2); 6798 6799 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE) 6800 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE)); 6801 6802 /* Equality works here because c_common_signed_type uses 6803 TYPE_MAIN_VARIANT. */ 6804 return lang_hooks.types.signed_type (t1) 6805 == lang_hooks.types.signed_type (t2); 6806} 6807 6808/* Check for missing format attributes on function pointers. LTYPE is 6809 the new type or left-hand side type. RTYPE is the old type or 6810 right-hand side type. Returns TRUE if LTYPE is missing the desired 6811 attribute. */ 6812 6813bool 6814check_missing_format_attribute (tree ltype, tree rtype) 6815{ 6816 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype); 6817 tree ra; 6818 6819 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra)) 6820 if (is_attribute_p ("format", TREE_PURPOSE (ra))) 6821 break; 6822 if (ra) 6823 { 6824 tree la; 6825 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la)) 6826 if (is_attribute_p ("format", TREE_PURPOSE (la))) 6827 break; 6828 return !la; 6829 } 6830 else 6831 return false; 6832} 6833 6834/* Subscripting with type char is likely to lose on a machine where 6835 chars are signed. So warn on any machine, but optionally. Don't 6836 warn for unsigned char since that type is safe. Don't warn for 6837 signed char because anyone who uses that must have done so 6838 deliberately. Furthermore, we reduce the false positive load by 6839 warning only for non-constant value of type char. */ 6840 6841void 6842warn_array_subscript_with_type_char (tree index) 6843{ 6844 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node 6845 && TREE_CODE (index) != INTEGER_CST) 6846 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>"); 6847} 6848 6849/* Implement -Wparentheses for the unexpected C precedence rules, to 6850 cover cases like x + y << z which readers are likely to 6851 misinterpret. We have seen an expression in which CODE is a binary 6852 operator used to combine expressions headed by CODE_LEFT and 6853 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which 6854 means that that side of the expression was not formed using a 6855 binary operator, or it was enclosed in parentheses. */ 6856 6857void 6858warn_about_parentheses (enum tree_code code, enum tree_code code_left, 6859 enum tree_code code_right) 6860{ 6861 if (!warn_parentheses) 6862 return; 6863 6864 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) 6865 { 6866 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR 6867 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 6868 warning (OPT_Wparentheses, 6869 "suggest parentheses around + or - inside shift"); 6870 } 6871 6872 if (code == TRUTH_ORIF_EXPR) 6873 { 6874 if (code_left == TRUTH_ANDIF_EXPR 6875 || code_right == TRUTH_ANDIF_EXPR) 6876 warning (OPT_Wparentheses, 6877 "suggest parentheses around && within ||"); 6878 } 6879 6880 if (code == BIT_IOR_EXPR) 6881 { 6882 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR 6883 || code_left == PLUS_EXPR || code_left == MINUS_EXPR 6884 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR 6885 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 6886 warning (OPT_Wparentheses, 6887 "suggest parentheses around arithmetic in operand of |"); 6888 /* Check cases like x|y==z */ 6889 if (TREE_CODE_CLASS (code_left) == tcc_comparison 6890 || TREE_CODE_CLASS (code_right) == tcc_comparison) 6891 warning (OPT_Wparentheses, 6892 "suggest parentheses around comparison in operand of |"); 6893 } 6894 6895 if (code == BIT_XOR_EXPR) 6896 { 6897 if (code_left == BIT_AND_EXPR 6898 || code_left == PLUS_EXPR || code_left == MINUS_EXPR 6899 || code_right == BIT_AND_EXPR 6900 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 6901 warning (OPT_Wparentheses, 6902 "suggest parentheses around arithmetic in operand of ^"); 6903 /* Check cases like x^y==z */ 6904 if (TREE_CODE_CLASS (code_left) == tcc_comparison 6905 || TREE_CODE_CLASS (code_right) == tcc_comparison) 6906 warning (OPT_Wparentheses, 6907 "suggest parentheses around comparison in operand of ^"); 6908 } 6909 6910 if (code == BIT_AND_EXPR) 6911 { 6912 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR 6913 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 6914 warning (OPT_Wparentheses, 6915 "suggest parentheses around + or - in operand of &"); 6916 /* Check cases like x&y==z */ 6917 if (TREE_CODE_CLASS (code_left) == tcc_comparison 6918 || TREE_CODE_CLASS (code_right) == tcc_comparison) 6919 warning (OPT_Wparentheses, 6920 "suggest parentheses around comparison in operand of &"); 6921 } 6922 6923 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ 6924 if (TREE_CODE_CLASS (code) == tcc_comparison 6925 && (TREE_CODE_CLASS (code_left) == tcc_comparison 6926 || TREE_CODE_CLASS (code_right) == tcc_comparison)) 6927 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not " 6928 "have their mathematical meaning"); 6929} 6930 6931/* APPLE LOCAL begin radar 6246527 */ 6932/* This routine is called for a "format" attribute. It adds the number of 6933 hidden argument ('1') to the format's 2nd and 3rd argument to compensate 6934 for these two arguments. This is to make rest of the "format" attribute 6935 processing done in the middle-end to work seemlessly. */ 6936 6937static void 6938block_delta_format_args (tree format) 6939{ 6940 tree format_num_expr, first_arg_num_expr; 6941 int val; 6942 tree args = TREE_VALUE (format); 6943 gcc_assert (TREE_CHAIN (args) && TREE_CHAIN (TREE_CHAIN (args))); 6944 format_num_expr = TREE_VALUE (TREE_CHAIN (args)); 6945 first_arg_num_expr = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))); 6946 if (format_num_expr && TREE_CODE (format_num_expr) == INTEGER_CST) 6947 { 6948 val = TREE_INT_CST_LOW (format_num_expr); 6949 TREE_VALUE (TREE_CHAIN (args)) = build_int_cst (NULL_TREE, val+1); 6950 } 6951 if (first_arg_num_expr && TREE_CODE (first_arg_num_expr) == INTEGER_CST) 6952 { 6953 val = TREE_INT_CST_LOW (first_arg_num_expr); 6954 if (val != 0) 6955 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))) = 6956 build_int_cst (NULL_TREE, val+1); 6957 } 6958} 6959 6960/* This routine recognizes legal block attributes. In case of block's "format" 6961 attribute, it calls block_delta_format_args to compensate for hidden 6962 argument _self getting passed to block's helper function. */ 6963bool 6964any_recognized_block_attribute (tree attributes) 6965{ 6966 tree chain; 6967 bool res = false; 6968 for (chain = attributes; chain; chain = TREE_CHAIN (chain)) 6969 { 6970 if (is_attribute_p ("format", TREE_PURPOSE (chain))) 6971 { 6972 block_delta_format_args (chain); 6973 res = true; 6974 } 6975 else if (is_attribute_p ("sentinel", TREE_PURPOSE (chain))) 6976 res = true; 6977 } 6978 return res; 6979} 6980/* APPLE LOCAL end radar 6246527 */ 6981/* APPLE LOCAL begin radar 5847976 */ 6982static GTY(()) tree block_object_assign_decl; 6983static GTY(()) tree block_object_dispose_func_decl; 6984/* This routine declares: 6985 void _Block_object_assign (void *, void *, int) or uses an 6986 existing one. 6987*/ 6988static tree 6989build_block_object_assign_decl (void) 6990{ 6991 tree func_type; 6992 if (block_object_assign_decl) 6993 return block_object_assign_decl; 6994 block_object_assign_decl = lookup_name (get_identifier ("_Block_object_assign")); 6995 if (block_object_assign_decl) 6996 return block_object_assign_decl; 6997 func_type = 6998 build_function_type (void_type_node, 6999 tree_cons (NULL_TREE, ptr_type_node, 7000 tree_cons (NULL_TREE, ptr_type_node, 7001 tree_cons (NULL_TREE, integer_type_node, void_list_node)))); 7002 7003 block_object_assign_decl = builtin_function ("_Block_object_assign", func_type, 7004 0, NOT_BUILT_IN, 0, NULL_TREE); 7005 TREE_NOTHROW (block_object_assign_decl) = 0; 7006 return block_object_assign_decl; 7007} 7008 7009/* This routine builds: 7010 _Block_object_assign(dest, src, flag) 7011*/ 7012tree build_block_object_assign_call_exp (tree dst, tree src, int flag) 7013{ 7014 tree func_params = tree_cons (NULL_TREE, dst, 7015 tree_cons (NULL_TREE, src, 7016 tree_cons (NULL_TREE, 7017 build_int_cst (integer_type_node, flag), 7018 NULL_TREE))); 7019 return build_function_call (build_block_object_assign_decl (), func_params); 7020} 7021 7022/* This routine declares: 7023 void _Block_object_dispose (void *, int) or uses an 7024 existing one. 7025*/ 7026static tree 7027build_block_object_dispose_decl (void) 7028{ 7029 tree func_type; 7030 if (block_object_dispose_func_decl) 7031 return block_object_dispose_func_decl; 7032 block_object_dispose_func_decl = lookup_name (get_identifier ("_Block_object_dispose")); 7033 if (block_object_dispose_func_decl) 7034 return block_object_dispose_func_decl; 7035 func_type = 7036 build_function_type (void_type_node, 7037 tree_cons (NULL_TREE, ptr_type_node, 7038 tree_cons (NULL_TREE, integer_type_node, void_list_node))); 7039 7040 block_object_dispose_func_decl = builtin_function ("_Block_object_dispose", func_type, 7041 0, NOT_BUILT_IN, 0, NULL_TREE); 7042 TREE_NOTHROW (block_object_dispose_func_decl) = 0; 7043 return block_object_dispose_func_decl; 7044} 7045 7046/* This routine builds the call tree: 7047 _Block_object_dispose(src, flag) 7048*/ 7049tree build_block_object_dispose_call_exp (tree src, int flag) 7050{ 7051 tree func_params = tree_cons (NULL_TREE, src, 7052 tree_cons (NULL_TREE, 7053 build_int_cst (integer_type_node, flag), 7054 NULL_TREE)); 7055 return build_function_call (build_block_object_dispose_decl (), func_params); 7056} 7057/* APPLE LOCAL end radar 5847976 */ 7058/* APPLE LOCAL begin radar 7760213 */ 7059int HasByrefArray(tree byrefType) 7060{ 7061 tree s1; 7062 /* Check for possibility of an error condition. */ 7063 if (TREE_CODE(byrefType) != RECORD_TYPE) 7064 return 0; 7065 7066 for (s1 = TYPE_FIELDS (byrefType); s1; s1 = TREE_CHAIN (s1)) 7067 { 7068 if (TREE_CODE(TREE_TYPE(s1)) == ARRAY_TYPE) 7069 return 1; 7070 } 7071 return 0; 7072} 7073/* APPLE LOCAL end radar 7760213 */ 7074#include "gt-c-common.h" 7075