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, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 3, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING3. If not see 20<http://www.gnu.org/licenses/>. */ 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 "tm_p.h" 37#include "obstack.h" 38#include "cpplib.h" 39#include "target.h" 40#include "langhooks.h" 41#include "tree-inline.h" 42#include "c-tree.h" 43#include "toplev.h" 44#include "diagnostic.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#include "target-def.h" 52#include "gimple.h" 53#include "fixed-value.h" 54#include "libfuncs.h" 55 56cpp_reader *parse_in; /* Declared in c-pragma.h. */ 57 58/* The following symbols are subsumed in the c_global_trees array, and 59 listed here individually for documentation purposes. 60 61 INTEGER_TYPE and REAL_TYPE nodes for the standard data types. 62 63 tree short_integer_type_node; 64 tree long_integer_type_node; 65 tree long_long_integer_type_node; 66 67 tree short_unsigned_type_node; 68 tree long_unsigned_type_node; 69 tree long_long_unsigned_type_node; 70 71 tree truthvalue_type_node; 72 tree truthvalue_false_node; 73 tree truthvalue_true_node; 74 75 tree ptrdiff_type_node; 76 77 tree unsigned_char_type_node; 78 tree signed_char_type_node; 79 tree wchar_type_node; 80 81 tree char16_type_node; 82 tree char32_type_node; 83 84 tree float_type_node; 85 tree double_type_node; 86 tree long_double_type_node; 87 88 tree complex_integer_type_node; 89 tree complex_float_type_node; 90 tree complex_double_type_node; 91 tree complex_long_double_type_node; 92 93 tree dfloat32_type_node; 94 tree dfloat64_type_node; 95 tree_dfloat128_type_node; 96 97 tree intQI_type_node; 98 tree intHI_type_node; 99 tree intSI_type_node; 100 tree intDI_type_node; 101 tree intTI_type_node; 102 103 tree unsigned_intQI_type_node; 104 tree unsigned_intHI_type_node; 105 tree unsigned_intSI_type_node; 106 tree unsigned_intDI_type_node; 107 tree unsigned_intTI_type_node; 108 109 tree widest_integer_literal_type_node; 110 tree widest_unsigned_literal_type_node; 111 112 Nodes for types `void *' and `const void *'. 113 114 tree ptr_type_node, const_ptr_type_node; 115 116 Nodes for types `char *' and `const char *'. 117 118 tree string_type_node, const_string_type_node; 119 120 Type `char[SOMENUMBER]'. 121 Used when an array of char is needed and the size is irrelevant. 122 123 tree char_array_type_node; 124 125 Type `int[SOMENUMBER]' or something like it. 126 Used when an array of int needed and the size is irrelevant. 127 128 tree int_array_type_node; 129 130 Type `wchar_t[SOMENUMBER]' or something like it. 131 Used when a wide string literal is created. 132 133 tree wchar_array_type_node; 134 135 Type `char16_t[SOMENUMBER]' or something like it. 136 Used when a UTF-16 string literal is created. 137 138 tree char16_array_type_node; 139 140 Type `char32_t[SOMENUMBER]' or something like it. 141 Used when a UTF-32 string literal is created. 142 143 tree char32_array_type_node; 144 145 Type `int ()' -- used for implicit declaration of functions. 146 147 tree default_function_type; 148 149 A VOID_TYPE node, packaged in a TREE_LIST. 150 151 tree void_list_node; 152 153 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__, 154 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__ 155 VAR_DECLS, but C++ does.) 156 157 tree function_name_decl_node; 158 tree pretty_function_name_decl_node; 159 tree c99_function_name_decl_node; 160 161 Stack of nested function name VAR_DECLs. 162 163 tree saved_function_name_decls; 164 165*/ 166 167tree c_global_trees[CTI_MAX]; 168 169/* Switches common to the C front ends. */ 170 171/* Nonzero if preprocessing only. */ 172 173int flag_preprocess_only; 174 175/* Nonzero means don't output line number information. */ 176 177char flag_no_line_commands; 178 179/* Nonzero causes -E output not to be done, but directives such as 180 #define that have side effects are still obeyed. */ 181 182char flag_no_output; 183 184/* Nonzero means dump macros in some fashion. */ 185 186char flag_dump_macros; 187 188/* Nonzero means pass #include lines through to the output. */ 189 190char flag_dump_includes; 191 192/* Nonzero means process PCH files while preprocessing. */ 193 194bool flag_pch_preprocess; 195 196/* The file name to which we should write a precompiled header, or 197 NULL if no header will be written in this compile. */ 198 199const char *pch_file; 200 201/* Nonzero if an ISO standard was selected. It rejects macros in the 202 user's namespace. */ 203int flag_iso; 204 205/* Nonzero if -undef was given. It suppresses target built-in macros 206 and assertions. */ 207int flag_undef; 208 209/* Nonzero means don't recognize the non-ANSI builtin functions. */ 210 211int flag_no_builtin; 212 213/* Nonzero means don't recognize the non-ANSI builtin functions. 214 -ansi sets this. */ 215 216int flag_no_nonansi_builtin; 217 218/* Nonzero means give `double' the same size as `float'. */ 219 220int flag_short_double; 221 222/* Nonzero means give `wchar_t' the same size as `short'. */ 223 224int flag_short_wchar; 225 226/* Nonzero means allow implicit conversions between vectors with 227 differing numbers of subparts and/or differing element types. */ 228int flag_lax_vector_conversions; 229 230/* Nonzero means allow Microsoft extensions without warnings or errors. */ 231int flag_ms_extensions; 232 233/* Nonzero means don't recognize the keyword `asm'. */ 234 235int flag_no_asm; 236 237/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */ 238 239int flag_signed_bitfields = 1; 240 241/* Warn about #pragma directives that are not recognized. */ 242 243int warn_unknown_pragmas; /* Tri state variable. */ 244 245/* Warn about format/argument anomalies in calls to formatted I/O functions 246 (*printf, *scanf, strftime, strfmon, etc.). */ 247 248int warn_format; 249 250/* Warn about using __null (as NULL in C++) as sentinel. For code compiled 251 with GCC this doesn't matter as __null is guaranteed to have the right 252 size. */ 253 254int warn_strict_null_sentinel; 255 256/* Zero means that faster, ...NonNil variants of objc_msgSend... 257 calls will be used in ObjC; passing nil receivers to such calls 258 will most likely result in crashes. */ 259int flag_nil_receivers = 1; 260 261/* Nonzero means that code generation will be altered to support 262 "zero-link" execution. This currently affects ObjC only, but may 263 affect other languages in the future. */ 264int flag_zero_link = 0; 265 266/* Nonzero means emit an '__OBJC, __image_info' for the current translation 267 unit. It will inform the ObjC runtime that class definition(s) herein 268 contained are to replace one(s) previously loaded. */ 269int flag_replace_objc_classes = 0; 270 271/* C/ObjC language option variables. */ 272 273 274/* Nonzero means allow type mismatches in conditional expressions; 275 just make their values `void'. */ 276 277int flag_cond_mismatch; 278 279/* Nonzero means enable C89 Amendment 1 features. */ 280 281int flag_isoc94; 282 283/* Nonzero means use the ISO C99 dialect of C. */ 284 285int flag_isoc99; 286 287/* Nonzero means that we have builtin functions, and main is an int. */ 288 289int flag_hosted = 1; 290 291 292/* ObjC language option variables. */ 293 294 295/* Open and close the file for outputting class declarations, if 296 requested (ObjC). */ 297 298int flag_gen_declaration; 299 300/* Tells the compiler that this is a special run. Do not perform any 301 compiling, instead we are to test some platform dependent features 302 and output a C header file with appropriate definitions. */ 303 304int print_struct_values; 305 306/* Tells the compiler what is the constant string class for ObjC. */ 307 308const char *constant_string_class_name; 309 310 311/* C++ language option variables. */ 312 313 314/* Nonzero means don't recognize any extension keywords. */ 315 316int flag_no_gnu_keywords; 317 318/* Nonzero means do emit exported implementations of functions even if 319 they can be inlined. */ 320 321int flag_implement_inlines = 1; 322 323/* Nonzero means that implicit instantiations will be emitted if needed. */ 324 325int flag_implicit_templates = 1; 326 327/* Nonzero means that implicit instantiations of inline templates will be 328 emitted if needed, even if instantiations of non-inline templates 329 aren't. */ 330 331int flag_implicit_inline_templates = 1; 332 333/* Nonzero means generate separate instantiation control files and 334 juggle them at link time. */ 335 336int flag_use_repository; 337 338/* Nonzero if we want to issue diagnostics that the standard says are not 339 required. */ 340 341int flag_optional_diags = 1; 342 343/* Nonzero means we should attempt to elide constructors when possible. */ 344 345int flag_elide_constructors = 1; 346 347/* Nonzero means that member functions defined in class scope are 348 inline by default. */ 349 350int flag_default_inline = 1; 351 352/* Controls whether compiler generates 'type descriptor' that give 353 run-time type information. */ 354 355int flag_rtti = 1; 356 357/* Nonzero if we want to conserve space in the .o files. We do this 358 by putting uninitialized data and runtime initialized data into 359 .common instead of .data at the expense of not flagging multiple 360 definitions. */ 361 362int flag_conserve_space; 363 364/* Nonzero if we want to obey access control semantics. */ 365 366int flag_access_control = 1; 367 368/* Nonzero if we want to check the return value of new and avoid calling 369 constructors if it is a null pointer. */ 370 371int flag_check_new; 372 373/* The C++ dialect being used. C++98 is the default. */ 374 375enum cxx_dialect cxx_dialect = cxx98; 376 377/* Nonzero if we want the new ISO rules for pushing a new scope for `for' 378 initialization variables. 379 0: Old rules, set by -fno-for-scope. 380 2: New ISO rules, set by -ffor-scope. 381 1: Try to implement new ISO rules, but with backup compatibility 382 (and warnings). This is the default, for now. */ 383 384int flag_new_for_scope = 1; 385 386/* Nonzero if we want to emit defined symbols with common-like linkage as 387 weak symbols where possible, in order to conform to C++ semantics. 388 Otherwise, emit them as local symbols. */ 389 390int flag_weak = 1; 391 392/* 0 means we want the preprocessor to not emit line directives for 393 the current working directory. 1 means we want it to do it. -1 394 means we should decide depending on whether debugging information 395 is being emitted or not. */ 396 397int flag_working_directory = -1; 398 399/* Nonzero to use __cxa_atexit, rather than atexit, to register 400 destructors for local statics and global objects. '2' means it has been 401 set nonzero as a default, not by a command-line flag. */ 402 403int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT; 404 405/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling 406 code. '2' means it has not been set explicitly on the command line. */ 407 408int flag_use_cxa_get_exception_ptr = 2; 409 410/* Nonzero means to implement standard semantics for exception 411 specifications, calling unexpected if an exception is thrown that 412 doesn't match the specification. Zero means to treat them as 413 assertions and optimize accordingly, but not check them. */ 414 415int flag_enforce_eh_specs = 1; 416 417/* Nonzero means to generate thread-safe code for initializing local 418 statics. */ 419 420int flag_threadsafe_statics = 1; 421 422/* Nonzero if we want to pretty-print template specializations as the 423 template signature followed by the arguments. */ 424 425int flag_pretty_templates = 1; 426 427/* Nonzero means warn about implicit declarations. */ 428 429int warn_implicit = 1; 430 431/* Maximum template instantiation depth. This limit exists to limit the 432 time it takes to notice infinite template instantiations; the default 433 value of 1024 is likely to be in the next C++ standard. */ 434 435int max_tinst_depth = 1024; 436 437 438 439/* The elements of `ridpointers' are identifier nodes for the reserved 440 type names and storage classes. It is indexed by a RID_... value. */ 441tree *ridpointers; 442 443tree (*make_fname_decl) (location_t, tree, int); 444 445/* Nonzero means don't warn about problems that occur when the code is 446 executed. */ 447int c_inhibit_evaluation_warnings; 448 449/* Whether we are building a boolean conversion inside 450 convert_for_assignment, or some other late binary operation. If 451 build_binary_op is called for C (from code shared by C and C++) in 452 this case, then the operands have already been folded and the 453 result will not be folded again, so C_MAYBE_CONST_EXPR should not 454 be generated. */ 455bool in_late_binary_op; 456 457/* Whether lexing has been completed, so subsequent preprocessor 458 errors should use the compiler's input_location. */ 459bool done_lexing = false; 460 461/* Information about how a function name is generated. */ 462struct fname_var_t 463{ 464 tree *const decl; /* pointer to the VAR_DECL. */ 465 const unsigned rid; /* RID number for the identifier. */ 466 const int pretty; /* How pretty is it? */ 467}; 468 469/* The three ways of getting then name of the current function. */ 470 471const struct fname_var_t fname_vars[] = 472{ 473 /* C99 compliant __func__, must be first. */ 474 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0}, 475 /* GCC __FUNCTION__ compliant. */ 476 {&function_name_decl_node, RID_FUNCTION_NAME, 0}, 477 /* GCC __PRETTY_FUNCTION__ compliant. */ 478 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1}, 479 {NULL, 0, 0}, 480}; 481 482static tree c_fully_fold_internal (tree expr, bool, bool *, bool *); 483static tree check_case_value (tree); 484static bool check_case_bounds (tree, tree, tree *, tree *); 485 486static tree handle_packed_attribute (tree *, tree, tree, int, bool *); 487static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *); 488static tree handle_common_attribute (tree *, tree, tree, int, bool *); 489static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *); 490static tree handle_hot_attribute (tree *, tree, tree, int, bool *); 491static tree handle_cold_attribute (tree *, tree, tree, int, bool *); 492static tree handle_noinline_attribute (tree *, tree, tree, int, bool *); 493static tree handle_noclone_attribute (tree *, tree, tree, int, bool *); 494static tree handle_always_inline_attribute (tree *, tree, tree, int, 495 bool *); 496static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *); 497static tree handle_artificial_attribute (tree *, tree, tree, int, bool *); 498static tree handle_flatten_attribute (tree *, tree, tree, int, bool *); 499static tree handle_error_attribute (tree *, tree, tree, int, bool *); 500static tree handle_used_attribute (tree *, tree, tree, int, bool *); 501static tree handle_unused_attribute (tree *, tree, tree, int, bool *); 502static tree handle_externally_visible_attribute (tree *, tree, tree, int, 503 bool *); 504static tree handle_const_attribute (tree *, tree, tree, int, bool *); 505static tree handle_transparent_union_attribute (tree *, tree, tree, 506 int, bool *); 507static tree handle_constructor_attribute (tree *, tree, tree, int, bool *); 508static tree handle_destructor_attribute (tree *, tree, tree, int, bool *); 509static tree handle_mode_attribute (tree *, tree, tree, int, bool *); 510static tree handle_section_attribute (tree *, tree, tree, int, bool *); 511static tree handle_aligned_attribute (tree *, tree, tree, int, bool *); 512static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ; 513static tree handle_alias_attribute (tree *, tree, tree, int, bool *); 514static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ; 515static tree handle_visibility_attribute (tree *, tree, tree, int, 516 bool *); 517static tree handle_tls_model_attribute (tree *, tree, tree, int, 518 bool *); 519static tree handle_no_instrument_function_attribute (tree *, tree, 520 tree, int, bool *); 521static tree handle_malloc_attribute (tree *, tree, tree, int, bool *); 522static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *); 523static tree handle_no_limit_stack_attribute (tree *, tree, tree, int, 524 bool *); 525static tree handle_pure_attribute (tree *, tree, tree, int, bool *); 526static tree handle_novops_attribute (tree *, tree, tree, int, bool *); 527static tree handle_deprecated_attribute (tree *, tree, tree, int, 528 bool *); 529static tree handle_vector_size_attribute (tree *, tree, tree, int, 530 bool *); 531static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *); 532static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *); 533static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *); 534static tree handle_warn_unused_result_attribute (tree *, tree, tree, int, 535 bool *); 536static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *); 537static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *); 538static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *); 539static tree handle_target_attribute (tree *, tree, tree, int, bool *); 540static tree handle_optimize_attribute (tree *, tree, tree, int, bool *); 541 542static void check_function_nonnull (tree, int, tree *); 543static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT); 544static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT); 545static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *); 546static int resort_field_decl_cmp (const void *, const void *); 547 548/* Reserved words. The third field is a mask: keywords are disabled 549 if they match the mask. 550 551 Masks for languages: 552 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC 553 C --std=c99: D_CXXONLY | D_OBJC 554 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set 555 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC 556 C++ --std=c0x: D_CONLY | D_OBJC 557 ObjC++ is like C++ except that D_OBJC is not set 558 559 If -fno-asm is used, D_ASM is added to the mask. If 560 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in 561 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords. 562 In C with -Wc++-compat, we warn if D_CXXWARN is set. */ 563 564const struct c_common_resword c_common_reswords[] = 565{ 566 { "_Bool", RID_BOOL, D_CONLY }, 567 { "_Complex", RID_COMPLEX, 0 }, 568 { "_Imaginary", RID_IMAGINARY, D_CONLY }, 569 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT }, 570 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT }, 571 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT }, 572 { "_Fract", RID_FRACT, D_CONLY | D_EXT }, 573 { "_Accum", RID_ACCUM, D_CONLY | D_EXT }, 574 { "_Sat", RID_SAT, D_CONLY | D_EXT }, 575 { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, 576 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, 577 { "__alignof", RID_ALIGNOF, 0 }, 578 { "__alignof__", RID_ALIGNOF, 0 }, 579 { "__asm", RID_ASM, 0 }, 580 { "__asm__", RID_ASM, 0 }, 581 { "__attribute", RID_ATTRIBUTE, 0 }, 582 { "__attribute__", RID_ATTRIBUTE, 0 }, 583 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY }, 584 { "__builtin_offsetof", RID_OFFSETOF, 0 }, 585 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY }, 586 { "__builtin_va_arg", RID_VA_ARG, 0 }, 587 { "__complex", RID_COMPLEX, 0 }, 588 { "__complex__", RID_COMPLEX, 0 }, 589 { "__const", RID_CONST, 0 }, 590 { "__const__", RID_CONST, 0 }, 591 { "__decltype", RID_DECLTYPE, D_CXXONLY }, 592 { "__extension__", RID_EXTENSION, 0 }, 593 { "__func__", RID_C99_FUNCTION_NAME, 0 }, 594 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY }, 595 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY }, 596 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY }, 597 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY }, 598 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY }, 599 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY }, 600 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY }, 601 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY }, 602 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY }, 603 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY }, 604 { "__is_class", RID_IS_CLASS, D_CXXONLY }, 605 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY }, 606 { "__is_empty", RID_IS_EMPTY, D_CXXONLY }, 607 { "__is_enum", RID_IS_ENUM, D_CXXONLY }, 608 { "__is_pod", RID_IS_POD, D_CXXONLY }, 609 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY }, 610 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY }, 611 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY }, 612 { "__is_union", RID_IS_UNION, D_CXXONLY }, 613 { "__imag", RID_IMAGPART, 0 }, 614 { "__imag__", RID_IMAGPART, 0 }, 615 { "__inline", RID_INLINE, 0 }, 616 { "__inline__", RID_INLINE, 0 }, 617 { "__label__", RID_LABEL, 0 }, 618 { "__null", RID_NULL, 0 }, 619 { "__real", RID_REALPART, 0 }, 620 { "__real__", RID_REALPART, 0 }, 621 { "__restrict", RID_RESTRICT, 0 }, 622 { "__restrict__", RID_RESTRICT, 0 }, 623 { "__signed", RID_SIGNED, 0 }, 624 { "__signed__", RID_SIGNED, 0 }, 625 { "__thread", RID_THREAD, 0 }, 626 { "__typeof", RID_TYPEOF, 0 }, 627 { "__typeof__", RID_TYPEOF, 0 }, 628 { "__volatile", RID_VOLATILE, 0 }, 629 { "__volatile__", RID_VOLATILE, 0 }, 630 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX0X | D_CXXWARN }, 631 { "asm", RID_ASM, D_ASM }, 632 { "auto", RID_AUTO, 0 }, 633 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN }, 634 { "break", RID_BREAK, 0 }, 635 { "case", RID_CASE, 0 }, 636 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN }, 637 { "char", RID_CHAR, 0 }, 638 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN }, 639 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN }, 640 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN }, 641 { "const", RID_CONST, 0 }, 642 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX0X | D_CXXWARN }, 643 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN }, 644 { "continue", RID_CONTINUE, 0 }, 645 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN }, 646 { "default", RID_DEFAULT, 0 }, 647 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN }, 648 { "do", RID_DO, 0 }, 649 { "double", RID_DOUBLE, 0 }, 650 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN }, 651 { "else", RID_ELSE, 0 }, 652 { "enum", RID_ENUM, 0 }, 653 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN }, 654 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN }, 655 { "extern", RID_EXTERN, 0 }, 656 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN }, 657 { "float", RID_FLOAT, 0 }, 658 { "for", RID_FOR, 0 }, 659 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN }, 660 { "goto", RID_GOTO, 0 }, 661 { "if", RID_IF, 0 }, 662 { "inline", RID_INLINE, D_EXT89 }, 663 { "int", RID_INT, 0 }, 664 { "long", RID_LONG, 0 }, 665 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN }, 666 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN }, 667 { "new", RID_NEW, D_CXXONLY | D_CXXWARN }, 668 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN }, 669 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN }, 670 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN }, 671 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN }, 672 { "register", RID_REGISTER, 0 }, 673 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN }, 674 { "restrict", RID_RESTRICT, D_CONLY | D_C99 }, 675 { "return", RID_RETURN, 0 }, 676 { "short", RID_SHORT, 0 }, 677 { "signed", RID_SIGNED, 0 }, 678 { "sizeof", RID_SIZEOF, 0 }, 679 { "static", RID_STATIC, 0 }, 680 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN }, 681 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN }, 682 { "struct", RID_STRUCT, 0 }, 683 { "switch", RID_SWITCH, 0 }, 684 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN }, 685 { "this", RID_THIS, D_CXXONLY | D_CXXWARN }, 686 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN }, 687 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN }, 688 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN }, 689 { "typedef", RID_TYPEDEF, 0 }, 690 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN }, 691 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN }, 692 { "typeof", RID_TYPEOF, D_ASM | D_EXT }, 693 { "union", RID_UNION, 0 }, 694 { "unsigned", RID_UNSIGNED, 0 }, 695 { "using", RID_USING, D_CXXONLY | D_CXXWARN }, 696 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN }, 697 { "void", RID_VOID, 0 }, 698 { "volatile", RID_VOLATILE, 0 }, 699 { "wchar_t", RID_WCHAR, D_CXXONLY }, 700 { "while", RID_WHILE, 0 }, 701 /* These Objective-C keywords are recognized only immediately after 702 an '@'. */ 703 { "compatibility_alias", RID_AT_ALIAS, D_OBJC }, 704 { "defs", RID_AT_DEFS, D_OBJC }, 705 { "encode", RID_AT_ENCODE, D_OBJC }, 706 { "end", RID_AT_END, D_OBJC }, 707 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC }, 708 { "interface", RID_AT_INTERFACE, D_OBJC }, 709 { "protocol", RID_AT_PROTOCOL, D_OBJC }, 710 { "selector", RID_AT_SELECTOR, D_OBJC }, 711 { "finally", RID_AT_FINALLY, D_OBJC }, 712 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC }, 713 /* These are recognized only in protocol-qualifier context 714 (see above) */ 715 { "bycopy", RID_BYCOPY, D_OBJC }, 716 { "byref", RID_BYREF, D_OBJC }, 717 { "in", RID_IN, D_OBJC }, 718 { "inout", RID_INOUT, D_OBJC }, 719 { "oneway", RID_ONEWAY, D_OBJC }, 720 { "out", RID_OUT, D_OBJC }, 721 722#ifdef TARGET_ADDR_SPACE_KEYWORDS 723 /* Any address space keywords recognized by the target. */ 724 TARGET_ADDR_SPACE_KEYWORDS, 725#endif 726}; 727 728const unsigned int num_c_common_reswords = 729 sizeof c_common_reswords / sizeof (struct c_common_resword); 730 731/* Table of machine-independent attributes common to all C-like languages. */ 732const struct attribute_spec c_common_attribute_table[] = 733{ 734 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ 735 { "packed", 0, 0, false, false, false, 736 handle_packed_attribute }, 737 { "nocommon", 0, 0, true, false, false, 738 handle_nocommon_attribute }, 739 { "common", 0, 0, true, false, false, 740 handle_common_attribute }, 741 /* FIXME: logically, noreturn attributes should be listed as 742 "false, true, true" and apply to function types. But implementing this 743 would require all the places in the compiler that use TREE_THIS_VOLATILE 744 on a decl to identify non-returning functions to be located and fixed 745 to check the function type instead. */ 746 { "noreturn", 0, 0, true, false, false, 747 handle_noreturn_attribute }, 748 { "volatile", 0, 0, true, false, false, 749 handle_noreturn_attribute }, 750 { "noinline", 0, 0, true, false, false, 751 handle_noinline_attribute }, 752 { "noclone", 0, 0, true, false, false, 753 handle_noclone_attribute }, 754 { "always_inline", 0, 0, true, false, false, 755 handle_always_inline_attribute }, 756 { "gnu_inline", 0, 0, true, false, false, 757 handle_gnu_inline_attribute }, 758 { "artificial", 0, 0, true, false, false, 759 handle_artificial_attribute }, 760 { "flatten", 0, 0, true, false, false, 761 handle_flatten_attribute }, 762 { "used", 0, 0, true, false, false, 763 handle_used_attribute }, 764 { "unused", 0, 0, false, false, false, 765 handle_unused_attribute }, 766 { "externally_visible", 0, 0, true, false, false, 767 handle_externally_visible_attribute }, 768 /* The same comments as for noreturn attributes apply to const ones. */ 769 { "const", 0, 0, true, false, false, 770 handle_const_attribute }, 771 { "transparent_union", 0, 0, false, false, false, 772 handle_transparent_union_attribute }, 773 { "constructor", 0, 1, true, false, false, 774 handle_constructor_attribute }, 775 { "destructor", 0, 1, true, false, false, 776 handle_destructor_attribute }, 777 { "mode", 1, 1, false, true, false, 778 handle_mode_attribute }, 779 { "section", 1, 1, true, false, false, 780 handle_section_attribute }, 781 { "aligned", 0, 1, false, false, false, 782 handle_aligned_attribute }, 783 { "weak", 0, 0, true, false, false, 784 handle_weak_attribute }, 785 { "alias", 1, 1, true, false, false, 786 handle_alias_attribute }, 787 { "weakref", 0, 1, true, false, false, 788 handle_weakref_attribute }, 789 { "no_instrument_function", 0, 0, true, false, false, 790 handle_no_instrument_function_attribute }, 791 { "malloc", 0, 0, true, false, false, 792 handle_malloc_attribute }, 793 { "returns_twice", 0, 0, true, false, false, 794 handle_returns_twice_attribute }, 795 { "no_stack_limit", 0, 0, true, false, false, 796 handle_no_limit_stack_attribute }, 797 { "pure", 0, 0, true, false, false, 798 handle_pure_attribute }, 799 /* For internal use (marking of builtins) only. The name contains space 800 to prevent its usage in source code. */ 801 { "no vops", 0, 0, true, false, false, 802 handle_novops_attribute }, 803 { "deprecated", 0, 1, false, false, false, 804 handle_deprecated_attribute }, 805 { "vector_size", 1, 1, false, true, false, 806 handle_vector_size_attribute }, 807 { "visibility", 1, 1, false, false, false, 808 handle_visibility_attribute }, 809 { "tls_model", 1, 1, true, false, false, 810 handle_tls_model_attribute }, 811 { "nonnull", 0, -1, false, true, true, 812 handle_nonnull_attribute }, 813 { "nothrow", 0, 0, true, false, false, 814 handle_nothrow_attribute }, 815 { "may_alias", 0, 0, false, true, false, NULL }, 816 { "cleanup", 1, 1, true, false, false, 817 handle_cleanup_attribute }, 818 { "warn_unused_result", 0, 0, false, true, true, 819 handle_warn_unused_result_attribute }, 820 { "sentinel", 0, 1, false, true, true, 821 handle_sentinel_attribute }, 822 /* For internal use (marking of builtins) only. The name contains space 823 to prevent its usage in source code. */ 824 { "type generic", 0, 0, false, true, true, 825 handle_type_generic_attribute }, 826 { "alloc_size", 1, 2, false, true, true, 827 handle_alloc_size_attribute }, 828 { "cold", 0, 0, true, false, false, 829 handle_cold_attribute }, 830 { "hot", 0, 0, true, false, false, 831 handle_hot_attribute }, 832 { "warning", 1, 1, true, false, false, 833 handle_error_attribute }, 834 { "error", 1, 1, true, false, false, 835 handle_error_attribute }, 836 { "target", 1, -1, true, false, false, 837 handle_target_attribute }, 838 { "optimize", 1, -1, true, false, false, 839 handle_optimize_attribute }, 840 { NULL, 0, 0, false, false, false, NULL } 841}; 842 843/* Give the specifications for the format attributes, used by C and all 844 descendants. */ 845 846const struct attribute_spec c_common_format_attribute_table[] = 847{ 848 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */ 849 { "format", 3, 3, false, true, true, 850 handle_format_attribute }, 851 { "format_arg", 1, 1, false, true, true, 852 handle_format_arg_attribute }, 853 { NULL, 0, 0, false, false, false, NULL } 854}; 855 856/* Return identifier for address space AS. */ 857const char * 858c_addr_space_name (addr_space_t as) 859{ 860 unsigned int i; 861 862 for (i = 0; i < num_c_common_reswords; i++) 863 if (c_common_reswords[i].rid == RID_FIRST_ADDR_SPACE + as) 864 return c_common_reswords[i].word; 865 866 gcc_unreachable (); 867} 868 869/* Push current bindings for the function name VAR_DECLS. */ 870 871void 872start_fname_decls (void) 873{ 874 unsigned ix; 875 tree saved = NULL_TREE; 876 877 for (ix = 0; fname_vars[ix].decl; ix++) 878 { 879 tree decl = *fname_vars[ix].decl; 880 881 if (decl) 882 { 883 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved); 884 *fname_vars[ix].decl = NULL_TREE; 885 } 886 } 887 if (saved || saved_function_name_decls) 888 /* Normally they'll have been NULL, so only push if we've got a 889 stack, or they are non-NULL. */ 890 saved_function_name_decls = tree_cons (saved, NULL_TREE, 891 saved_function_name_decls); 892} 893 894/* Finish up the current bindings, adding them into the current function's 895 statement tree. This must be done _before_ finish_stmt_tree is called. 896 If there is no current function, we must be at file scope and no statements 897 are involved. Pop the previous bindings. */ 898 899void 900finish_fname_decls (void) 901{ 902 unsigned ix; 903 tree stmts = NULL_TREE; 904 tree stack = saved_function_name_decls; 905 906 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack)) 907 append_to_statement_list (TREE_VALUE (stack), &stmts); 908 909 if (stmts) 910 { 911 tree *bodyp = &DECL_SAVED_TREE (current_function_decl); 912 913 if (TREE_CODE (*bodyp) == BIND_EXPR) 914 bodyp = &BIND_EXPR_BODY (*bodyp); 915 916 append_to_statement_list_force (*bodyp, &stmts); 917 *bodyp = stmts; 918 } 919 920 for (ix = 0; fname_vars[ix].decl; ix++) 921 *fname_vars[ix].decl = NULL_TREE; 922 923 if (stack) 924 { 925 /* We had saved values, restore them. */ 926 tree saved; 927 928 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved)) 929 { 930 tree decl = TREE_PURPOSE (saved); 931 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved)); 932 933 *fname_vars[ix].decl = decl; 934 } 935 stack = TREE_CHAIN (stack); 936 } 937 saved_function_name_decls = stack; 938} 939 940/* Return the text name of the current function, suitably prettified 941 by PRETTY_P. Return string must be freed by caller. */ 942 943const char * 944fname_as_string (int pretty_p) 945{ 946 const char *name = "top level"; 947 char *namep; 948 int vrb = 2, len; 949 cpp_string cstr = { 0, 0 }, strname; 950 951 if (!pretty_p) 952 { 953 name = ""; 954 vrb = 0; 955 } 956 957 if (current_function_decl) 958 name = lang_hooks.decl_printable_name (current_function_decl, vrb); 959 960 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */ 961 962 namep = XNEWVEC (char, len); 963 snprintf (namep, len, "\"%s\"", name); 964 strname.text = (unsigned char *) namep; 965 strname.len = len - 1; 966 967 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING)) 968 { 969 XDELETEVEC (namep); 970 return (const char *) cstr.text; 971 } 972 973 return namep; 974} 975 976/* Return the VAR_DECL for a const char array naming the current 977 function. If the VAR_DECL has not yet been created, create it 978 now. RID indicates how it should be formatted and IDENTIFIER_NODE 979 ID is its name (unfortunately C and C++ hold the RID values of 980 keywords in different places, so we can't derive RID from ID in 981 this language independent code. LOC is the location of the 982 function. */ 983 984tree 985fname_decl (location_t loc, unsigned int rid, tree id) 986{ 987 unsigned ix; 988 tree decl = NULL_TREE; 989 990 for (ix = 0; fname_vars[ix].decl; ix++) 991 if (fname_vars[ix].rid == rid) 992 break; 993 994 decl = *fname_vars[ix].decl; 995 if (!decl) 996 { 997 /* If a tree is built here, it would normally have the lineno of 998 the current statement. Later this tree will be moved to the 999 beginning of the function and this line number will be wrong. 1000 To avoid this problem set the lineno to 0 here; that prevents 1001 it from appearing in the RTL. */ 1002 tree stmts; 1003 location_t saved_location = input_location; 1004 input_location = UNKNOWN_LOCATION; 1005 1006 stmts = push_stmt_list (); 1007 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty); 1008 stmts = pop_stmt_list (stmts); 1009 if (!IS_EMPTY_STMT (stmts)) 1010 saved_function_name_decls 1011 = tree_cons (decl, stmts, saved_function_name_decls); 1012 *fname_vars[ix].decl = decl; 1013 input_location = saved_location; 1014 } 1015 if (!ix && !current_function_decl) 1016 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl); 1017 1018 return decl; 1019} 1020 1021/* Given a STRING_CST, give it a suitable array-of-chars data type. */ 1022 1023tree 1024fix_string_type (tree value) 1025{ 1026 int length = TREE_STRING_LENGTH (value); 1027 int nchars; 1028 tree e_type, i_type, a_type; 1029 1030 /* Compute the number of elements, for the array type. */ 1031 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value)) 1032 { 1033 nchars = length; 1034 e_type = char_type_node; 1035 } 1036 else if (TREE_TYPE (value) == char16_array_type_node) 1037 { 1038 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT); 1039 e_type = char16_type_node; 1040 } 1041 else if (TREE_TYPE (value) == char32_array_type_node) 1042 { 1043 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT); 1044 e_type = char32_type_node; 1045 } 1046 else 1047 { 1048 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT); 1049 e_type = wchar_type_node; 1050 } 1051 1052 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous 1053 limit in C++98 Annex B is very large (65536) and is not normative, 1054 so we do not diagnose it (warn_overlength_strings is forced off 1055 in c_common_post_options). */ 1056 if (warn_overlength_strings) 1057 { 1058 const int nchars_max = flag_isoc99 ? 4095 : 509; 1059 const int relevant_std = flag_isoc99 ? 99 : 90; 1060 if (nchars - 1 > nchars_max) 1061 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not 1062 separate the %d from the 'C'. 'ISO' should not be 1063 translated, but it may be moved after 'C%d' in languages 1064 where modifiers follow nouns. */ 1065 pedwarn (input_location, OPT_Woverlength_strings, 1066 "string length %qd is greater than the length %qd " 1067 "ISO C%d compilers are required to support", 1068 nchars - 1, nchars_max, relevant_std); 1069 } 1070 1071 /* Create the array type for the string constant. The ISO C++ 1072 standard says that a string literal has type `const char[N]' or 1073 `const wchar_t[N]'. We use the same logic when invoked as a C 1074 front-end with -Wwrite-strings. 1075 ??? We should change the type of an expression depending on the 1076 state of a warning flag. We should just be warning -- see how 1077 this is handled in the C++ front-end for the deprecated implicit 1078 conversion from string literals to `char*' or `wchar_t*'. 1079 1080 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified 1081 array type being the unqualified version of that type. 1082 Therefore, if we are constructing an array of const char, we must 1083 construct the matching unqualified array type first. The C front 1084 end does not require this, but it does no harm, so we do it 1085 unconditionally. */ 1086 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1)); 1087 a_type = build_array_type (e_type, i_type); 1088 if (c_dialect_cxx() || warn_write_strings) 1089 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST); 1090 1091 TREE_TYPE (value) = a_type; 1092 TREE_CONSTANT (value) = 1; 1093 TREE_READONLY (value) = 1; 1094 TREE_STATIC (value) = 1; 1095 return value; 1096} 1097 1098/* Fully fold EXPR, an expression that was not folded (beyond integer 1099 constant expressions and null pointer constants) when being built 1100 up. If IN_INIT, this is in a static initializer and certain 1101 changes are made to the folding done. Clear *MAYBE_CONST if 1102 MAYBE_CONST is not NULL and EXPR is definitely not a constant 1103 expression because it contains an evaluated operator (in C99) or an 1104 operator outside of sizeof returning an integer constant (in C90) 1105 not permitted in constant expressions, or because it contains an 1106 evaluated arithmetic overflow. (*MAYBE_CONST should typically be 1107 set to true by callers before calling this function.) Return the 1108 folded expression. Function arguments have already been folded 1109 before calling this function, as have the contents of SAVE_EXPR, 1110 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and 1111 C_MAYBE_CONST_EXPR. */ 1112 1113tree 1114c_fully_fold (tree expr, bool in_init, bool *maybe_const) 1115{ 1116 tree ret; 1117 tree eptype = NULL_TREE; 1118 bool dummy = true; 1119 bool maybe_const_itself = true; 1120 location_t loc = EXPR_LOCATION (expr); 1121 1122 /* This function is not relevant to C++ because C++ folds while 1123 parsing, and may need changes to be correct for C++ when C++ 1124 stops folding while parsing. */ 1125 if (c_dialect_cxx ()) 1126 gcc_unreachable (); 1127 1128 if (!maybe_const) 1129 maybe_const = &dummy; 1130 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR) 1131 { 1132 eptype = TREE_TYPE (expr); 1133 expr = TREE_OPERAND (expr, 0); 1134 } 1135 ret = c_fully_fold_internal (expr, in_init, maybe_const, 1136 &maybe_const_itself); 1137 if (eptype) 1138 ret = fold_convert_loc (loc, eptype, ret); 1139 *maybe_const &= maybe_const_itself; 1140 return ret; 1141} 1142 1143/* Internal helper for c_fully_fold. EXPR and IN_INIT are as for 1144 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands 1145 not permitted, while *MAYBE_CONST_ITSELF is cleared because of 1146 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from 1147 both evaluated and unevaluated subexpressions while 1148 *MAYBE_CONST_ITSELF is carried from only evaluated 1149 subexpressions). */ 1150 1151static tree 1152c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands, 1153 bool *maybe_const_itself) 1154{ 1155 tree ret = expr; 1156 enum tree_code code = TREE_CODE (expr); 1157 enum tree_code_class kind = TREE_CODE_CLASS (code); 1158 location_t loc = EXPR_LOCATION (expr); 1159 tree op0, op1, op2, op3; 1160 tree orig_op0, orig_op1, orig_op2; 1161 bool op0_const = true, op1_const = true, op2_const = true; 1162 bool op0_const_self = true, op1_const_self = true, op2_const_self = true; 1163 bool nowarning = TREE_NO_WARNING (expr); 1164 int unused_p; 1165 1166 /* This function is not relevant to C++ because C++ folds while 1167 parsing, and may need changes to be correct for C++ when C++ 1168 stops folding while parsing. */ 1169 if (c_dialect_cxx ()) 1170 gcc_unreachable (); 1171 1172 /* Constants, declarations, statements, errors, SAVE_EXPRs and 1173 anything else not counted as an expression cannot usefully be 1174 folded further at this point. */ 1175 if (!IS_EXPR_CODE_CLASS (kind) 1176 || kind == tcc_statement 1177 || code == SAVE_EXPR) 1178 return expr; 1179 1180 /* Operands of variable-length expressions (function calls) have 1181 already been folded, as have __builtin_* function calls, and such 1182 expressions cannot occur in constant expressions. */ 1183 if (kind == tcc_vl_exp) 1184 { 1185 *maybe_const_operands = false; 1186 ret = fold (expr); 1187 goto out; 1188 } 1189 1190 if (code == C_MAYBE_CONST_EXPR) 1191 { 1192 tree pre = C_MAYBE_CONST_EXPR_PRE (expr); 1193 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr); 1194 if (C_MAYBE_CONST_EXPR_NON_CONST (expr)) 1195 *maybe_const_operands = false; 1196 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr)) 1197 *maybe_const_itself = false; 1198 if (pre && !in_init) 1199 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner); 1200 else 1201 ret = inner; 1202 goto out; 1203 } 1204 1205 /* Assignment, increment, decrement, function call and comma 1206 operators, and statement expressions, cannot occur in constant 1207 expressions if evaluated / outside of sizeof. (Function calls 1208 were handled above, though VA_ARG_EXPR is treated like a function 1209 call here, and statement expressions are handled through 1210 C_MAYBE_CONST_EXPR to avoid folding inside them.) */ 1211 switch (code) 1212 { 1213 case MODIFY_EXPR: 1214 case PREDECREMENT_EXPR: 1215 case PREINCREMENT_EXPR: 1216 case POSTDECREMENT_EXPR: 1217 case POSTINCREMENT_EXPR: 1218 case COMPOUND_EXPR: 1219 *maybe_const_operands = false; 1220 break; 1221 1222 case VA_ARG_EXPR: 1223 case TARGET_EXPR: 1224 case BIND_EXPR: 1225 case OBJ_TYPE_REF: 1226 *maybe_const_operands = false; 1227 ret = fold (expr); 1228 goto out; 1229 1230 default: 1231 break; 1232 } 1233 1234 /* Fold individual tree codes as appropriate. */ 1235 switch (code) 1236 { 1237 case COMPOUND_LITERAL_EXPR: 1238 /* Any non-constancy will have been marked in a containing 1239 C_MAYBE_CONST_EXPR; there is no more folding to do here. */ 1240 goto out; 1241 1242 case COMPONENT_REF: 1243 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1244 op1 = TREE_OPERAND (expr, 1); 1245 op2 = TREE_OPERAND (expr, 2); 1246 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands, 1247 maybe_const_itself); 1248 STRIP_TYPE_NOPS (op0); 1249 if (op0 != orig_op0) 1250 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2); 1251 if (ret != expr) 1252 { 1253 TREE_READONLY (ret) = TREE_READONLY (expr); 1254 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr); 1255 } 1256 goto out; 1257 1258 case ARRAY_REF: 1259 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1260 orig_op1 = op1 = TREE_OPERAND (expr, 1); 1261 op2 = TREE_OPERAND (expr, 2); 1262 op3 = TREE_OPERAND (expr, 3); 1263 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands, 1264 maybe_const_itself); 1265 STRIP_TYPE_NOPS (op0); 1266 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands, 1267 maybe_const_itself); 1268 STRIP_TYPE_NOPS (op1); 1269 op1 = decl_constant_value_for_optimization (op1); 1270 if (op0 != orig_op0 || op1 != orig_op1) 1271 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3); 1272 if (ret != expr) 1273 { 1274 TREE_READONLY (ret) = TREE_READONLY (expr); 1275 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr); 1276 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr); 1277 } 1278 ret = fold (ret); 1279 goto out; 1280 1281 case COMPOUND_EXPR: 1282 case MODIFY_EXPR: 1283 case PREDECREMENT_EXPR: 1284 case PREINCREMENT_EXPR: 1285 case POSTDECREMENT_EXPR: 1286 case POSTINCREMENT_EXPR: 1287 case PLUS_EXPR: 1288 case MINUS_EXPR: 1289 case MULT_EXPR: 1290 case POINTER_PLUS_EXPR: 1291 case TRUNC_DIV_EXPR: 1292 case CEIL_DIV_EXPR: 1293 case FLOOR_DIV_EXPR: 1294 case TRUNC_MOD_EXPR: 1295 case RDIV_EXPR: 1296 case EXACT_DIV_EXPR: 1297 case LSHIFT_EXPR: 1298 case RSHIFT_EXPR: 1299 case BIT_IOR_EXPR: 1300 case BIT_XOR_EXPR: 1301 case BIT_AND_EXPR: 1302 case LT_EXPR: 1303 case LE_EXPR: 1304 case GT_EXPR: 1305 case GE_EXPR: 1306 case EQ_EXPR: 1307 case NE_EXPR: 1308 case COMPLEX_EXPR: 1309 case TRUTH_AND_EXPR: 1310 case TRUTH_OR_EXPR: 1311 case TRUTH_XOR_EXPR: 1312 case UNORDERED_EXPR: 1313 case ORDERED_EXPR: 1314 case UNLT_EXPR: 1315 case UNLE_EXPR: 1316 case UNGT_EXPR: 1317 case UNGE_EXPR: 1318 case UNEQ_EXPR: 1319 /* Binary operations evaluating both arguments (increment and 1320 decrement are binary internally in GCC). */ 1321 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1322 orig_op1 = op1 = TREE_OPERAND (expr, 1); 1323 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands, 1324 maybe_const_itself); 1325 STRIP_TYPE_NOPS (op0); 1326 if (code != MODIFY_EXPR 1327 && code != PREDECREMENT_EXPR 1328 && code != PREINCREMENT_EXPR 1329 && code != POSTDECREMENT_EXPR 1330 && code != POSTINCREMENT_EXPR) 1331 op0 = decl_constant_value_for_optimization (op0); 1332 /* The RHS of a MODIFY_EXPR was fully folded when building that 1333 expression for the sake of conversion warnings. */ 1334 if (code != MODIFY_EXPR) 1335 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands, 1336 maybe_const_itself); 1337 STRIP_TYPE_NOPS (op1); 1338 op1 = decl_constant_value_for_optimization (op1); 1339 if (op0 != orig_op0 || op1 != orig_op1 || in_init) 1340 ret = in_init 1341 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1) 1342 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1); 1343 else 1344 ret = fold (expr); 1345 if (TREE_OVERFLOW_P (ret) 1346 && !TREE_OVERFLOW_P (op0) 1347 && !TREE_OVERFLOW_P (op1)) 1348 overflow_warning (EXPR_LOCATION (expr), ret); 1349 goto out; 1350 1351 case INDIRECT_REF: 1352 case FIX_TRUNC_EXPR: 1353 case FLOAT_EXPR: 1354 CASE_CONVERT: 1355 case VIEW_CONVERT_EXPR: 1356 case NON_LVALUE_EXPR: 1357 case NEGATE_EXPR: 1358 case BIT_NOT_EXPR: 1359 case TRUTH_NOT_EXPR: 1360 case ADDR_EXPR: 1361 case CONJ_EXPR: 1362 case REALPART_EXPR: 1363 case IMAGPART_EXPR: 1364 /* Unary operations. */ 1365 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1366 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands, 1367 maybe_const_itself); 1368 STRIP_TYPE_NOPS (op0); 1369 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR) 1370 op0 = decl_constant_value_for_optimization (op0); 1371 if (op0 != orig_op0 || in_init) 1372 ret = in_init 1373 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0) 1374 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0); 1375 else 1376 ret = fold (expr); 1377 if (code == INDIRECT_REF 1378 && ret != expr 1379 && TREE_CODE (ret) == INDIRECT_REF) 1380 { 1381 TREE_READONLY (ret) = TREE_READONLY (expr); 1382 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr); 1383 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr); 1384 } 1385 switch (code) 1386 { 1387 case FIX_TRUNC_EXPR: 1388 case FLOAT_EXPR: 1389 CASE_CONVERT: 1390 /* Don't warn about explicit conversions. We will already 1391 have warned about suspect implicit conversions. */ 1392 break; 1393 1394 default: 1395 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0)) 1396 overflow_warning (EXPR_LOCATION (expr), ret); 1397 break; 1398 } 1399 goto out; 1400 1401 case TRUTH_ANDIF_EXPR: 1402 case TRUTH_ORIF_EXPR: 1403 /* Binary operations not necessarily evaluating both 1404 arguments. */ 1405 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1406 orig_op1 = op1 = TREE_OPERAND (expr, 1); 1407 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self); 1408 STRIP_TYPE_NOPS (op0); 1409 1410 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR 1411 ? truthvalue_false_node 1412 : truthvalue_true_node)); 1413 c_inhibit_evaluation_warnings += unused_p; 1414 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self); 1415 STRIP_TYPE_NOPS (op1); 1416 c_inhibit_evaluation_warnings -= unused_p; 1417 1418 if (op0 != orig_op0 || op1 != orig_op1 || in_init) 1419 ret = in_init 1420 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1) 1421 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1); 1422 else 1423 ret = fold (expr); 1424 *maybe_const_operands &= op0_const; 1425 *maybe_const_itself &= op0_const_self; 1426 if (!(flag_isoc99 1427 && op0_const 1428 && op0_const_self 1429 && (code == TRUTH_ANDIF_EXPR 1430 ? op0 == truthvalue_false_node 1431 : op0 == truthvalue_true_node))) 1432 *maybe_const_operands &= op1_const; 1433 if (!(op0_const 1434 && op0_const_self 1435 && (code == TRUTH_ANDIF_EXPR 1436 ? op0 == truthvalue_false_node 1437 : op0 == truthvalue_true_node))) 1438 *maybe_const_itself &= op1_const_self; 1439 goto out; 1440 1441 case COND_EXPR: 1442 orig_op0 = op0 = TREE_OPERAND (expr, 0); 1443 orig_op1 = op1 = TREE_OPERAND (expr, 1); 1444 orig_op2 = op2 = TREE_OPERAND (expr, 2); 1445 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self); 1446 1447 STRIP_TYPE_NOPS (op0); 1448 c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node); 1449 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self); 1450 STRIP_TYPE_NOPS (op1); 1451 c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node); 1452 1453 c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node); 1454 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self); 1455 STRIP_TYPE_NOPS (op2); 1456 c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node); 1457 1458 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2) 1459 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2); 1460 else 1461 ret = fold (expr); 1462 *maybe_const_operands &= op0_const; 1463 *maybe_const_itself &= op0_const_self; 1464 if (!(flag_isoc99 1465 && op0_const 1466 && op0_const_self 1467 && op0 == truthvalue_false_node)) 1468 *maybe_const_operands &= op1_const; 1469 if (!(op0_const 1470 && op0_const_self 1471 && op0 == truthvalue_false_node)) 1472 *maybe_const_itself &= op1_const_self; 1473 if (!(flag_isoc99 1474 && op0_const 1475 && op0_const_self 1476 && op0 == truthvalue_true_node)) 1477 *maybe_const_operands &= op2_const; 1478 if (!(op0_const 1479 && op0_const_self 1480 && op0 == truthvalue_true_node)) 1481 *maybe_const_itself &= op2_const_self; 1482 goto out; 1483 1484 case EXCESS_PRECISION_EXPR: 1485 /* Each case where an operand with excess precision may be 1486 encountered must remove the EXCESS_PRECISION_EXPR around 1487 inner operands and possibly put one around the whole 1488 expression or possibly convert to the semantic type (which 1489 c_fully_fold does); we cannot tell at this stage which is 1490 appropriate in any particular case. */ 1491 gcc_unreachable (); 1492 1493 default: 1494 /* Various codes may appear through folding built-in functions 1495 and their arguments. */ 1496 goto out; 1497 } 1498 1499 out: 1500 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks 1501 have been done by this point, so remove them again. */ 1502 nowarning |= TREE_NO_WARNING (ret); 1503 STRIP_TYPE_NOPS (ret); 1504 if (nowarning && !TREE_NO_WARNING (ret)) 1505 { 1506 if (!CAN_HAVE_LOCATION_P (ret)) 1507 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret); 1508 TREE_NO_WARNING (ret) = 1; 1509 } 1510 if (ret != expr) 1511 protected_set_expr_location (ret, loc); 1512 return ret; 1513} 1514 1515/* If not optimizing, EXP is not a VAR_DECL, or EXP has array type, 1516 return EXP. Otherwise, return either EXP or its known constant 1517 value (if it has one), but return EXP if EXP has mode BLKmode. ??? 1518 Is the BLKmode test appropriate? */ 1519 1520tree 1521decl_constant_value_for_optimization (tree exp) 1522{ 1523 tree ret; 1524 1525 /* This function is only used by C, for c_fully_fold and other 1526 optimization, and may not be correct for C++. */ 1527 if (c_dialect_cxx ()) 1528 gcc_unreachable (); 1529 1530 if (!optimize 1531 || TREE_CODE (exp) != VAR_DECL 1532 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE 1533 || DECL_MODE (exp) == BLKmode) 1534 return exp; 1535 1536 ret = decl_constant_value (exp); 1537 /* Avoid unwanted tree sharing between the initializer and current 1538 function's body where the tree can be modified e.g. by the 1539 gimplifier. */ 1540 if (ret != exp && TREE_STATIC (exp)) 1541 ret = unshare_expr (ret); 1542 return ret; 1543} 1544 1545/* Print a warning if a constant expression had overflow in folding. 1546 Invoke this function on every expression that the language 1547 requires to be a constant expression. 1548 Note the ANSI C standard says it is erroneous for a 1549 constant expression to overflow. */ 1550 1551void 1552constant_expression_warning (tree value) 1553{ 1554 if (warn_overflow && pedantic 1555 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST 1556 || TREE_CODE (value) == FIXED_CST 1557 || TREE_CODE (value) == VECTOR_CST 1558 || TREE_CODE (value) == COMPLEX_CST) 1559 && TREE_OVERFLOW (value)) 1560 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression"); 1561} 1562 1563/* The same as above but print an unconditional error. */ 1564void 1565constant_expression_error (tree value) 1566{ 1567 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST 1568 || TREE_CODE (value) == FIXED_CST 1569 || TREE_CODE (value) == VECTOR_CST 1570 || TREE_CODE (value) == COMPLEX_CST) 1571 && TREE_OVERFLOW (value)) 1572 error ("overflow in constant expression"); 1573} 1574 1575/* Print a warning if an expression had overflow in folding and its 1576 operands hadn't. 1577 1578 Invoke this function on every expression that 1579 (1) appears in the source code, and 1580 (2) is a constant expression that overflowed, and 1581 (3) is not already checked by convert_and_check; 1582 however, do not invoke this function on operands of explicit casts 1583 or when the expression is the result of an operator and any operand 1584 already overflowed. */ 1585 1586void 1587overflow_warning (location_t loc, tree value) 1588{ 1589 if (c_inhibit_evaluation_warnings != 0) 1590 return; 1591 1592 switch (TREE_CODE (value)) 1593 { 1594 case INTEGER_CST: 1595 warning_at (loc, OPT_Woverflow, "integer overflow in expression"); 1596 break; 1597 1598 case REAL_CST: 1599 warning_at (loc, OPT_Woverflow, 1600 "floating point overflow in expression"); 1601 break; 1602 1603 case FIXED_CST: 1604 warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression"); 1605 break; 1606 1607 case VECTOR_CST: 1608 warning_at (loc, OPT_Woverflow, "vector overflow in expression"); 1609 break; 1610 1611 case COMPLEX_CST: 1612 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST) 1613 warning_at (loc, OPT_Woverflow, 1614 "complex integer overflow in expression"); 1615 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST) 1616 warning_at (loc, OPT_Woverflow, 1617 "complex floating point overflow in expression"); 1618 break; 1619 1620 default: 1621 break; 1622 } 1623} 1624 1625/* Warn about uses of logical || / && operator in a context where it 1626 is likely that the bitwise equivalent was intended by the 1627 programmer. We have seen an expression in which CODE is a binary 1628 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding 1629 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */ 1630void 1631warn_logical_operator (location_t location, enum tree_code code, tree type, 1632 enum tree_code code_left, tree op_left, 1633 enum tree_code ARG_UNUSED (code_right), tree op_right) 1634{ 1635 int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR); 1636 int in0_p, in1_p, in_p; 1637 tree low0, low1, low, high0, high1, high, lhs, rhs, tem; 1638 bool strict_overflow_p = false; 1639 1640 if (code != TRUTH_ANDIF_EXPR 1641 && code != TRUTH_AND_EXPR 1642 && code != TRUTH_ORIF_EXPR 1643 && code != TRUTH_OR_EXPR) 1644 return; 1645 1646 /* Warn if &&/|| are being used in a context where it is 1647 likely that the bitwise equivalent was intended by the 1648 programmer. That is, an expression such as op && MASK 1649 where op should not be any boolean expression, nor a 1650 constant, and mask seems to be a non-boolean integer constant. */ 1651 if (!truth_value_p (code_left) 1652 && INTEGRAL_TYPE_P (TREE_TYPE (op_left)) 1653 && !CONSTANT_CLASS_P (op_left) 1654 && !TREE_NO_WARNING (op_left) 1655 && TREE_CODE (op_right) == INTEGER_CST 1656 && !integer_zerop (op_right) 1657 && !integer_onep (op_right)) 1658 { 1659 if (or_op) 1660 warning_at (location, OPT_Wlogical_op, "logical %<or%>" 1661 " applied to non-boolean constant"); 1662 else 1663 warning_at (location, OPT_Wlogical_op, "logical %<and%>" 1664 " applied to non-boolean constant"); 1665 TREE_NO_WARNING (op_left) = true; 1666 return; 1667 } 1668 1669 /* We do not warn for constants because they are typical of macro 1670 expansions that test for features. */ 1671 if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right)) 1672 return; 1673 1674 /* This warning only makes sense with logical operands. */ 1675 if (!(truth_value_p (TREE_CODE (op_left)) 1676 || INTEGRAL_TYPE_P (TREE_TYPE (op_left))) 1677 || !(truth_value_p (TREE_CODE (op_right)) 1678 || INTEGRAL_TYPE_P (TREE_TYPE (op_right)))) 1679 return; 1680 1681 lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p); 1682 rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p); 1683 1684 if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR) 1685 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs); 1686 1687 if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR) 1688 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs); 1689 1690 /* If this is an OR operation, invert both sides; we will invert 1691 again at the end. */ 1692 if (or_op) 1693 in0_p = !in0_p, in1_p = !in1_p; 1694 1695 /* If both expressions are the same, if we can merge the ranges, and we 1696 can build the range test, return it or it inverted. */ 1697 if (lhs && rhs && operand_equal_p (lhs, rhs, 0) 1698 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0, 1699 in1_p, low1, high1) 1700 && 0 != (tem = build_range_check (UNKNOWN_LOCATION, 1701 type, lhs, in_p, low, high))) 1702 { 1703 if (TREE_CODE (tem) != INTEGER_CST) 1704 return; 1705 1706 if (or_op) 1707 warning_at (location, OPT_Wlogical_op, 1708 "logical %<or%> " 1709 "of collectively exhaustive tests is always true"); 1710 else 1711 warning_at (location, OPT_Wlogical_op, 1712 "logical %<and%> " 1713 "of mutually exclusive tests is always false"); 1714 } 1715} 1716 1717 1718/* Print a warning about casts that might indicate violation 1719 of strict aliasing rules if -Wstrict-aliasing is used and 1720 strict aliasing mode is in effect. OTYPE is the original 1721 TREE_TYPE of EXPR, and TYPE the type we're casting to. */ 1722 1723bool 1724strict_aliasing_warning (tree otype, tree type, tree expr) 1725{ 1726 /* Strip pointer conversion chains and get to the correct original type. */ 1727 STRIP_NOPS (expr); 1728 otype = TREE_TYPE (expr); 1729 1730 if (!(flag_strict_aliasing 1731 && POINTER_TYPE_P (type) 1732 && POINTER_TYPE_P (otype) 1733 && !VOID_TYPE_P (TREE_TYPE (type))) 1734 /* If the type we are casting to is a ref-all pointer 1735 dereferencing it is always valid. */ 1736 || TYPE_REF_CAN_ALIAS_ALL (type)) 1737 return false; 1738 1739 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR 1740 && (DECL_P (TREE_OPERAND (expr, 0)) 1741 || handled_component_p (TREE_OPERAND (expr, 0)))) 1742 { 1743 /* Casting the address of an object to non void pointer. Warn 1744 if the cast breaks type based aliasing. */ 1745 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2) 1746 { 1747 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type " 1748 "might break strict-aliasing rules"); 1749 return true; 1750 } 1751 else 1752 { 1753 /* warn_strict_aliasing >= 3. This includes the default (3). 1754 Only warn if the cast is dereferenced immediately. */ 1755 alias_set_type set1 = 1756 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))); 1757 alias_set_type set2 = get_alias_set (TREE_TYPE (type)); 1758 1759 if (set1 != set2 && set2 != 0 1760 && (set1 == 0 || !alias_sets_conflict_p (set1, set2))) 1761 { 1762 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1763 "pointer will break strict-aliasing rules"); 1764 return true; 1765 } 1766 else if (warn_strict_aliasing == 2 1767 && !alias_sets_must_conflict_p (set1, set2)) 1768 { 1769 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1770 "pointer might break strict-aliasing rules"); 1771 return true; 1772 } 1773 } 1774 } 1775 else 1776 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype))) 1777 { 1778 /* At this level, warn for any conversions, even if an address is 1779 not taken in the same statement. This will likely produce many 1780 false positives, but could be useful to pinpoint problems that 1781 are not revealed at higher levels. */ 1782 alias_set_type set1 = get_alias_set (TREE_TYPE (otype)); 1783 alias_set_type set2 = get_alias_set (TREE_TYPE (type)); 1784 if (!COMPLETE_TYPE_P (type) 1785 || !alias_sets_must_conflict_p (set1, set2)) 1786 { 1787 warning (OPT_Wstrict_aliasing, "dereferencing type-punned " 1788 "pointer might break strict-aliasing rules"); 1789 return true; 1790 } 1791 } 1792 1793 return false; 1794} 1795 1796/* Warn for unlikely, improbable, or stupid DECL declarations 1797 of `main'. */ 1798 1799void 1800check_main_parameter_types (tree decl) 1801{ 1802 tree args; 1803 int argct = 0; 1804 1805 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args; 1806 args = TREE_CHAIN (args)) 1807 { 1808 tree type = args ? TREE_VALUE (args) : 0; 1809 1810 if (type == void_type_node || type == error_mark_node ) 1811 break; 1812 1813 ++argct; 1814 switch (argct) 1815 { 1816 case 1: 1817 if (TYPE_MAIN_VARIANT (type) != integer_type_node) 1818 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>", 1819 decl); 1820 break; 1821 1822 case 2: 1823 if (TREE_CODE (type) != POINTER_TYPE 1824 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE 1825 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))) 1826 != char_type_node)) 1827 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>", 1828 decl); 1829 break; 1830 1831 case 3: 1832 if (TREE_CODE (type) != POINTER_TYPE 1833 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE 1834 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))) 1835 != char_type_node)) 1836 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be " 1837 "%<char **%>", decl); 1838 break; 1839 } 1840 } 1841 1842 /* It is intentional that this message does not mention the third 1843 argument because it's only mentioned in an appendix of the 1844 standard. */ 1845 if (argct > 0 && (argct < 2 || argct > 3)) 1846 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl); 1847} 1848 1849/* True if pointers to distinct types T1 and T2 can be converted to 1850 each other without an explicit cast. Only returns true for opaque 1851 vector types. */ 1852bool 1853vector_targets_convertible_p (const_tree t1, const_tree t2) 1854{ 1855 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE 1856 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2)) 1857 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))) 1858 return true; 1859 1860 return false; 1861} 1862 1863/* True if vector types T1 and T2 can be converted to each other 1864 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2 1865 can only be converted with -flax-vector-conversions yet that is not 1866 in effect, emit a note telling the user about that option if such 1867 a note has not previously been emitted. */ 1868bool 1869vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note) 1870{ 1871 static bool emitted_lax_note = false; 1872 bool convertible_lax; 1873 1874 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2)) 1875 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))) 1876 return true; 1877 1878 convertible_lax = 1879 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)) 1880 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE || 1881 TYPE_PRECISION (t1) == TYPE_PRECISION (t2)) 1882 && (INTEGRAL_TYPE_P (TREE_TYPE (t1)) 1883 == INTEGRAL_TYPE_P (TREE_TYPE (t2)))); 1884 1885 if (!convertible_lax || flag_lax_vector_conversions) 1886 return convertible_lax; 1887 1888 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 1889 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1890 return true; 1891 1892 if (emit_lax_note && !emitted_lax_note) 1893 { 1894 emitted_lax_note = true; 1895 inform (input_location, "use -flax-vector-conversions to permit " 1896 "conversions between vectors with differing " 1897 "element types or numbers of subparts"); 1898 } 1899 1900 return false; 1901} 1902 1903/* This is a helper function of build_binary_op. 1904 1905 For certain operations if both args were extended from the same 1906 smaller type, do the arithmetic in that type and then extend. 1907 1908 BITWISE indicates a bitwise operation. 1909 For them, this optimization is safe only if 1910 both args are zero-extended or both are sign-extended. 1911 Otherwise, we might change the result. 1912 Eg, (short)-1 | (unsigned short)-1 is (int)-1 1913 but calculated in (unsigned short) it would be (unsigned short)-1. 1914*/ 1915tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise) 1916{ 1917 int unsigned0, unsigned1; 1918 tree arg0, arg1; 1919 int uns; 1920 tree type; 1921 1922 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 1923 excessive narrowing when we call get_narrower below. For 1924 example, suppose that OP0 is of unsigned int extended 1925 from signed char and that RESULT_TYPE is long long int. 1926 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 1927 like 1928 1929 (long long int) (unsigned int) signed_char 1930 1931 which get_narrower would narrow down to 1932 1933 (unsigned int) signed char 1934 1935 If we do not cast OP0 first, get_narrower would return 1936 signed_char, which is inconsistent with the case of the 1937 explicit cast. */ 1938 op0 = convert (result_type, op0); 1939 op1 = convert (result_type, op1); 1940 1941 arg0 = get_narrower (op0, &unsigned0); 1942 arg1 = get_narrower (op1, &unsigned1); 1943 1944 /* UNS is 1 if the operation to be done is an unsigned one. */ 1945 uns = TYPE_UNSIGNED (result_type); 1946 1947 /* Handle the case that OP0 (or OP1) does not *contain* a conversion 1948 but it *requires* conversion to FINAL_TYPE. */ 1949 1950 if ((TYPE_PRECISION (TREE_TYPE (op0)) 1951 == TYPE_PRECISION (TREE_TYPE (arg0))) 1952 && TREE_TYPE (op0) != result_type) 1953 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 1954 if ((TYPE_PRECISION (TREE_TYPE (op1)) 1955 == TYPE_PRECISION (TREE_TYPE (arg1))) 1956 && TREE_TYPE (op1) != result_type) 1957 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 1958 1959 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 1960 1961 /* For bitwise operations, signedness of nominal type 1962 does not matter. Consider only how operands were extended. */ 1963 if (bitwise) 1964 uns = unsigned0; 1965 1966 /* Note that in all three cases below we refrain from optimizing 1967 an unsigned operation on sign-extended args. 1968 That would not be valid. */ 1969 1970 /* Both args variable: if both extended in same way 1971 from same width, do it in that width. 1972 Do it unsigned if args were zero-extended. */ 1973 if ((TYPE_PRECISION (TREE_TYPE (arg0)) 1974 < TYPE_PRECISION (result_type)) 1975 && (TYPE_PRECISION (TREE_TYPE (arg1)) 1976 == TYPE_PRECISION (TREE_TYPE (arg0))) 1977 && unsigned0 == unsigned1 1978 && (unsigned0 || !uns)) 1979 return c_common_signed_or_unsigned_type 1980 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 1981 1982 else if (TREE_CODE (arg0) == INTEGER_CST 1983 && (unsigned1 || !uns) 1984 && (TYPE_PRECISION (TREE_TYPE (arg1)) 1985 < TYPE_PRECISION (result_type)) 1986 && (type 1987 = c_common_signed_or_unsigned_type (unsigned1, 1988 TREE_TYPE (arg1))) 1989 && !POINTER_TYPE_P (type) 1990 && int_fits_type_p (arg0, type)) 1991 return type; 1992 1993 else if (TREE_CODE (arg1) == INTEGER_CST 1994 && (unsigned0 || !uns) 1995 && (TYPE_PRECISION (TREE_TYPE (arg0)) 1996 < TYPE_PRECISION (result_type)) 1997 && (type 1998 = c_common_signed_or_unsigned_type (unsigned0, 1999 TREE_TYPE (arg0))) 2000 && !POINTER_TYPE_P (type) 2001 && int_fits_type_p (arg1, type)) 2002 return type; 2003 2004 return result_type; 2005} 2006 2007/* Warns if the conversion of EXPR to TYPE may alter a value. 2008 This is a helper function for warnings_for_convert_and_check. */ 2009 2010static void 2011conversion_warning (tree type, tree expr) 2012{ 2013 bool give_warning = false; 2014 2015 int i; 2016 const int expr_num_operands = TREE_OPERAND_LENGTH (expr); 2017 tree expr_type = TREE_TYPE (expr); 2018 2019 if (!warn_conversion && !warn_sign_conversion) 2020 return; 2021 2022 /* If any operand is artificial, then this expression was generated 2023 by the compiler and we do not warn. */ 2024 for (i = 0; i < expr_num_operands; i++) 2025 { 2026 tree op = TREE_OPERAND (expr, i); 2027 if (op && DECL_P (op) && DECL_ARTIFICIAL (op)) 2028 return; 2029 } 2030 2031 switch (TREE_CODE (expr)) 2032 { 2033 case EQ_EXPR: 2034 case NE_EXPR: 2035 case LE_EXPR: 2036 case GE_EXPR: 2037 case LT_EXPR: 2038 case GT_EXPR: 2039 case TRUTH_ANDIF_EXPR: 2040 case TRUTH_ORIF_EXPR: 2041 case TRUTH_AND_EXPR: 2042 case TRUTH_OR_EXPR: 2043 case TRUTH_XOR_EXPR: 2044 case TRUTH_NOT_EXPR: 2045 /* Conversion from boolean to a signed:1 bit-field (which only 2046 can hold the values 0 and -1) doesn't lose information - but 2047 it does change the value. */ 2048 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type)) 2049 warning (OPT_Wconversion, 2050 "conversion to %qT from boolean expression", type); 2051 return; 2052 2053 case REAL_CST: 2054 case INTEGER_CST: 2055 2056 /* Warn for real constant that is not an exact integer converted 2057 to integer type. */ 2058 if (TREE_CODE (expr_type) == REAL_TYPE 2059 && TREE_CODE (type) == INTEGER_TYPE) 2060 { 2061 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type))) 2062 give_warning = true; 2063 } 2064 /* Warn for an integer constant that does not fit into integer type. */ 2065 else if (TREE_CODE (expr_type) == INTEGER_TYPE 2066 && TREE_CODE (type) == INTEGER_TYPE 2067 && !int_fits_type_p (expr, type)) 2068 { 2069 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type) 2070 && tree_int_cst_sgn (expr) < 0) 2071 warning (OPT_Wsign_conversion, 2072 "negative integer implicitly converted to unsigned type"); 2073 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type)) 2074 warning (OPT_Wsign_conversion, "conversion of unsigned constant " 2075 "value to negative integer"); 2076 else 2077 give_warning = true; 2078 } 2079 else if (TREE_CODE (type) == REAL_TYPE) 2080 { 2081 /* Warn for an integer constant that does not fit into real type. */ 2082 if (TREE_CODE (expr_type) == INTEGER_TYPE) 2083 { 2084 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr); 2085 if (!exact_real_truncate (TYPE_MODE (type), &a)) 2086 give_warning = true; 2087 } 2088 /* Warn for a real constant that does not fit into a smaller 2089 real type. */ 2090 else if (TREE_CODE (expr_type) == REAL_TYPE 2091 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 2092 { 2093 REAL_VALUE_TYPE a = TREE_REAL_CST (expr); 2094 if (!exact_real_truncate (TYPE_MODE (type), &a)) 2095 give_warning = true; 2096 } 2097 } 2098 2099 if (give_warning) 2100 warning (OPT_Wconversion, 2101 "conversion to %qT alters %qT constant value", 2102 type, expr_type); 2103 2104 return; 2105 2106 case COND_EXPR: 2107 { 2108 /* In case of COND_EXPR, if both operands are constants or 2109 COND_EXPR, then we do not care about the type of COND_EXPR, 2110 only about the conversion of each operand. */ 2111 tree op1 = TREE_OPERAND (expr, 1); 2112 tree op2 = TREE_OPERAND (expr, 2); 2113 2114 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST 2115 || TREE_CODE (op1) == COND_EXPR) 2116 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST 2117 || TREE_CODE (op2) == COND_EXPR)) 2118 { 2119 conversion_warning (type, op1); 2120 conversion_warning (type, op2); 2121 return; 2122 } 2123 /* Fall through. */ 2124 } 2125 2126 default: /* 'expr' is not a constant. */ 2127 2128 /* Warn for real types converted to integer types. */ 2129 if (TREE_CODE (expr_type) == REAL_TYPE 2130 && TREE_CODE (type) == INTEGER_TYPE) 2131 give_warning = true; 2132 2133 else if (TREE_CODE (expr_type) == INTEGER_TYPE 2134 && TREE_CODE (type) == INTEGER_TYPE) 2135 { 2136 /* Don't warn about unsigned char y = 0xff, x = (int) y; */ 2137 expr = get_unwidened (expr, 0); 2138 expr_type = TREE_TYPE (expr); 2139 2140 /* Don't warn for short y; short x = ((int)y & 0xff); */ 2141 if (TREE_CODE (expr) == BIT_AND_EXPR 2142 || TREE_CODE (expr) == BIT_IOR_EXPR 2143 || TREE_CODE (expr) == BIT_XOR_EXPR) 2144 { 2145 /* If both args were extended from a shortest type, 2146 use that type if that is safe. */ 2147 expr_type = shorten_binary_op (expr_type, 2148 TREE_OPERAND (expr, 0), 2149 TREE_OPERAND (expr, 1), 2150 /* bitwise */1); 2151 2152 if (TREE_CODE (expr) == BIT_AND_EXPR) 2153 { 2154 tree op0 = TREE_OPERAND (expr, 0); 2155 tree op1 = TREE_OPERAND (expr, 1); 2156 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 2157 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 2158 2159 /* If one of the operands is a non-negative constant 2160 that fits in the target type, then the type of the 2161 other operand does not matter. */ 2162 if ((TREE_CODE (op0) == INTEGER_CST 2163 && int_fits_type_p (op0, c_common_signed_type (type)) 2164 && int_fits_type_p (op0, c_common_unsigned_type (type))) 2165 || (TREE_CODE (op1) == INTEGER_CST 2166 && int_fits_type_p (op1, c_common_signed_type (type)) 2167 && int_fits_type_p (op1, 2168 c_common_unsigned_type (type)))) 2169 return; 2170 /* If constant is unsigned and fits in the target 2171 type, then the result will also fit. */ 2172 else if ((TREE_CODE (op0) == INTEGER_CST 2173 && unsigned0 2174 && int_fits_type_p (op0, type)) 2175 || (TREE_CODE (op1) == INTEGER_CST 2176 && unsigned1 2177 && int_fits_type_p (op1, type))) 2178 return; 2179 } 2180 } 2181 /* Warn for integer types converted to smaller integer types. */ 2182 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 2183 give_warning = true; 2184 2185 /* When they are the same width but different signedness, 2186 then the value may change. */ 2187 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type) 2188 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type)) 2189 /* Even when converted to a bigger type, if the type is 2190 unsigned but expr is signed, then negative values 2191 will be changed. */ 2192 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type))) 2193 warning (OPT_Wsign_conversion, "conversion to %qT from %qT " 2194 "may change the sign of the result", 2195 type, expr_type); 2196 } 2197 2198 /* Warn for integer types converted to real types if and only if 2199 all the range of values of the integer type cannot be 2200 represented by the real type. */ 2201 else if (TREE_CODE (expr_type) == INTEGER_TYPE 2202 && TREE_CODE (type) == REAL_TYPE) 2203 { 2204 tree type_low_bound, type_high_bound; 2205 REAL_VALUE_TYPE real_low_bound, real_high_bound; 2206 2207 /* Don't warn about char y = 0xff; float x = (int) y; */ 2208 expr = get_unwidened (expr, 0); 2209 expr_type = TREE_TYPE (expr); 2210 2211 type_low_bound = TYPE_MIN_VALUE (expr_type); 2212 type_high_bound = TYPE_MAX_VALUE (expr_type); 2213 real_low_bound = real_value_from_int_cst (0, type_low_bound); 2214 real_high_bound = real_value_from_int_cst (0, type_high_bound); 2215 2216 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound) 2217 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound)) 2218 give_warning = true; 2219 } 2220 2221 /* Warn for real types converted to smaller real types. */ 2222 else if (TREE_CODE (expr_type) == REAL_TYPE 2223 && TREE_CODE (type) == REAL_TYPE 2224 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 2225 give_warning = true; 2226 2227 2228 if (give_warning) 2229 warning (OPT_Wconversion, 2230 "conversion to %qT from %qT may alter its value", 2231 type, expr_type); 2232 } 2233} 2234 2235/* Produce warnings after a conversion. RESULT is the result of 2236 converting EXPR to TYPE. This is a helper function for 2237 convert_and_check and cp_convert_and_check. */ 2238 2239void 2240warnings_for_convert_and_check (tree type, tree expr, tree result) 2241{ 2242 if (TREE_CODE (expr) == INTEGER_CST 2243 && (TREE_CODE (type) == INTEGER_TYPE 2244 || TREE_CODE (type) == ENUMERAL_TYPE) 2245 && !int_fits_type_p (expr, type)) 2246 { 2247 /* Do not diagnose overflow in a constant expression merely 2248 because a conversion overflowed. */ 2249 if (TREE_OVERFLOW (result)) 2250 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr); 2251 2252 if (TYPE_UNSIGNED (type)) 2253 { 2254 /* This detects cases like converting -129 or 256 to 2255 unsigned char. */ 2256 if (!int_fits_type_p (expr, c_common_signed_type (type))) 2257 warning (OPT_Woverflow, 2258 "large integer implicitly truncated to unsigned type"); 2259 else 2260 conversion_warning (type, expr); 2261 } 2262 else if (!int_fits_type_p (expr, c_common_unsigned_type (type))) 2263 warning (OPT_Woverflow, 2264 "overflow in implicit constant conversion"); 2265 /* No warning for converting 0x80000000 to int. */ 2266 else if (pedantic 2267 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE 2268 || TYPE_PRECISION (TREE_TYPE (expr)) 2269 != TYPE_PRECISION (type))) 2270 warning (OPT_Woverflow, 2271 "overflow in implicit constant conversion"); 2272 2273 else 2274 conversion_warning (type, expr); 2275 } 2276 else if ((TREE_CODE (result) == INTEGER_CST 2277 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result)) 2278 warning (OPT_Woverflow, 2279 "overflow in implicit constant conversion"); 2280 else 2281 conversion_warning (type, expr); 2282} 2283 2284 2285/* Convert EXPR to TYPE, warning about conversion problems with constants. 2286 Invoke this function on every expression that is converted implicitly, 2287 i.e. because of language rules and not because of an explicit cast. */ 2288 2289tree 2290convert_and_check (tree type, tree expr) 2291{ 2292 tree result; 2293 tree expr_for_warning; 2294 2295 /* Convert from a value with possible excess precision rather than 2296 via the semantic type, but do not warn about values not fitting 2297 exactly in the semantic type. */ 2298 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR) 2299 { 2300 tree orig_type = TREE_TYPE (expr); 2301 expr = TREE_OPERAND (expr, 0); 2302 expr_for_warning = convert (orig_type, expr); 2303 if (orig_type == type) 2304 return expr_for_warning; 2305 } 2306 else 2307 expr_for_warning = expr; 2308 2309 if (TREE_TYPE (expr) == type) 2310 return expr; 2311 2312 result = convert (type, expr); 2313 2314 if (c_inhibit_evaluation_warnings == 0 2315 && !TREE_OVERFLOW_P (expr) 2316 && result != error_mark_node) 2317 warnings_for_convert_and_check (type, expr_for_warning, result); 2318 2319 return result; 2320} 2321 2322/* A node in a list that describes references to variables (EXPR), which are 2323 either read accesses if WRITER is zero, or write accesses, in which case 2324 WRITER is the parent of EXPR. */ 2325struct tlist 2326{ 2327 struct tlist *next; 2328 tree expr, writer; 2329}; 2330 2331/* Used to implement a cache the results of a call to verify_tree. We only 2332 use this for SAVE_EXPRs. */ 2333struct tlist_cache 2334{ 2335 struct tlist_cache *next; 2336 struct tlist *cache_before_sp; 2337 struct tlist *cache_after_sp; 2338 tree expr; 2339}; 2340 2341/* Obstack to use when allocating tlist structures, and corresponding 2342 firstobj. */ 2343static struct obstack tlist_obstack; 2344static char *tlist_firstobj = 0; 2345 2346/* Keep track of the identifiers we've warned about, so we can avoid duplicate 2347 warnings. */ 2348static struct tlist *warned_ids; 2349/* SAVE_EXPRs need special treatment. We process them only once and then 2350 cache the results. */ 2351static struct tlist_cache *save_expr_cache; 2352 2353static void add_tlist (struct tlist **, struct tlist *, tree, int); 2354static void merge_tlist (struct tlist **, struct tlist *, int); 2355static void verify_tree (tree, struct tlist **, struct tlist **, tree); 2356static int warning_candidate_p (tree); 2357static bool candidate_equal_p (const_tree, const_tree); 2358static void warn_for_collisions (struct tlist *); 2359static void warn_for_collisions_1 (tree, tree, struct tlist *, int); 2360static struct tlist *new_tlist (struct tlist *, tree, tree); 2361 2362/* Create a new struct tlist and fill in its fields. */ 2363static struct tlist * 2364new_tlist (struct tlist *next, tree t, tree writer) 2365{ 2366 struct tlist *l; 2367 l = XOBNEW (&tlist_obstack, struct tlist); 2368 l->next = next; 2369 l->expr = t; 2370 l->writer = writer; 2371 return l; 2372} 2373 2374/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER 2375 is nonnull, we ignore any node we find which has a writer equal to it. */ 2376 2377static void 2378add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy) 2379{ 2380 while (add) 2381 { 2382 struct tlist *next = add->next; 2383 if (!copy) 2384 add->next = *to; 2385 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer)) 2386 *to = copy ? new_tlist (*to, add->expr, add->writer) : add; 2387 add = next; 2388 } 2389} 2390 2391/* Merge the nodes of ADD into TO. This merging process is done so that for 2392 each variable that already exists in TO, no new node is added; however if 2393 there is a write access recorded in ADD, and an occurrence on TO is only 2394 a read access, then the occurrence in TO will be modified to record the 2395 write. */ 2396 2397static void 2398merge_tlist (struct tlist **to, struct tlist *add, int copy) 2399{ 2400 struct tlist **end = to; 2401 2402 while (*end) 2403 end = &(*end)->next; 2404 2405 while (add) 2406 { 2407 int found = 0; 2408 struct tlist *tmp2; 2409 struct tlist *next = add->next; 2410 2411 for (tmp2 = *to; tmp2; tmp2 = tmp2->next) 2412 if (candidate_equal_p (tmp2->expr, add->expr)) 2413 { 2414 found = 1; 2415 if (!tmp2->writer) 2416 tmp2->writer = add->writer; 2417 } 2418 if (!found) 2419 { 2420 *end = copy ? add : new_tlist (NULL, add->expr, add->writer); 2421 end = &(*end)->next; 2422 *end = 0; 2423 } 2424 add = next; 2425 } 2426} 2427 2428/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable 2429 references in list LIST conflict with it, excluding reads if ONLY writers 2430 is nonzero. */ 2431 2432static void 2433warn_for_collisions_1 (tree written, tree writer, struct tlist *list, 2434 int only_writes) 2435{ 2436 struct tlist *tmp; 2437 2438 /* Avoid duplicate warnings. */ 2439 for (tmp = warned_ids; tmp; tmp = tmp->next) 2440 if (candidate_equal_p (tmp->expr, written)) 2441 return; 2442 2443 while (list) 2444 { 2445 if (candidate_equal_p (list->expr, written) 2446 && !candidate_equal_p (list->writer, writer) 2447 && (!only_writes || list->writer)) 2448 { 2449 warned_ids = new_tlist (warned_ids, written, NULL_TREE); 2450 warning_at (EXPR_HAS_LOCATION (writer) 2451 ? EXPR_LOCATION (writer) : input_location, 2452 OPT_Wsequence_point, "operation on %qE may be undefined", 2453 list->expr); 2454 } 2455 list = list->next; 2456 } 2457} 2458 2459/* Given a list LIST of references to variables, find whether any of these 2460 can cause conflicts due to missing sequence points. */ 2461 2462static void 2463warn_for_collisions (struct tlist *list) 2464{ 2465 struct tlist *tmp; 2466 2467 for (tmp = list; tmp; tmp = tmp->next) 2468 { 2469 if (tmp->writer) 2470 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0); 2471 } 2472} 2473 2474/* Return nonzero if X is a tree that can be verified by the sequence point 2475 warnings. */ 2476static int 2477warning_candidate_p (tree x) 2478{ 2479 if (DECL_P (x) && DECL_ARTIFICIAL (x)) 2480 return 0; 2481 2482 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c 2483 (lvalue_p) crash on TRY/CATCH. */ 2484 if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x))) 2485 return 0; 2486 2487 if (!lvalue_p (x)) 2488 return 0; 2489 2490 /* No point to track non-const calls, they will never satisfy 2491 operand_equal_p. */ 2492 if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0) 2493 return 0; 2494 2495 if (TREE_CODE (x) == STRING_CST) 2496 return 0; 2497 2498 return 1; 2499} 2500 2501/* Return nonzero if X and Y appear to be the same candidate (or NULL) */ 2502static bool 2503candidate_equal_p (const_tree x, const_tree y) 2504{ 2505 return (x == y) || (x && y && operand_equal_p (x, y, 0)); 2506} 2507 2508/* Walk the tree X, and record accesses to variables. If X is written by the 2509 parent tree, WRITER is the parent. 2510 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this 2511 expression or its only operand forces a sequence point, then everything up 2512 to the sequence point is stored in PBEFORE_SP. Everything else gets stored 2513 in PNO_SP. 2514 Once we return, we will have emitted warnings if any subexpression before 2515 such a sequence point could be undefined. On a higher level, however, the 2516 sequence point may not be relevant, and we'll merge the two lists. 2517 2518 Example: (b++, a) + b; 2519 The call that processes the COMPOUND_EXPR will store the increment of B 2520 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that 2521 processes the PLUS_EXPR will need to merge the two lists so that 2522 eventually, all accesses end up on the same list (and we'll warn about the 2523 unordered subexpressions b++ and b. 2524 2525 A note on merging. If we modify the former example so that our expression 2526 becomes 2527 (b++, b) + a 2528 care must be taken not simply to add all three expressions into the final 2529 PNO_SP list. The function merge_tlist takes care of that by merging the 2530 before-SP list of the COMPOUND_EXPR into its after-SP list in a special 2531 way, so that no more than one access to B is recorded. */ 2532 2533static void 2534verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp, 2535 tree writer) 2536{ 2537 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3; 2538 enum tree_code code; 2539 enum tree_code_class cl; 2540 2541 /* X may be NULL if it is the operand of an empty statement expression 2542 ({ }). */ 2543 if (x == NULL) 2544 return; 2545 2546 restart: 2547 code = TREE_CODE (x); 2548 cl = TREE_CODE_CLASS (code); 2549 2550 if (warning_candidate_p (x)) 2551 *pno_sp = new_tlist (*pno_sp, x, writer); 2552 2553 switch (code) 2554 { 2555 case CONSTRUCTOR: 2556 return; 2557 2558 case COMPOUND_EXPR: 2559 case TRUTH_ANDIF_EXPR: 2560 case TRUTH_ORIF_EXPR: 2561 tmp_before = tmp_nosp = tmp_list3 = 0; 2562 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 2563 warn_for_collisions (tmp_nosp); 2564 merge_tlist (pbefore_sp, tmp_before, 0); 2565 merge_tlist (pbefore_sp, tmp_nosp, 0); 2566 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE); 2567 merge_tlist (pbefore_sp, tmp_list3, 0); 2568 return; 2569 2570 case COND_EXPR: 2571 tmp_before = tmp_list2 = 0; 2572 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE); 2573 warn_for_collisions (tmp_list2); 2574 merge_tlist (pbefore_sp, tmp_before, 0); 2575 merge_tlist (pbefore_sp, tmp_list2, 1); 2576 2577 tmp_list3 = tmp_nosp = 0; 2578 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE); 2579 warn_for_collisions (tmp_nosp); 2580 merge_tlist (pbefore_sp, tmp_list3, 0); 2581 2582 tmp_list3 = tmp_list2 = 0; 2583 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE); 2584 warn_for_collisions (tmp_list2); 2585 merge_tlist (pbefore_sp, tmp_list3, 0); 2586 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the 2587 two first, to avoid warning for (a ? b++ : b++). */ 2588 merge_tlist (&tmp_nosp, tmp_list2, 0); 2589 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 2590 return; 2591 2592 case PREDECREMENT_EXPR: 2593 case PREINCREMENT_EXPR: 2594 case POSTDECREMENT_EXPR: 2595 case POSTINCREMENT_EXPR: 2596 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x); 2597 return; 2598 2599 case MODIFY_EXPR: 2600 tmp_before = tmp_nosp = tmp_list3 = 0; 2601 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE); 2602 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x); 2603 /* Expressions inside the LHS are not ordered wrt. the sequence points 2604 in the RHS. Example: 2605 *a = (a++, 2) 2606 Despite the fact that the modification of "a" is in the before_sp 2607 list (tmp_before), it conflicts with the use of "a" in the LHS. 2608 We can handle this by adding the contents of tmp_list3 2609 to those of tmp_before, and redoing the collision warnings for that 2610 list. */ 2611 add_tlist (&tmp_before, tmp_list3, x, 1); 2612 warn_for_collisions (tmp_before); 2613 /* Exclude the LHS itself here; we first have to merge it into the 2614 tmp_nosp list. This is done to avoid warning for "a = a"; if we 2615 didn't exclude the LHS, we'd get it twice, once as a read and once 2616 as a write. */ 2617 add_tlist (pno_sp, tmp_list3, x, 0); 2618 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1); 2619 2620 merge_tlist (pbefore_sp, tmp_before, 0); 2621 if (warning_candidate_p (TREE_OPERAND (x, 0))) 2622 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0); 2623 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1); 2624 return; 2625 2626 case CALL_EXPR: 2627 /* We need to warn about conflicts among arguments and conflicts between 2628 args and the function address. Side effects of the function address, 2629 however, are not ordered by the sequence point of the call. */ 2630 { 2631 call_expr_arg_iterator iter; 2632 tree arg; 2633 tmp_before = tmp_nosp = 0; 2634 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE); 2635 FOR_EACH_CALL_EXPR_ARG (arg, iter, x) 2636 { 2637 tmp_list2 = tmp_list3 = 0; 2638 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE); 2639 merge_tlist (&tmp_list3, tmp_list2, 0); 2640 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0); 2641 } 2642 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0); 2643 warn_for_collisions (tmp_before); 2644 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0); 2645 return; 2646 } 2647 2648 case TREE_LIST: 2649 /* Scan all the list, e.g. indices of multi dimensional array. */ 2650 while (x) 2651 { 2652 tmp_before = tmp_nosp = 0; 2653 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE); 2654 merge_tlist (&tmp_nosp, tmp_before, 0); 2655 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 2656 x = TREE_CHAIN (x); 2657 } 2658 return; 2659 2660 case SAVE_EXPR: 2661 { 2662 struct tlist_cache *t; 2663 for (t = save_expr_cache; t; t = t->next) 2664 if (candidate_equal_p (t->expr, x)) 2665 break; 2666 2667 if (!t) 2668 { 2669 t = XOBNEW (&tlist_obstack, struct tlist_cache); 2670 t->next = save_expr_cache; 2671 t->expr = x; 2672 save_expr_cache = t; 2673 2674 tmp_before = tmp_nosp = 0; 2675 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 2676 warn_for_collisions (tmp_nosp); 2677 2678 tmp_list3 = 0; 2679 while (tmp_nosp) 2680 { 2681 struct tlist *t = tmp_nosp; 2682 tmp_nosp = t->next; 2683 merge_tlist (&tmp_list3, t, 0); 2684 } 2685 t->cache_before_sp = tmp_before; 2686 t->cache_after_sp = tmp_list3; 2687 } 2688 merge_tlist (pbefore_sp, t->cache_before_sp, 1); 2689 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1); 2690 return; 2691 } 2692 2693 case ADDR_EXPR: 2694 x = TREE_OPERAND (x, 0); 2695 if (DECL_P (x)) 2696 return; 2697 writer = 0; 2698 goto restart; 2699 2700 default: 2701 /* For other expressions, simply recurse on their operands. 2702 Manual tail recursion for unary expressions. 2703 Other non-expressions need not be processed. */ 2704 if (cl == tcc_unary) 2705 { 2706 x = TREE_OPERAND (x, 0); 2707 writer = 0; 2708 goto restart; 2709 } 2710 else if (IS_EXPR_CODE_CLASS (cl)) 2711 { 2712 int lp; 2713 int max = TREE_OPERAND_LENGTH (x); 2714 for (lp = 0; lp < max; lp++) 2715 { 2716 tmp_before = tmp_nosp = 0; 2717 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0); 2718 merge_tlist (&tmp_nosp, tmp_before, 0); 2719 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 2720 } 2721 } 2722 return; 2723 } 2724} 2725 2726/* Try to warn for undefined behavior in EXPR due to missing sequence 2727 points. */ 2728 2729void 2730verify_sequence_points (tree expr) 2731{ 2732 struct tlist *before_sp = 0, *after_sp = 0; 2733 2734 warned_ids = 0; 2735 save_expr_cache = 0; 2736 if (tlist_firstobj == 0) 2737 { 2738 gcc_obstack_init (&tlist_obstack); 2739 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0); 2740 } 2741 2742 verify_tree (expr, &before_sp, &after_sp, 0); 2743 warn_for_collisions (after_sp); 2744 obstack_free (&tlist_obstack, tlist_firstobj); 2745} 2746 2747/* Validate the expression after `case' and apply default promotions. */ 2748 2749static tree 2750check_case_value (tree value) 2751{ 2752 if (value == NULL_TREE) 2753 return value; 2754 2755 /* ??? Can we ever get nops here for a valid case value? We 2756 shouldn't for C. */ 2757 STRIP_TYPE_NOPS (value); 2758 /* In C++, the following is allowed: 2759 2760 const int i = 3; 2761 switch (...) { case i: ... } 2762 2763 So, we try to reduce the VALUE to a constant that way. */ 2764 if (c_dialect_cxx ()) 2765 { 2766 value = decl_constant_value (value); 2767 STRIP_TYPE_NOPS (value); 2768 value = fold (value); 2769 } 2770 2771 if (TREE_CODE (value) == INTEGER_CST) 2772 /* Promote char or short to int. */ 2773 value = perform_integral_promotions (value); 2774 else if (value != error_mark_node) 2775 { 2776 error ("case label does not reduce to an integer constant"); 2777 value = error_mark_node; 2778 } 2779 2780 constant_expression_warning (value); 2781 2782 return value; 2783} 2784 2785/* See if the case values LOW and HIGH are in the range of the original 2786 type (i.e. before the default conversion to int) of the switch testing 2787 expression. 2788 TYPE is the promoted type of the testing expression, and ORIG_TYPE is 2789 the type before promoting it. CASE_LOW_P is a pointer to the lower 2790 bound of the case label, and CASE_HIGH_P is the upper bound or NULL 2791 if the case is not a case range. 2792 The caller has to make sure that we are not called with NULL for 2793 CASE_LOW_P (i.e. the default case). 2794 Returns true if the case label is in range of ORIG_TYPE (saturated or 2795 untouched) or false if the label is out of range. */ 2796 2797static bool 2798check_case_bounds (tree type, tree orig_type, 2799 tree *case_low_p, tree *case_high_p) 2800{ 2801 tree min_value, max_value; 2802 tree case_low = *case_low_p; 2803 tree case_high = case_high_p ? *case_high_p : case_low; 2804 2805 /* If there was a problem with the original type, do nothing. */ 2806 if (orig_type == error_mark_node) 2807 return true; 2808 2809 min_value = TYPE_MIN_VALUE (orig_type); 2810 max_value = TYPE_MAX_VALUE (orig_type); 2811 2812 /* Case label is less than minimum for type. */ 2813 if (tree_int_cst_compare (case_low, min_value) < 0 2814 && tree_int_cst_compare (case_high, min_value) < 0) 2815 { 2816 warning (0, "case label value is less than minimum value for type"); 2817 return false; 2818 } 2819 2820 /* Case value is greater than maximum for type. */ 2821 if (tree_int_cst_compare (case_low, max_value) > 0 2822 && tree_int_cst_compare (case_high, max_value) > 0) 2823 { 2824 warning (0, "case label value exceeds maximum value for type"); 2825 return false; 2826 } 2827 2828 /* Saturate lower case label value to minimum. */ 2829 if (tree_int_cst_compare (case_high, min_value) >= 0 2830 && tree_int_cst_compare (case_low, min_value) < 0) 2831 { 2832 warning (0, "lower value in case label range" 2833 " less than minimum value for type"); 2834 case_low = min_value; 2835 } 2836 2837 /* Saturate upper case label value to maximum. */ 2838 if (tree_int_cst_compare (case_low, max_value) <= 0 2839 && tree_int_cst_compare (case_high, max_value) > 0) 2840 { 2841 warning (0, "upper value in case label range" 2842 " exceeds maximum value for type"); 2843 case_high = max_value; 2844 } 2845 2846 if (*case_low_p != case_low) 2847 *case_low_p = convert (type, case_low); 2848 if (case_high_p && *case_high_p != case_high) 2849 *case_high_p = convert (type, case_high); 2850 2851 return true; 2852} 2853 2854/* Return an integer type with BITS bits of precision, 2855 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 2856 2857tree 2858c_common_type_for_size (unsigned int bits, int unsignedp) 2859{ 2860 if (bits == TYPE_PRECISION (integer_type_node)) 2861 return unsignedp ? unsigned_type_node : integer_type_node; 2862 2863 if (bits == TYPE_PRECISION (signed_char_type_node)) 2864 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2865 2866 if (bits == TYPE_PRECISION (short_integer_type_node)) 2867 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2868 2869 if (bits == TYPE_PRECISION (long_integer_type_node)) 2870 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2871 2872 if (bits == TYPE_PRECISION (long_long_integer_type_node)) 2873 return (unsignedp ? long_long_unsigned_type_node 2874 : long_long_integer_type_node); 2875 2876 if (bits == TYPE_PRECISION (widest_integer_literal_type_node)) 2877 return (unsignedp ? widest_unsigned_literal_type_node 2878 : widest_integer_literal_type_node); 2879 2880 if (bits <= TYPE_PRECISION (intQI_type_node)) 2881 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2882 2883 if (bits <= TYPE_PRECISION (intHI_type_node)) 2884 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2885 2886 if (bits <= TYPE_PRECISION (intSI_type_node)) 2887 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2888 2889 if (bits <= TYPE_PRECISION (intDI_type_node)) 2890 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2891 2892 return 0; 2893} 2894 2895/* Return a fixed-point type that has at least IBIT ibits and FBIT fbits 2896 that is unsigned if UNSIGNEDP is nonzero, otherwise signed; 2897 and saturating if SATP is nonzero, otherwise not saturating. */ 2898 2899tree 2900c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit, 2901 int unsignedp, int satp) 2902{ 2903 enum machine_mode mode; 2904 if (ibit == 0) 2905 mode = unsignedp ? UQQmode : QQmode; 2906 else 2907 mode = unsignedp ? UHAmode : HAmode; 2908 2909 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) 2910 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit) 2911 break; 2912 2913 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode)) 2914 { 2915 sorry ("GCC cannot support operators with integer types and " 2916 "fixed-point types that have too many integral and " 2917 "fractional bits together"); 2918 return 0; 2919 } 2920 2921 return c_common_type_for_mode (mode, satp); 2922} 2923 2924/* Used for communication between c_common_type_for_mode and 2925 c_register_builtin_type. */ 2926static GTY(()) tree registered_builtin_types; 2927 2928/* Return a data type that has machine mode MODE. 2929 If the mode is an integer, 2930 then UNSIGNEDP selects between signed and unsigned types. 2931 If the mode is a fixed-point mode, 2932 then UNSIGNEDP selects between saturating and nonsaturating types. */ 2933 2934tree 2935c_common_type_for_mode (enum machine_mode mode, int unsignedp) 2936{ 2937 tree t; 2938 2939 if (mode == TYPE_MODE (integer_type_node)) 2940 return unsignedp ? unsigned_type_node : integer_type_node; 2941 2942 if (mode == TYPE_MODE (signed_char_type_node)) 2943 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2944 2945 if (mode == TYPE_MODE (short_integer_type_node)) 2946 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2947 2948 if (mode == TYPE_MODE (long_integer_type_node)) 2949 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2950 2951 if (mode == TYPE_MODE (long_long_integer_type_node)) 2952 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 2953 2954 if (mode == TYPE_MODE (widest_integer_literal_type_node)) 2955 return unsignedp ? widest_unsigned_literal_type_node 2956 : widest_integer_literal_type_node; 2957 2958 if (mode == QImode) 2959 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2960 2961 if (mode == HImode) 2962 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2963 2964 if (mode == SImode) 2965 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2966 2967 if (mode == DImode) 2968 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2969 2970#if HOST_BITS_PER_WIDE_INT >= 64 2971 if (mode == TYPE_MODE (intTI_type_node)) 2972 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 2973#endif 2974 2975 if (mode == TYPE_MODE (float_type_node)) 2976 return float_type_node; 2977 2978 if (mode == TYPE_MODE (double_type_node)) 2979 return double_type_node; 2980 2981 if (mode == TYPE_MODE (long_double_type_node)) 2982 return long_double_type_node; 2983 2984 if (mode == TYPE_MODE (void_type_node)) 2985 return void_type_node; 2986 2987 if (mode == TYPE_MODE (build_pointer_type (char_type_node))) 2988 return (unsignedp 2989 ? make_unsigned_type (GET_MODE_PRECISION (mode)) 2990 : make_signed_type (GET_MODE_PRECISION (mode))); 2991 2992 if (mode == TYPE_MODE (build_pointer_type (integer_type_node))) 2993 return (unsignedp 2994 ? make_unsigned_type (GET_MODE_PRECISION (mode)) 2995 : make_signed_type (GET_MODE_PRECISION (mode))); 2996 2997 if (COMPLEX_MODE_P (mode)) 2998 { 2999 enum machine_mode inner_mode; 3000 tree inner_type; 3001 3002 if (mode == TYPE_MODE (complex_float_type_node)) 3003 return complex_float_type_node; 3004 if (mode == TYPE_MODE (complex_double_type_node)) 3005 return complex_double_type_node; 3006 if (mode == TYPE_MODE (complex_long_double_type_node)) 3007 return complex_long_double_type_node; 3008 3009 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp) 3010 return complex_integer_type_node; 3011 3012 inner_mode = GET_MODE_INNER (mode); 3013 inner_type = c_common_type_for_mode (inner_mode, unsignedp); 3014 if (inner_type != NULL_TREE) 3015 return build_complex_type (inner_type); 3016 } 3017 else if (VECTOR_MODE_P (mode)) 3018 { 3019 enum machine_mode inner_mode = GET_MODE_INNER (mode); 3020 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp); 3021 if (inner_type != NULL_TREE) 3022 return build_vector_type_for_mode (inner_type, mode); 3023 } 3024 3025 if (mode == TYPE_MODE (dfloat32_type_node)) 3026 return dfloat32_type_node; 3027 if (mode == TYPE_MODE (dfloat64_type_node)) 3028 return dfloat64_type_node; 3029 if (mode == TYPE_MODE (dfloat128_type_node)) 3030 return dfloat128_type_node; 3031 3032 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode)) 3033 { 3034 if (mode == TYPE_MODE (short_fract_type_node)) 3035 return unsignedp ? sat_short_fract_type_node : short_fract_type_node; 3036 if (mode == TYPE_MODE (fract_type_node)) 3037 return unsignedp ? sat_fract_type_node : fract_type_node; 3038 if (mode == TYPE_MODE (long_fract_type_node)) 3039 return unsignedp ? sat_long_fract_type_node : long_fract_type_node; 3040 if (mode == TYPE_MODE (long_long_fract_type_node)) 3041 return unsignedp ? sat_long_long_fract_type_node 3042 : long_long_fract_type_node; 3043 3044 if (mode == TYPE_MODE (unsigned_short_fract_type_node)) 3045 return unsignedp ? sat_unsigned_short_fract_type_node 3046 : unsigned_short_fract_type_node; 3047 if (mode == TYPE_MODE (unsigned_fract_type_node)) 3048 return unsignedp ? sat_unsigned_fract_type_node 3049 : unsigned_fract_type_node; 3050 if (mode == TYPE_MODE (unsigned_long_fract_type_node)) 3051 return unsignedp ? sat_unsigned_long_fract_type_node 3052 : unsigned_long_fract_type_node; 3053 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node)) 3054 return unsignedp ? sat_unsigned_long_long_fract_type_node 3055 : unsigned_long_long_fract_type_node; 3056 3057 if (mode == TYPE_MODE (short_accum_type_node)) 3058 return unsignedp ? sat_short_accum_type_node : short_accum_type_node; 3059 if (mode == TYPE_MODE (accum_type_node)) 3060 return unsignedp ? sat_accum_type_node : accum_type_node; 3061 if (mode == TYPE_MODE (long_accum_type_node)) 3062 return unsignedp ? sat_long_accum_type_node : long_accum_type_node; 3063 if (mode == TYPE_MODE (long_long_accum_type_node)) 3064 return unsignedp ? sat_long_long_accum_type_node 3065 : long_long_accum_type_node; 3066 3067 if (mode == TYPE_MODE (unsigned_short_accum_type_node)) 3068 return unsignedp ? sat_unsigned_short_accum_type_node 3069 : unsigned_short_accum_type_node; 3070 if (mode == TYPE_MODE (unsigned_accum_type_node)) 3071 return unsignedp ? sat_unsigned_accum_type_node 3072 : unsigned_accum_type_node; 3073 if (mode == TYPE_MODE (unsigned_long_accum_type_node)) 3074 return unsignedp ? sat_unsigned_long_accum_type_node 3075 : unsigned_long_accum_type_node; 3076 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node)) 3077 return unsignedp ? sat_unsigned_long_long_accum_type_node 3078 : unsigned_long_long_accum_type_node; 3079 3080 if (mode == QQmode) 3081 return unsignedp ? sat_qq_type_node : qq_type_node; 3082 if (mode == HQmode) 3083 return unsignedp ? sat_hq_type_node : hq_type_node; 3084 if (mode == SQmode) 3085 return unsignedp ? sat_sq_type_node : sq_type_node; 3086 if (mode == DQmode) 3087 return unsignedp ? sat_dq_type_node : dq_type_node; 3088 if (mode == TQmode) 3089 return unsignedp ? sat_tq_type_node : tq_type_node; 3090 3091 if (mode == UQQmode) 3092 return unsignedp ? sat_uqq_type_node : uqq_type_node; 3093 if (mode == UHQmode) 3094 return unsignedp ? sat_uhq_type_node : uhq_type_node; 3095 if (mode == USQmode) 3096 return unsignedp ? sat_usq_type_node : usq_type_node; 3097 if (mode == UDQmode) 3098 return unsignedp ? sat_udq_type_node : udq_type_node; 3099 if (mode == UTQmode) 3100 return unsignedp ? sat_utq_type_node : utq_type_node; 3101 3102 if (mode == HAmode) 3103 return unsignedp ? sat_ha_type_node : ha_type_node; 3104 if (mode == SAmode) 3105 return unsignedp ? sat_sa_type_node : sa_type_node; 3106 if (mode == DAmode) 3107 return unsignedp ? sat_da_type_node : da_type_node; 3108 if (mode == TAmode) 3109 return unsignedp ? sat_ta_type_node : ta_type_node; 3110 3111 if (mode == UHAmode) 3112 return unsignedp ? sat_uha_type_node : uha_type_node; 3113 if (mode == USAmode) 3114 return unsignedp ? sat_usa_type_node : usa_type_node; 3115 if (mode == UDAmode) 3116 return unsignedp ? sat_uda_type_node : uda_type_node; 3117 if (mode == UTAmode) 3118 return unsignedp ? sat_uta_type_node : uta_type_node; 3119 } 3120 3121 for (t = registered_builtin_types; t; t = TREE_CHAIN (t)) 3122 if (TYPE_MODE (TREE_VALUE (t)) == mode) 3123 return TREE_VALUE (t); 3124 3125 return 0; 3126} 3127 3128tree 3129c_common_unsigned_type (tree type) 3130{ 3131 return c_common_signed_or_unsigned_type (1, type); 3132} 3133 3134/* Return a signed type the same as TYPE in other respects. */ 3135 3136tree 3137c_common_signed_type (tree type) 3138{ 3139 return c_common_signed_or_unsigned_type (0, type); 3140} 3141 3142/* Return a type the same as TYPE except unsigned or 3143 signed according to UNSIGNEDP. */ 3144 3145tree 3146c_common_signed_or_unsigned_type (int unsignedp, tree type) 3147{ 3148 tree type1; 3149 3150 /* This block of code emulates the behavior of the old 3151 c_common_unsigned_type. In particular, it returns 3152 long_unsigned_type_node if passed a long, even when a int would 3153 have the same size. This is necessary for warnings to work 3154 correctly in archs where sizeof(int) == sizeof(long) */ 3155 3156 type1 = TYPE_MAIN_VARIANT (type); 3157 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node) 3158 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 3159 if (type1 == integer_type_node || type1 == unsigned_type_node) 3160 return unsignedp ? unsigned_type_node : integer_type_node; 3161 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node) 3162 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 3163 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node) 3164 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 3165 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node) 3166 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 3167 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node) 3168 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node; 3169#if HOST_BITS_PER_WIDE_INT >= 64 3170 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node) 3171 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 3172#endif 3173 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node) 3174 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 3175 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node) 3176 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 3177 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node) 3178 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 3179 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node) 3180 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 3181 3182#define C_COMMON_FIXED_TYPES(NAME) \ 3183 if (type1 == short_ ## NAME ## _type_node \ 3184 || type1 == unsigned_short_ ## NAME ## _type_node) \ 3185 return unsignedp ? unsigned_short_ ## NAME ## _type_node \ 3186 : short_ ## NAME ## _type_node; \ 3187 if (type1 == NAME ## _type_node \ 3188 || type1 == unsigned_ ## NAME ## _type_node) \ 3189 return unsignedp ? unsigned_ ## NAME ## _type_node \ 3190 : NAME ## _type_node; \ 3191 if (type1 == long_ ## NAME ## _type_node \ 3192 || type1 == unsigned_long_ ## NAME ## _type_node) \ 3193 return unsignedp ? unsigned_long_ ## NAME ## _type_node \ 3194 : long_ ## NAME ## _type_node; \ 3195 if (type1 == long_long_ ## NAME ## _type_node \ 3196 || type1 == unsigned_long_long_ ## NAME ## _type_node) \ 3197 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \ 3198 : long_long_ ## NAME ## _type_node; 3199 3200#define C_COMMON_FIXED_MODE_TYPES(NAME) \ 3201 if (type1 == NAME ## _type_node \ 3202 || type1 == u ## NAME ## _type_node) \ 3203 return unsignedp ? u ## NAME ## _type_node \ 3204 : NAME ## _type_node; 3205 3206#define C_COMMON_FIXED_TYPES_SAT(NAME) \ 3207 if (type1 == sat_ ## short_ ## NAME ## _type_node \ 3208 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \ 3209 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \ 3210 : sat_ ## short_ ## NAME ## _type_node; \ 3211 if (type1 == sat_ ## NAME ## _type_node \ 3212 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \ 3213 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \ 3214 : sat_ ## NAME ## _type_node; \ 3215 if (type1 == sat_ ## long_ ## NAME ## _type_node \ 3216 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \ 3217 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \ 3218 : sat_ ## long_ ## NAME ## _type_node; \ 3219 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \ 3220 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \ 3221 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \ 3222 : sat_ ## long_long_ ## NAME ## _type_node; 3223 3224#define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \ 3225 if (type1 == sat_ ## NAME ## _type_node \ 3226 || type1 == sat_ ## u ## NAME ## _type_node) \ 3227 return unsignedp ? sat_ ## u ## NAME ## _type_node \ 3228 : sat_ ## NAME ## _type_node; 3229 3230 C_COMMON_FIXED_TYPES (fract); 3231 C_COMMON_FIXED_TYPES_SAT (fract); 3232 C_COMMON_FIXED_TYPES (accum); 3233 C_COMMON_FIXED_TYPES_SAT (accum); 3234 3235 C_COMMON_FIXED_MODE_TYPES (qq); 3236 C_COMMON_FIXED_MODE_TYPES (hq); 3237 C_COMMON_FIXED_MODE_TYPES (sq); 3238 C_COMMON_FIXED_MODE_TYPES (dq); 3239 C_COMMON_FIXED_MODE_TYPES (tq); 3240 C_COMMON_FIXED_MODE_TYPES_SAT (qq); 3241 C_COMMON_FIXED_MODE_TYPES_SAT (hq); 3242 C_COMMON_FIXED_MODE_TYPES_SAT (sq); 3243 C_COMMON_FIXED_MODE_TYPES_SAT (dq); 3244 C_COMMON_FIXED_MODE_TYPES_SAT (tq); 3245 C_COMMON_FIXED_MODE_TYPES (ha); 3246 C_COMMON_FIXED_MODE_TYPES (sa); 3247 C_COMMON_FIXED_MODE_TYPES (da); 3248 C_COMMON_FIXED_MODE_TYPES (ta); 3249 C_COMMON_FIXED_MODE_TYPES_SAT (ha); 3250 C_COMMON_FIXED_MODE_TYPES_SAT (sa); 3251 C_COMMON_FIXED_MODE_TYPES_SAT (da); 3252 C_COMMON_FIXED_MODE_TYPES_SAT (ta); 3253 3254 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not 3255 the precision; they have precision set to match their range, but 3256 may use a wider mode to match an ABI. If we change modes, we may 3257 wind up with bad conversions. For INTEGER_TYPEs in C, must check 3258 the precision as well, so as to yield correct results for 3259 bit-field types. C++ does not have these separate bit-field 3260 types, and producing a signed or unsigned variant of an 3261 ENUMERAL_TYPE may cause other problems as well. */ 3262 3263 if (!INTEGRAL_TYPE_P (type) 3264 || TYPE_UNSIGNED (type) == unsignedp) 3265 return type; 3266 3267#define TYPE_OK(node) \ 3268 (TYPE_MODE (type) == TYPE_MODE (node) \ 3269 && TYPE_PRECISION (type) == TYPE_PRECISION (node)) 3270 if (TYPE_OK (signed_char_type_node)) 3271 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 3272 if (TYPE_OK (integer_type_node)) 3273 return unsignedp ? unsigned_type_node : integer_type_node; 3274 if (TYPE_OK (short_integer_type_node)) 3275 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 3276 if (TYPE_OK (long_integer_type_node)) 3277 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 3278 if (TYPE_OK (long_long_integer_type_node)) 3279 return (unsignedp ? long_long_unsigned_type_node 3280 : long_long_integer_type_node); 3281 if (TYPE_OK (widest_integer_literal_type_node)) 3282 return (unsignedp ? widest_unsigned_literal_type_node 3283 : widest_integer_literal_type_node); 3284 3285#if HOST_BITS_PER_WIDE_INT >= 64 3286 if (TYPE_OK (intTI_type_node)) 3287 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 3288#endif 3289 if (TYPE_OK (intDI_type_node)) 3290 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 3291 if (TYPE_OK (intSI_type_node)) 3292 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 3293 if (TYPE_OK (intHI_type_node)) 3294 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 3295 if (TYPE_OK (intQI_type_node)) 3296 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 3297#undef TYPE_OK 3298 3299 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp); 3300} 3301 3302/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */ 3303 3304tree 3305c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp) 3306{ 3307 /* Extended integer types of the same width as a standard type have 3308 lesser rank, so those of the same width as int promote to int or 3309 unsigned int and are valid for printf formats expecting int or 3310 unsigned int. To avoid such special cases, avoid creating 3311 extended integer types for bit-fields if a standard integer type 3312 is available. */ 3313 if (width == TYPE_PRECISION (integer_type_node)) 3314 return unsignedp ? unsigned_type_node : integer_type_node; 3315 if (width == TYPE_PRECISION (signed_char_type_node)) 3316 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 3317 if (width == TYPE_PRECISION (short_integer_type_node)) 3318 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 3319 if (width == TYPE_PRECISION (long_integer_type_node)) 3320 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 3321 if (width == TYPE_PRECISION (long_long_integer_type_node)) 3322 return (unsignedp ? long_long_unsigned_type_node 3323 : long_long_integer_type_node); 3324 return build_nonstandard_integer_type (width, unsignedp); 3325} 3326 3327/* The C version of the register_builtin_type langhook. */ 3328 3329void 3330c_register_builtin_type (tree type, const char* name) 3331{ 3332 tree decl; 3333 3334 decl = build_decl (UNKNOWN_LOCATION, 3335 TYPE_DECL, get_identifier (name), type); 3336 DECL_ARTIFICIAL (decl) = 1; 3337 if (!TYPE_NAME (type)) 3338 TYPE_NAME (type) = decl; 3339 pushdecl (decl); 3340 3341 registered_builtin_types = tree_cons (0, type, registered_builtin_types); 3342} 3343 3344/* Print an error message for invalid operands to arith operation 3345 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. 3346 LOCATION is the location of the message. */ 3347 3348void 3349binary_op_error (location_t location, enum tree_code code, 3350 tree type0, tree type1) 3351{ 3352 const char *opname; 3353 3354 switch (code) 3355 { 3356 case PLUS_EXPR: 3357 opname = "+"; break; 3358 case MINUS_EXPR: 3359 opname = "-"; break; 3360 case MULT_EXPR: 3361 opname = "*"; break; 3362 case MAX_EXPR: 3363 opname = "max"; break; 3364 case MIN_EXPR: 3365 opname = "min"; break; 3366 case EQ_EXPR: 3367 opname = "=="; break; 3368 case NE_EXPR: 3369 opname = "!="; break; 3370 case LE_EXPR: 3371 opname = "<="; break; 3372 case GE_EXPR: 3373 opname = ">="; break; 3374 case LT_EXPR: 3375 opname = "<"; break; 3376 case GT_EXPR: 3377 opname = ">"; break; 3378 case LSHIFT_EXPR: 3379 opname = "<<"; break; 3380 case RSHIFT_EXPR: 3381 opname = ">>"; break; 3382 case TRUNC_MOD_EXPR: 3383 case FLOOR_MOD_EXPR: 3384 opname = "%"; break; 3385 case TRUNC_DIV_EXPR: 3386 case FLOOR_DIV_EXPR: 3387 opname = "/"; break; 3388 case BIT_AND_EXPR: 3389 opname = "&"; break; 3390 case BIT_IOR_EXPR: 3391 opname = "|"; break; 3392 case TRUTH_ANDIF_EXPR: 3393 opname = "&&"; break; 3394 case TRUTH_ORIF_EXPR: 3395 opname = "||"; break; 3396 case BIT_XOR_EXPR: 3397 opname = "^"; break; 3398 default: 3399 gcc_unreachable (); 3400 } 3401 error_at (location, 3402 "invalid operands to binary %s (have %qT and %qT)", opname, 3403 type0, type1); 3404} 3405 3406/* Subroutine of build_binary_op, used for comparison operations. 3407 See if the operands have both been converted from subword integer types 3408 and, if so, perhaps change them both back to their original type. 3409 This function is also responsible for converting the two operands 3410 to the proper common type for comparison. 3411 3412 The arguments of this function are all pointers to local variables 3413 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, 3414 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. 3415 3416 If this function returns nonzero, it means that the comparison has 3417 a constant value. What this function returns is an expression for 3418 that value. */ 3419 3420tree 3421shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr, 3422 enum tree_code *rescode_ptr) 3423{ 3424 tree type; 3425 tree op0 = *op0_ptr; 3426 tree op1 = *op1_ptr; 3427 int unsignedp0, unsignedp1; 3428 int real1, real2; 3429 tree primop0, primop1; 3430 enum tree_code code = *rescode_ptr; 3431 3432 /* Throw away any conversions to wider types 3433 already present in the operands. */ 3434 3435 primop0 = get_narrower (op0, &unsignedp0); 3436 primop1 = get_narrower (op1, &unsignedp1); 3437 3438 /* Handle the case that OP0 does not *contain* a conversion 3439 but it *requires* conversion to FINAL_TYPE. */ 3440 3441 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) 3442 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 3443 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) 3444 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 3445 3446 /* If one of the operands must be floated, we cannot optimize. */ 3447 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; 3448 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; 3449 3450 /* If first arg is constant, swap the args (changing operation 3451 so value is preserved), for canonicalization. Don't do this if 3452 the second arg is 0. */ 3453 3454 if (TREE_CONSTANT (primop0) 3455 && !integer_zerop (primop1) && !real_zerop (primop1) 3456 && !fixed_zerop (primop1)) 3457 { 3458 tree tem = primop0; 3459 int temi = unsignedp0; 3460 primop0 = primop1; 3461 primop1 = tem; 3462 tem = op0; 3463 op0 = op1; 3464 op1 = tem; 3465 *op0_ptr = op0; 3466 *op1_ptr = op1; 3467 unsignedp0 = unsignedp1; 3468 unsignedp1 = temi; 3469 temi = real1; 3470 real1 = real2; 3471 real2 = temi; 3472 3473 switch (code) 3474 { 3475 case LT_EXPR: 3476 code = GT_EXPR; 3477 break; 3478 case GT_EXPR: 3479 code = LT_EXPR; 3480 break; 3481 case LE_EXPR: 3482 code = GE_EXPR; 3483 break; 3484 case GE_EXPR: 3485 code = LE_EXPR; 3486 break; 3487 default: 3488 break; 3489 } 3490 *rescode_ptr = code; 3491 } 3492 3493 /* If comparing an integer against a constant more bits wide, 3494 maybe we can deduce a value of 1 or 0 independent of the data. 3495 Or else truncate the constant now 3496 rather than extend the variable at run time. 3497 3498 This is only interesting if the constant is the wider arg. 3499 Also, it is not safe if the constant is unsigned and the 3500 variable arg is signed, since in this case the variable 3501 would be sign-extended and then regarded as unsigned. 3502 Our technique fails in this case because the lowest/highest 3503 possible unsigned results don't follow naturally from the 3504 lowest/highest possible values of the variable operand. 3505 For just EQ_EXPR and NE_EXPR there is another technique that 3506 could be used: see if the constant can be faithfully represented 3507 in the other operand's type, by truncating it and reextending it 3508 and see if that preserves the constant's value. */ 3509 3510 if (!real1 && !real2 3511 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE 3512 && TREE_CODE (primop1) == INTEGER_CST 3513 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) 3514 { 3515 int min_gt, max_gt, min_lt, max_lt; 3516 tree maxval, minval; 3517 /* 1 if comparison is nominally unsigned. */ 3518 int unsignedp = TYPE_UNSIGNED (*restype_ptr); 3519 tree val; 3520 3521 type = c_common_signed_or_unsigned_type (unsignedp0, 3522 TREE_TYPE (primop0)); 3523 3524 maxval = TYPE_MAX_VALUE (type); 3525 minval = TYPE_MIN_VALUE (type); 3526 3527 if (unsignedp && !unsignedp0) 3528 *restype_ptr = c_common_signed_type (*restype_ptr); 3529 3530 if (TREE_TYPE (primop1) != *restype_ptr) 3531 { 3532 /* Convert primop1 to target type, but do not introduce 3533 additional overflow. We know primop1 is an int_cst. */ 3534 primop1 = force_fit_type_double (*restype_ptr, 3535 TREE_INT_CST_LOW (primop1), 3536 TREE_INT_CST_HIGH (primop1), 0, 3537 TREE_OVERFLOW (primop1)); 3538 } 3539 if (type != *restype_ptr) 3540 { 3541 minval = convert (*restype_ptr, minval); 3542 maxval = convert (*restype_ptr, maxval); 3543 } 3544 3545 if (unsignedp && unsignedp0) 3546 { 3547 min_gt = INT_CST_LT_UNSIGNED (primop1, minval); 3548 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval); 3549 min_lt = INT_CST_LT_UNSIGNED (minval, primop1); 3550 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1); 3551 } 3552 else 3553 { 3554 min_gt = INT_CST_LT (primop1, minval); 3555 max_gt = INT_CST_LT (primop1, maxval); 3556 min_lt = INT_CST_LT (minval, primop1); 3557 max_lt = INT_CST_LT (maxval, primop1); 3558 } 3559 3560 val = 0; 3561 /* This used to be a switch, but Genix compiler can't handle that. */ 3562 if (code == NE_EXPR) 3563 { 3564 if (max_lt || min_gt) 3565 val = truthvalue_true_node; 3566 } 3567 else if (code == EQ_EXPR) 3568 { 3569 if (max_lt || min_gt) 3570 val = truthvalue_false_node; 3571 } 3572 else if (code == LT_EXPR) 3573 { 3574 if (max_lt) 3575 val = truthvalue_true_node; 3576 if (!min_lt) 3577 val = truthvalue_false_node; 3578 } 3579 else if (code == GT_EXPR) 3580 { 3581 if (min_gt) 3582 val = truthvalue_true_node; 3583 if (!max_gt) 3584 val = truthvalue_false_node; 3585 } 3586 else if (code == LE_EXPR) 3587 { 3588 if (!max_gt) 3589 val = truthvalue_true_node; 3590 if (min_gt) 3591 val = truthvalue_false_node; 3592 } 3593 else if (code == GE_EXPR) 3594 { 3595 if (!min_lt) 3596 val = truthvalue_true_node; 3597 if (max_lt) 3598 val = truthvalue_false_node; 3599 } 3600 3601 /* If primop0 was sign-extended and unsigned comparison specd, 3602 we did a signed comparison above using the signed type bounds. 3603 But the comparison we output must be unsigned. 3604 3605 Also, for inequalities, VAL is no good; but if the signed 3606 comparison had *any* fixed result, it follows that the 3607 unsigned comparison just tests the sign in reverse 3608 (positive values are LE, negative ones GE). 3609 So we can generate an unsigned comparison 3610 against an extreme value of the signed type. */ 3611 3612 if (unsignedp && !unsignedp0) 3613 { 3614 if (val != 0) 3615 switch (code) 3616 { 3617 case LT_EXPR: 3618 case GE_EXPR: 3619 primop1 = TYPE_MIN_VALUE (type); 3620 val = 0; 3621 break; 3622 3623 case LE_EXPR: 3624 case GT_EXPR: 3625 primop1 = TYPE_MAX_VALUE (type); 3626 val = 0; 3627 break; 3628 3629 default: 3630 break; 3631 } 3632 type = c_common_unsigned_type (type); 3633 } 3634 3635 if (TREE_CODE (primop0) != INTEGER_CST) 3636 { 3637 if (val == truthvalue_false_node) 3638 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type"); 3639 if (val == truthvalue_true_node) 3640 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type"); 3641 } 3642 3643 if (val != 0) 3644 { 3645 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 3646 if (TREE_SIDE_EFFECTS (primop0)) 3647 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); 3648 return val; 3649 } 3650 3651 /* Value is not predetermined, but do the comparison 3652 in the type of the operand that is not constant. 3653 TYPE is already properly set. */ 3654 } 3655 3656 /* If either arg is decimal float and the other is float, find the 3657 proper common type to use for comparison. */ 3658 else if (real1 && real2 3659 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0))) 3660 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1))))) 3661 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 3662 3663 else if (real1 && real2 3664 && (TYPE_PRECISION (TREE_TYPE (primop0)) 3665 == TYPE_PRECISION (TREE_TYPE (primop1)))) 3666 type = TREE_TYPE (primop0); 3667 3668 /* If args' natural types are both narrower than nominal type 3669 and both extend in the same manner, compare them 3670 in the type of the wider arg. 3671 Otherwise must actually extend both to the nominal 3672 common type lest different ways of extending 3673 alter the result. 3674 (eg, (short)-1 == (unsigned short)-1 should be 0.) */ 3675 3676 else if (unsignedp0 == unsignedp1 && real1 == real2 3677 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) 3678 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) 3679 { 3680 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 3681 type = c_common_signed_or_unsigned_type (unsignedp0 3682 || TYPE_UNSIGNED (*restype_ptr), 3683 type); 3684 /* Make sure shorter operand is extended the right way 3685 to match the longer operand. */ 3686 primop0 3687 = convert (c_common_signed_or_unsigned_type (unsignedp0, 3688 TREE_TYPE (primop0)), 3689 primop0); 3690 primop1 3691 = convert (c_common_signed_or_unsigned_type (unsignedp1, 3692 TREE_TYPE (primop1)), 3693 primop1); 3694 } 3695 else 3696 { 3697 /* Here we must do the comparison on the nominal type 3698 using the args exactly as we received them. */ 3699 type = *restype_ptr; 3700 primop0 = op0; 3701 primop1 = op1; 3702 3703 if (!real1 && !real2 && integer_zerop (primop1) 3704 && TYPE_UNSIGNED (*restype_ptr)) 3705 { 3706 tree value = 0; 3707 switch (code) 3708 { 3709 case GE_EXPR: 3710 /* All unsigned values are >= 0, so we warn. However, 3711 if OP0 is a constant that is >= 0, the signedness of 3712 the comparison isn't an issue, so suppress the 3713 warning. */ 3714 if (warn_type_limits && !in_system_header 3715 && !(TREE_CODE (primop0) == INTEGER_CST 3716 && !TREE_OVERFLOW (convert (c_common_signed_type (type), 3717 primop0)))) 3718 warning (OPT_Wtype_limits, 3719 "comparison of unsigned expression >= 0 is always true"); 3720 value = truthvalue_true_node; 3721 break; 3722 3723 case LT_EXPR: 3724 if (warn_type_limits && !in_system_header 3725 && !(TREE_CODE (primop0) == INTEGER_CST 3726 && !TREE_OVERFLOW (convert (c_common_signed_type (type), 3727 primop0)))) 3728 warning (OPT_Wtype_limits, 3729 "comparison of unsigned expression < 0 is always false"); 3730 value = truthvalue_false_node; 3731 break; 3732 3733 default: 3734 break; 3735 } 3736 3737 if (value != 0) 3738 { 3739 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 3740 if (TREE_SIDE_EFFECTS (primop0)) 3741 return build2 (COMPOUND_EXPR, TREE_TYPE (value), 3742 primop0, value); 3743 return value; 3744 } 3745 } 3746 } 3747 3748 *op0_ptr = convert (type, primop0); 3749 *op1_ptr = convert (type, primop1); 3750 3751 *restype_ptr = truthvalue_type_node; 3752 3753 return 0; 3754} 3755 3756/* Return a tree for the sum or difference (RESULTCODE says which) 3757 of pointer PTROP and integer INTOP. */ 3758 3759tree 3760pointer_int_sum (location_t loc, enum tree_code resultcode, 3761 tree ptrop, tree intop) 3762{ 3763 tree size_exp, ret; 3764 3765 /* The result is a pointer of the same type that is being added. */ 3766 tree result_type = TREE_TYPE (ptrop); 3767 3768 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) 3769 { 3770 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 3771 "pointer of type %<void *%> used in arithmetic"); 3772 size_exp = integer_one_node; 3773 } 3774 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) 3775 { 3776 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 3777 "pointer to a function used in arithmetic"); 3778 size_exp = integer_one_node; 3779 } 3780 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE) 3781 { 3782 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 3783 "pointer to member function used in arithmetic"); 3784 size_exp = integer_one_node; 3785 } 3786 else 3787 size_exp = size_in_bytes (TREE_TYPE (result_type)); 3788 3789 /* We are manipulating pointer values, so we don't need to warn 3790 about relying on undefined signed overflow. We disable the 3791 warning here because we use integer types so fold won't know that 3792 they are really pointers. */ 3793 fold_defer_overflow_warnings (); 3794 3795 /* If what we are about to multiply by the size of the elements 3796 contains a constant term, apply distributive law 3797 and multiply that constant term separately. 3798 This helps produce common subexpressions. */ 3799 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR) 3800 && !TREE_CONSTANT (intop) 3801 && TREE_CONSTANT (TREE_OPERAND (intop, 1)) 3802 && TREE_CONSTANT (size_exp) 3803 /* If the constant comes from pointer subtraction, 3804 skip this optimization--it would cause an error. */ 3805 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE 3806 /* If the constant is unsigned, and smaller than the pointer size, 3807 then we must skip this optimization. This is because it could cause 3808 an overflow error if the constant is negative but INTOP is not. */ 3809 && (!TYPE_UNSIGNED (TREE_TYPE (intop)) 3810 || (TYPE_PRECISION (TREE_TYPE (intop)) 3811 == TYPE_PRECISION (TREE_TYPE (ptrop))))) 3812 { 3813 enum tree_code subcode = resultcode; 3814 tree int_type = TREE_TYPE (intop); 3815 if (TREE_CODE (intop) == MINUS_EXPR) 3816 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR); 3817 /* Convert both subexpression types to the type of intop, 3818 because weird cases involving pointer arithmetic 3819 can result in a sum or difference with different type args. */ 3820 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)), 3821 subcode, ptrop, 3822 convert (int_type, TREE_OPERAND (intop, 1)), 1); 3823 intop = convert (int_type, TREE_OPERAND (intop, 0)); 3824 } 3825 3826 /* Convert the integer argument to a type the same size as sizetype 3827 so the multiply won't overflow spuriously. */ 3828 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype) 3829 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype)) 3830 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype), 3831 TYPE_UNSIGNED (sizetype)), intop); 3832 3833 /* Replace the integer argument with a suitable product by the object size. 3834 Do this multiplication as signed, then convert to the appropriate 3835 type for the pointer operation. */ 3836 intop = convert (sizetype, 3837 build_binary_op (loc, 3838 MULT_EXPR, intop, 3839 convert (TREE_TYPE (intop), size_exp), 1)); 3840 3841 /* Create the sum or difference. */ 3842 if (resultcode == MINUS_EXPR) 3843 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop); 3844 3845 ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop); 3846 3847 fold_undefer_and_ignore_overflow_warnings (); 3848 3849 return ret; 3850} 3851 3852/* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded 3853 and if NON_CONST is known not to be permitted in an evaluated part 3854 of a constant expression. */ 3855 3856tree 3857c_wrap_maybe_const (tree expr, bool non_const) 3858{ 3859 bool nowarning = TREE_NO_WARNING (expr); 3860 location_t loc = EXPR_LOCATION (expr); 3861 3862 /* This should never be called for C++. */ 3863 if (c_dialect_cxx ()) 3864 gcc_unreachable (); 3865 3866 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */ 3867 STRIP_TYPE_NOPS (expr); 3868 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr); 3869 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const; 3870 if (nowarning) 3871 TREE_NO_WARNING (expr) = 1; 3872 protected_set_expr_location (expr, loc); 3873 3874 return expr; 3875} 3876 3877/* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but 3878 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR 3879 around the SAVE_EXPR if needed so that c_fully_fold does not need 3880 to look inside SAVE_EXPRs. */ 3881 3882tree 3883c_save_expr (tree expr) 3884{ 3885 bool maybe_const = true; 3886 if (c_dialect_cxx ()) 3887 return save_expr (expr); 3888 expr = c_fully_fold (expr, false, &maybe_const); 3889 expr = save_expr (expr); 3890 if (!maybe_const) 3891 expr = c_wrap_maybe_const (expr, true); 3892 return expr; 3893} 3894 3895/* Return whether EXPR is a declaration whose address can never be 3896 NULL. */ 3897 3898bool 3899decl_with_nonnull_addr_p (const_tree expr) 3900{ 3901 return (DECL_P (expr) 3902 && (TREE_CODE (expr) == PARM_DECL 3903 || TREE_CODE (expr) == LABEL_DECL 3904 || !DECL_WEAK (expr))); 3905} 3906 3907/* Prepare expr to be an argument of a TRUTH_NOT_EXPR, 3908 or for an `if' or `while' statement or ?..: exp. It should already 3909 have been validated to be of suitable type; otherwise, a bad 3910 diagnostic may result. 3911 3912 The EXPR is located at LOCATION. 3913 3914 This preparation consists of taking the ordinary 3915 representation of an expression expr and producing a valid tree 3916 boolean expression describing whether expr is nonzero. We could 3917 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1), 3918 but we optimize comparisons, &&, ||, and !. 3919 3920 The resulting type should always be `truthvalue_type_node'. */ 3921 3922tree 3923c_common_truthvalue_conversion (location_t location, tree expr) 3924{ 3925 switch (TREE_CODE (expr)) 3926 { 3927 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR: 3928 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 3929 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR: 3930 case ORDERED_EXPR: case UNORDERED_EXPR: 3931 if (TREE_TYPE (expr) == truthvalue_type_node) 3932 return expr; 3933 expr = build2 (TREE_CODE (expr), truthvalue_type_node, 3934 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1)); 3935 goto ret; 3936 3937 case TRUTH_ANDIF_EXPR: 3938 case TRUTH_ORIF_EXPR: 3939 case TRUTH_AND_EXPR: 3940 case TRUTH_OR_EXPR: 3941 case TRUTH_XOR_EXPR: 3942 if (TREE_TYPE (expr) == truthvalue_type_node) 3943 return expr; 3944 expr = build2 (TREE_CODE (expr), truthvalue_type_node, 3945 c_common_truthvalue_conversion (location, 3946 TREE_OPERAND (expr, 0)), 3947 c_common_truthvalue_conversion (location, 3948 TREE_OPERAND (expr, 1))); 3949 goto ret; 3950 3951 case TRUTH_NOT_EXPR: 3952 if (TREE_TYPE (expr) == truthvalue_type_node) 3953 return expr; 3954 expr = build1 (TREE_CODE (expr), truthvalue_type_node, 3955 c_common_truthvalue_conversion (location, 3956 TREE_OPERAND (expr, 0))); 3957 goto ret; 3958 3959 case ERROR_MARK: 3960 return expr; 3961 3962 case INTEGER_CST: 3963 return integer_zerop (expr) ? truthvalue_false_node 3964 : truthvalue_true_node; 3965 3966 case REAL_CST: 3967 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0) 3968 ? truthvalue_true_node 3969 : truthvalue_false_node; 3970 3971 case FIXED_CST: 3972 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr), 3973 &FCONST0 (TYPE_MODE (TREE_TYPE (expr)))) 3974 ? truthvalue_true_node 3975 : truthvalue_false_node; 3976 3977 case FUNCTION_DECL: 3978 expr = build_unary_op (location, ADDR_EXPR, expr, 0); 3979 /* Fall through. */ 3980 3981 case ADDR_EXPR: 3982 { 3983 tree inner = TREE_OPERAND (expr, 0); 3984 if (decl_with_nonnull_addr_p (inner)) 3985 { 3986 /* Common Ada/Pascal programmer's mistake. */ 3987 warning_at (location, 3988 OPT_Waddress, 3989 "the address of %qD will always evaluate as %<true%>", 3990 inner); 3991 return truthvalue_true_node; 3992 } 3993 break; 3994 } 3995 3996 case COMPLEX_EXPR: 3997 expr = build_binary_op (EXPR_LOCATION (expr), 3998 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) 3999 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 4000 c_common_truthvalue_conversion (location, 4001 TREE_OPERAND (expr, 0)), 4002 c_common_truthvalue_conversion (location, 4003 TREE_OPERAND (expr, 1)), 4004 0); 4005 goto ret; 4006 4007 case NEGATE_EXPR: 4008 case ABS_EXPR: 4009 case FLOAT_EXPR: 4010 case EXCESS_PRECISION_EXPR: 4011 /* These don't change whether an object is nonzero or zero. */ 4012 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0)); 4013 4014 case LROTATE_EXPR: 4015 case RROTATE_EXPR: 4016 /* These don't change whether an object is zero or nonzero, but 4017 we can't ignore them if their second arg has side-effects. */ 4018 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 4019 { 4020 expr = build2 (COMPOUND_EXPR, truthvalue_type_node, 4021 TREE_OPERAND (expr, 1), 4022 c_common_truthvalue_conversion 4023 (location, TREE_OPERAND (expr, 0))); 4024 goto ret; 4025 } 4026 else 4027 return c_common_truthvalue_conversion (location, 4028 TREE_OPERAND (expr, 0)); 4029 4030 case COND_EXPR: 4031 /* Distribute the conversion into the arms of a COND_EXPR. */ 4032 if (c_dialect_cxx ()) 4033 { 4034 expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node, 4035 TREE_OPERAND (expr, 0), 4036 c_common_truthvalue_conversion (location, 4037 TREE_OPERAND (expr, 4038 1)), 4039 c_common_truthvalue_conversion (location, 4040 TREE_OPERAND (expr, 4041 2))); 4042 goto ret; 4043 } 4044 else 4045 { 4046 /* Folding will happen later for C. */ 4047 expr = build3 (COND_EXPR, truthvalue_type_node, 4048 TREE_OPERAND (expr, 0), 4049 c_common_truthvalue_conversion (location, 4050 TREE_OPERAND (expr, 1)), 4051 c_common_truthvalue_conversion (location, 4052 TREE_OPERAND (expr, 2))); 4053 goto ret; 4054 } 4055 4056 CASE_CONVERT: 4057 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, 4058 since that affects how `default_conversion' will behave. */ 4059 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE 4060 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) 4061 break; 4062 /* If this is widening the argument, we can ignore it. */ 4063 if (TYPE_PRECISION (TREE_TYPE (expr)) 4064 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) 4065 return c_common_truthvalue_conversion (location, 4066 TREE_OPERAND (expr, 0)); 4067 break; 4068 4069 case MODIFY_EXPR: 4070 if (!TREE_NO_WARNING (expr) 4071 && warn_parentheses) 4072 { 4073 warning (OPT_Wparentheses, 4074 "suggest parentheses around assignment used as truth value"); 4075 TREE_NO_WARNING (expr) = 1; 4076 } 4077 break; 4078 4079 default: 4080 break; 4081 } 4082 4083 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE) 4084 { 4085 tree t = (in_late_binary_op ? save_expr (expr) : c_save_expr (expr)); 4086 expr = (build_binary_op 4087 (EXPR_LOCATION (expr), 4088 (TREE_SIDE_EFFECTS (expr) 4089 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 4090 c_common_truthvalue_conversion 4091 (location, 4092 build_unary_op (location, REALPART_EXPR, t, 0)), 4093 c_common_truthvalue_conversion 4094 (location, 4095 build_unary_op (location, IMAGPART_EXPR, t, 0)), 4096 0)); 4097 goto ret; 4098 } 4099 4100 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE) 4101 { 4102 tree fixed_zero_node = build_fixed (TREE_TYPE (expr), 4103 FCONST0 (TYPE_MODE 4104 (TREE_TYPE (expr)))); 4105 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1); 4106 } 4107 else 4108 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1); 4109 4110 ret: 4111 protected_set_expr_location (expr, location); 4112 return expr; 4113} 4114 4115static void def_builtin_1 (enum built_in_function fncode, 4116 const char *name, 4117 enum built_in_class fnclass, 4118 tree fntype, tree libtype, 4119 bool both_p, bool fallback_p, bool nonansi_p, 4120 tree fnattrs, bool implicit_p); 4121 4122 4123/* Apply the TYPE_QUALS to the new DECL. */ 4124 4125void 4126c_apply_type_quals_to_decl (int type_quals, tree decl) 4127{ 4128 tree type = TREE_TYPE (decl); 4129 4130 if (type == error_mark_node) 4131 return; 4132 4133 if (((type_quals & TYPE_QUAL_CONST) 4134 || (type && TREE_CODE (type) == REFERENCE_TYPE)) 4135 /* An object declared 'const' is only readonly after it is 4136 initialized. We don't have any way of expressing this currently, 4137 so we need to be conservative and unset TREE_READONLY for types 4138 with constructors. Otherwise aliasing code will ignore stores in 4139 an inline constructor. */ 4140 && !(type && TYPE_NEEDS_CONSTRUCTING (type))) 4141 TREE_READONLY (decl) = 1; 4142 if (type_quals & TYPE_QUAL_VOLATILE) 4143 { 4144 TREE_SIDE_EFFECTS (decl) = 1; 4145 TREE_THIS_VOLATILE (decl) = 1; 4146 } 4147 if (type_quals & TYPE_QUAL_RESTRICT) 4148 { 4149 while (type && TREE_CODE (type) == ARRAY_TYPE) 4150 /* Allow 'restrict' on arrays of pointers. 4151 FIXME currently we just ignore it. */ 4152 type = TREE_TYPE (type); 4153 if (!type 4154 || !POINTER_TYPE_P (type) 4155 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))) 4156 error ("invalid use of %<restrict%>"); 4157 } 4158} 4159 4160/* Hash function for the problem of multiple type definitions in 4161 different files. This must hash all types that will compare 4162 equal via comptypes to the same value. In practice it hashes 4163 on some of the simple stuff and leaves the details to comptypes. */ 4164 4165static hashval_t 4166c_type_hash (const void *p) 4167{ 4168 int i = 0; 4169 int shift, size; 4170 const_tree const t = (const_tree) p; 4171 tree t2; 4172 switch (TREE_CODE (t)) 4173 { 4174 /* For pointers, hash on pointee type plus some swizzling. */ 4175 case POINTER_TYPE: 4176 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003; 4177 /* Hash on number of elements and total size. */ 4178 case ENUMERAL_TYPE: 4179 shift = 3; 4180 t2 = TYPE_VALUES (t); 4181 break; 4182 case RECORD_TYPE: 4183 shift = 0; 4184 t2 = TYPE_FIELDS (t); 4185 break; 4186 case QUAL_UNION_TYPE: 4187 shift = 1; 4188 t2 = TYPE_FIELDS (t); 4189 break; 4190 case UNION_TYPE: 4191 shift = 2; 4192 t2 = TYPE_FIELDS (t); 4193 break; 4194 default: 4195 gcc_unreachable (); 4196 } 4197 for (; t2; t2 = TREE_CHAIN (t2)) 4198 i++; 4199 /* We might have a VLA here. */ 4200 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST) 4201 size = 0; 4202 else 4203 size = TREE_INT_CST_LOW (TYPE_SIZE (t)); 4204 return ((size << 24) | (i << shift)); 4205} 4206 4207static GTY((param_is (union tree_node))) htab_t type_hash_table; 4208 4209/* Return the typed-based alias set for T, which may be an expression 4210 or a type. Return -1 if we don't do anything special. */ 4211 4212alias_set_type 4213c_common_get_alias_set (tree t) 4214{ 4215 tree u; 4216 PTR *slot; 4217 4218 /* For VLAs, use the alias set of the element type rather than the 4219 default of alias set 0 for types compared structurally. */ 4220 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t)) 4221 { 4222 if (TREE_CODE (t) == ARRAY_TYPE) 4223 return get_alias_set (TREE_TYPE (t)); 4224 return -1; 4225 } 4226 4227 /* Permit type-punning when accessing a union, provided the access 4228 is directly through the union. For example, this code does not 4229 permit taking the address of a union member and then storing 4230 through it. Even the type-punning allowed here is a GCC 4231 extension, albeit a common and useful one; the C standard says 4232 that such accesses have implementation-defined behavior. */ 4233 for (u = t; 4234 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF; 4235 u = TREE_OPERAND (u, 0)) 4236 if (TREE_CODE (u) == COMPONENT_REF 4237 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE) 4238 return 0; 4239 4240 /* That's all the expressions we handle specially. */ 4241 if (!TYPE_P (t)) 4242 return -1; 4243 4244 /* The C standard guarantees that any object may be accessed via an 4245 lvalue that has character type. */ 4246 if (t == char_type_node 4247 || t == signed_char_type_node 4248 || t == unsigned_char_type_node) 4249 return 0; 4250 4251 /* The C standard specifically allows aliasing between signed and 4252 unsigned variants of the same type. We treat the signed 4253 variant as canonical. */ 4254 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t)) 4255 { 4256 tree t1 = c_common_signed_type (t); 4257 4258 /* t1 == t can happen for boolean nodes which are always unsigned. */ 4259 if (t1 != t) 4260 return get_alias_set (t1); 4261 } 4262 else if (POINTER_TYPE_P (t)) 4263 { 4264 tree t1; 4265 4266 /* Unfortunately, there is no canonical form of a pointer type. 4267 In particular, if we have `typedef int I', then `int *', and 4268 `I *' are different types. So, we have to pick a canonical 4269 representative. We do this below. 4270 4271 Technically, this approach is actually more conservative that 4272 it needs to be. In particular, `const int *' and `int *' 4273 should be in different alias sets, according to the C and C++ 4274 standard, since their types are not the same, and so, 4275 technically, an `int **' and `const int **' cannot point at 4276 the same thing. 4277 4278 But, the standard is wrong. In particular, this code is 4279 legal C++: 4280 4281 int *ip; 4282 int **ipp = &ip; 4283 const int* const* cipp = ipp; 4284 4285 And, it doesn't make sense for that to be legal unless you 4286 can dereference IPP and CIPP. So, we ignore cv-qualifiers on 4287 the pointed-to types. This issue has been reported to the 4288 C++ committee. */ 4289 t1 = build_type_no_quals (t); 4290 if (t1 != t) 4291 return get_alias_set (t1); 4292 } 4293 4294 /* Handle the case of multiple type nodes referring to "the same" type, 4295 which occurs with IMA. These share an alias set. FIXME: Currently only 4296 C90 is handled. (In C99 type compatibility is not transitive, which 4297 complicates things mightily. The alias set splay trees can theoretically 4298 represent this, but insertion is tricky when you consider all the 4299 different orders things might arrive in.) */ 4300 4301 if (c_language != clk_c || flag_isoc99) 4302 return -1; 4303 4304 /* Save time if there's only one input file. */ 4305 if (num_in_fnames == 1) 4306 return -1; 4307 4308 /* Pointers need special handling if they point to any type that 4309 needs special handling (below). */ 4310 if (TREE_CODE (t) == POINTER_TYPE) 4311 { 4312 tree t2; 4313 /* Find bottom type under any nested POINTERs. */ 4314 for (t2 = TREE_TYPE (t); 4315 TREE_CODE (t2) == POINTER_TYPE; 4316 t2 = TREE_TYPE (t2)) 4317 ; 4318 if (TREE_CODE (t2) != RECORD_TYPE 4319 && TREE_CODE (t2) != ENUMERAL_TYPE 4320 && TREE_CODE (t2) != QUAL_UNION_TYPE 4321 && TREE_CODE (t2) != UNION_TYPE) 4322 return -1; 4323 if (TYPE_SIZE (t2) == 0) 4324 return -1; 4325 } 4326 /* These are the only cases that need special handling. */ 4327 if (TREE_CODE (t) != RECORD_TYPE 4328 && TREE_CODE (t) != ENUMERAL_TYPE 4329 && TREE_CODE (t) != QUAL_UNION_TYPE 4330 && TREE_CODE (t) != UNION_TYPE 4331 && TREE_CODE (t) != POINTER_TYPE) 4332 return -1; 4333 /* Undefined? */ 4334 if (TYPE_SIZE (t) == 0) 4335 return -1; 4336 4337 /* Look up t in hash table. Only one of the compatible types within each 4338 alias set is recorded in the table. */ 4339 if (!type_hash_table) 4340 type_hash_table = htab_create_ggc (1021, c_type_hash, 4341 (htab_eq) lang_hooks.types_compatible_p, 4342 NULL); 4343 slot = htab_find_slot (type_hash_table, t, INSERT); 4344 if (*slot != NULL) 4345 { 4346 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot); 4347 return TYPE_ALIAS_SET ((tree)*slot); 4348 } 4349 else 4350 /* Our caller will assign and record (in t) a new alias set; all we need 4351 to do is remember t in the hash table. */ 4352 *slot = t; 4353 4354 return -1; 4355} 4356 4357/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where 4358 the second parameter indicates which OPERATOR is being applied. 4359 The COMPLAIN flag controls whether we should diagnose possibly 4360 ill-formed constructs or not. LOC is the location of the SIZEOF or 4361 TYPEOF operator. */ 4362 4363tree 4364c_sizeof_or_alignof_type (location_t loc, 4365 tree type, bool is_sizeof, int complain) 4366{ 4367 const char *op_name; 4368 tree value = NULL; 4369 enum tree_code type_code = TREE_CODE (type); 4370 4371 op_name = is_sizeof ? "sizeof" : "__alignof__"; 4372 4373 if (type_code == FUNCTION_TYPE) 4374 { 4375 if (is_sizeof) 4376 { 4377 if (complain && (pedantic || warn_pointer_arith)) 4378 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 4379 "invalid application of %<sizeof%> to a function type"); 4380 else if (!complain) 4381 return error_mark_node; 4382 value = size_one_node; 4383 } 4384 else 4385 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); 4386 } 4387 else if (type_code == VOID_TYPE || type_code == ERROR_MARK) 4388 { 4389 if (type_code == VOID_TYPE 4390 && complain && (pedantic || warn_pointer_arith)) 4391 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 4392 "invalid application of %qs to a void type", op_name); 4393 else if (!complain) 4394 return error_mark_node; 4395 value = size_one_node; 4396 } 4397 else if (!COMPLETE_TYPE_P (type)) 4398 { 4399 if (complain) 4400 error_at (loc, "invalid application of %qs to incomplete type %qT ", 4401 op_name, type); 4402 value = size_zero_node; 4403 } 4404 else 4405 { 4406 if (is_sizeof) 4407 /* Convert in case a char is more than one unit. */ 4408 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 4409 size_int (TYPE_PRECISION (char_type_node) 4410 / BITS_PER_UNIT)); 4411 else 4412 value = size_int (TYPE_ALIGN_UNIT (type)); 4413 } 4414 4415 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set. 4416 TYPE_IS_SIZETYPE means that certain things (like overflow) will 4417 never happen. However, this node should really have type 4418 `size_t', which is just a typedef for an ordinary integer type. */ 4419 value = fold_convert_loc (loc, size_type_node, value); 4420 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value))); 4421 4422 return value; 4423} 4424 4425/* Implement the __alignof keyword: Return the minimum required 4426 alignment of EXPR, measured in bytes. For VAR_DECLs, 4427 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set 4428 from an "aligned" __attribute__ specification). LOC is the 4429 location of the ALIGNOF operator. */ 4430 4431tree 4432c_alignof_expr (location_t loc, tree expr) 4433{ 4434 tree t; 4435 4436 if (VAR_OR_FUNCTION_DECL_P (expr)) 4437 t = size_int (DECL_ALIGN_UNIT (expr)); 4438 4439 else if (TREE_CODE (expr) == COMPONENT_REF 4440 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1))) 4441 { 4442 error_at (loc, "%<__alignof%> applied to a bit-field"); 4443 t = size_one_node; 4444 } 4445 else if (TREE_CODE (expr) == COMPONENT_REF 4446 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL) 4447 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1))); 4448 4449 else if (TREE_CODE (expr) == INDIRECT_REF) 4450 { 4451 tree t = TREE_OPERAND (expr, 0); 4452 tree best = t; 4453 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 4454 4455 while (CONVERT_EXPR_P (t) 4456 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) 4457 { 4458 int thisalign; 4459 4460 t = TREE_OPERAND (t, 0); 4461 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 4462 if (thisalign > bestalign) 4463 best = t, bestalign = thisalign; 4464 } 4465 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best))); 4466 } 4467 else 4468 return c_alignof (loc, TREE_TYPE (expr)); 4469 4470 return fold_convert_loc (loc, size_type_node, t); 4471} 4472 4473/* Handle C and C++ default attributes. */ 4474 4475enum built_in_attribute 4476{ 4477#define DEF_ATTR_NULL_TREE(ENUM) ENUM, 4478#define DEF_ATTR_INT(ENUM, VALUE) ENUM, 4479#define DEF_ATTR_IDENT(ENUM, STRING) ENUM, 4480#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM, 4481#include "builtin-attrs.def" 4482#undef DEF_ATTR_NULL_TREE 4483#undef DEF_ATTR_INT 4484#undef DEF_ATTR_IDENT 4485#undef DEF_ATTR_TREE_LIST 4486 ATTR_LAST 4487}; 4488 4489static GTY(()) tree built_in_attributes[(int) ATTR_LAST]; 4490 4491static void c_init_attributes (void); 4492 4493enum c_builtin_type 4494{ 4495#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME, 4496#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME, 4497#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME, 4498#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME, 4499#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 4500#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 4501#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME, 4502#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME, 4503#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME, 4504#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME, 4505#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME, 4506#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME, 4507#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 4508#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 4509#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \ 4510 NAME, 4511#define DEF_POINTER_TYPE(NAME, TYPE) NAME, 4512#include "builtin-types.def" 4513#undef DEF_PRIMITIVE_TYPE 4514#undef DEF_FUNCTION_TYPE_0 4515#undef DEF_FUNCTION_TYPE_1 4516#undef DEF_FUNCTION_TYPE_2 4517#undef DEF_FUNCTION_TYPE_3 4518#undef DEF_FUNCTION_TYPE_4 4519#undef DEF_FUNCTION_TYPE_5 4520#undef DEF_FUNCTION_TYPE_6 4521#undef DEF_FUNCTION_TYPE_7 4522#undef DEF_FUNCTION_TYPE_VAR_0 4523#undef DEF_FUNCTION_TYPE_VAR_1 4524#undef DEF_FUNCTION_TYPE_VAR_2 4525#undef DEF_FUNCTION_TYPE_VAR_3 4526#undef DEF_FUNCTION_TYPE_VAR_4 4527#undef DEF_FUNCTION_TYPE_VAR_5 4528#undef DEF_POINTER_TYPE 4529 BT_LAST 4530}; 4531 4532typedef enum c_builtin_type builtin_type; 4533 4534/* A temporary array for c_common_nodes_and_builtins. Used in 4535 communication with def_fn_type. */ 4536static tree builtin_types[(int) BT_LAST + 1]; 4537 4538/* A helper function for c_common_nodes_and_builtins. Build function type 4539 for DEF with return type RET and N arguments. If VAR is true, then the 4540 function should be variadic after those N arguments. 4541 4542 Takes special care not to ICE if any of the types involved are 4543 error_mark_node, which indicates that said type is not in fact available 4544 (see builtin_type_for_size). In which case the function type as a whole 4545 should be error_mark_node. */ 4546 4547static void 4548def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...) 4549{ 4550 tree args = NULL, t; 4551 va_list list; 4552 int i; 4553 4554 va_start (list, n); 4555 for (i = 0; i < n; ++i) 4556 { 4557 builtin_type a = (builtin_type) va_arg (list, int); 4558 t = builtin_types[a]; 4559 if (t == error_mark_node) 4560 goto egress; 4561 args = tree_cons (NULL_TREE, t, args); 4562 } 4563 va_end (list); 4564 4565 args = nreverse (args); 4566 if (!var) 4567 args = chainon (args, void_list_node); 4568 4569 t = builtin_types[ret]; 4570 if (t == error_mark_node) 4571 goto egress; 4572 t = build_function_type (t, args); 4573 4574 egress: 4575 builtin_types[def] = t; 4576} 4577 4578/* Build builtin functions common to both C and C++ language 4579 frontends. */ 4580 4581static void 4582c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node) 4583{ 4584#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \ 4585 builtin_types[ENUM] = VALUE; 4586#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \ 4587 def_fn_type (ENUM, RETURN, 0, 0); 4588#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \ 4589 def_fn_type (ENUM, RETURN, 0, 1, ARG1); 4590#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \ 4591 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2); 4592#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 4593 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3); 4594#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 4595 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4); 4596#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 4597 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 4598#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 4599 ARG6) \ 4600 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 4601#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 4602 ARG6, ARG7) \ 4603 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7); 4604#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \ 4605 def_fn_type (ENUM, RETURN, 1, 0); 4606#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \ 4607 def_fn_type (ENUM, RETURN, 1, 1, ARG1); 4608#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \ 4609 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2); 4610#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 4611 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3); 4612#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 4613 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4); 4614#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 4615 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 4616#define DEF_POINTER_TYPE(ENUM, TYPE) \ 4617 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]); 4618 4619#include "builtin-types.def" 4620 4621#undef DEF_PRIMITIVE_TYPE 4622#undef DEF_FUNCTION_TYPE_1 4623#undef DEF_FUNCTION_TYPE_2 4624#undef DEF_FUNCTION_TYPE_3 4625#undef DEF_FUNCTION_TYPE_4 4626#undef DEF_FUNCTION_TYPE_5 4627#undef DEF_FUNCTION_TYPE_6 4628#undef DEF_FUNCTION_TYPE_VAR_0 4629#undef DEF_FUNCTION_TYPE_VAR_1 4630#undef DEF_FUNCTION_TYPE_VAR_2 4631#undef DEF_FUNCTION_TYPE_VAR_3 4632#undef DEF_FUNCTION_TYPE_VAR_4 4633#undef DEF_FUNCTION_TYPE_VAR_5 4634#undef DEF_POINTER_TYPE 4635 builtin_types[(int) BT_LAST] = NULL_TREE; 4636 4637 c_init_attributes (); 4638 4639#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \ 4640 NONANSI_P, ATTRS, IMPLICIT, COND) \ 4641 if (NAME && COND) \ 4642 def_builtin_1 (ENUM, NAME, CLASS, \ 4643 builtin_types[(int) TYPE], \ 4644 builtin_types[(int) LIBTYPE], \ 4645 BOTH_P, FALLBACK_P, NONANSI_P, \ 4646 built_in_attributes[(int) ATTRS], IMPLICIT); 4647#include "builtins.def" 4648#undef DEF_BUILTIN 4649 4650 targetm.init_builtins (); 4651 4652 build_common_builtin_nodes (); 4653 4654 if (flag_mudflap) 4655 mudflap_init (); 4656} 4657 4658/* Like get_identifier, but avoid warnings about null arguments when 4659 the argument may be NULL for targets where GCC lacks stdint.h type 4660 information. */ 4661 4662static inline tree 4663c_get_ident (const char *id) 4664{ 4665 return get_identifier (id); 4666} 4667 4668/* Build tree nodes and builtin functions common to both C and C++ language 4669 frontends. */ 4670 4671void 4672c_common_nodes_and_builtins (void) 4673{ 4674 int char16_type_size; 4675 int char32_type_size; 4676 int wchar_type_size; 4677 tree array_domain_type; 4678 tree va_list_ref_type_node; 4679 tree va_list_arg_type_node; 4680 4681 /* Define `int' and `char' first so that dbx will output them first. */ 4682 record_builtin_type (RID_INT, NULL, integer_type_node); 4683 record_builtin_type (RID_CHAR, "char", char_type_node); 4684 4685 /* `signed' is the same as `int'. FIXME: the declarations of "signed", 4686 "unsigned long", "long long unsigned" and "unsigned short" were in C++ 4687 but not C. Are the conditionals here needed? */ 4688 if (c_dialect_cxx ()) 4689 record_builtin_type (RID_SIGNED, NULL, integer_type_node); 4690 record_builtin_type (RID_LONG, "long int", long_integer_type_node); 4691 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node); 4692 record_builtin_type (RID_MAX, "long unsigned int", 4693 long_unsigned_type_node); 4694 if (c_dialect_cxx ()) 4695 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node); 4696 record_builtin_type (RID_MAX, "long long int", 4697 long_long_integer_type_node); 4698 record_builtin_type (RID_MAX, "long long unsigned int", 4699 long_long_unsigned_type_node); 4700 if (c_dialect_cxx ()) 4701 record_builtin_type (RID_MAX, "long long unsigned", 4702 long_long_unsigned_type_node); 4703 record_builtin_type (RID_SHORT, "short int", short_integer_type_node); 4704 record_builtin_type (RID_MAX, "short unsigned int", 4705 short_unsigned_type_node); 4706 if (c_dialect_cxx ()) 4707 record_builtin_type (RID_MAX, "unsigned short", 4708 short_unsigned_type_node); 4709 4710 /* Define both `signed char' and `unsigned char'. */ 4711 record_builtin_type (RID_MAX, "signed char", signed_char_type_node); 4712 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node); 4713 4714 /* These are types that c_common_type_for_size and 4715 c_common_type_for_mode use. */ 4716 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4717 TYPE_DECL, NULL_TREE, 4718 intQI_type_node)); 4719 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4720 TYPE_DECL, NULL_TREE, 4721 intHI_type_node)); 4722 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4723 TYPE_DECL, NULL_TREE, 4724 intSI_type_node)); 4725 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4726 TYPE_DECL, NULL_TREE, 4727 intDI_type_node)); 4728#if HOST_BITS_PER_WIDE_INT >= 64 4729 if (targetm.scalar_mode_supported_p (TImode)) 4730 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4731 TYPE_DECL, 4732 get_identifier ("__int128_t"), 4733 intTI_type_node)); 4734#endif 4735 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4736 TYPE_DECL, NULL_TREE, 4737 unsigned_intQI_type_node)); 4738 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4739 TYPE_DECL, NULL_TREE, 4740 unsigned_intHI_type_node)); 4741 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4742 TYPE_DECL, NULL_TREE, 4743 unsigned_intSI_type_node)); 4744 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4745 TYPE_DECL, NULL_TREE, 4746 unsigned_intDI_type_node)); 4747#if HOST_BITS_PER_WIDE_INT >= 64 4748 if (targetm.scalar_mode_supported_p (TImode)) 4749 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4750 TYPE_DECL, 4751 get_identifier ("__uint128_t"), 4752 unsigned_intTI_type_node)); 4753#endif 4754 4755 /* Create the widest literal types. */ 4756 widest_integer_literal_type_node 4757 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2); 4758 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4759 TYPE_DECL, NULL_TREE, 4760 widest_integer_literal_type_node)); 4761 4762 widest_unsigned_literal_type_node 4763 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2); 4764 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4765 TYPE_DECL, NULL_TREE, 4766 widest_unsigned_literal_type_node)); 4767 4768 /* `unsigned long' is the standard type for sizeof. 4769 Note that stddef.h uses `unsigned long', 4770 and this must agree, even if long and int are the same size. */ 4771 size_type_node = 4772 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE))); 4773 signed_size_type_node = c_common_signed_type (size_type_node); 4774 set_sizetype (size_type_node); 4775 4776 pid_type_node = 4777 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE))); 4778 4779 build_common_tree_nodes_2 (flag_short_double); 4780 4781 record_builtin_type (RID_FLOAT, NULL, float_type_node); 4782 record_builtin_type (RID_DOUBLE, NULL, double_type_node); 4783 record_builtin_type (RID_MAX, "long double", long_double_type_node); 4784 4785 /* Only supported decimal floating point extension if the target 4786 actually supports underlying modes. */ 4787 if (targetm.scalar_mode_supported_p (SDmode) 4788 && targetm.scalar_mode_supported_p (DDmode) 4789 && targetm.scalar_mode_supported_p (TDmode)) 4790 { 4791 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node); 4792 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node); 4793 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node); 4794 } 4795 4796 if (targetm.fixed_point_supported_p ()) 4797 { 4798 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node); 4799 record_builtin_type (RID_FRACT, NULL, fract_type_node); 4800 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node); 4801 record_builtin_type (RID_MAX, "long long _Fract", 4802 long_long_fract_type_node); 4803 record_builtin_type (RID_MAX, "unsigned short _Fract", 4804 unsigned_short_fract_type_node); 4805 record_builtin_type (RID_MAX, "unsigned _Fract", 4806 unsigned_fract_type_node); 4807 record_builtin_type (RID_MAX, "unsigned long _Fract", 4808 unsigned_long_fract_type_node); 4809 record_builtin_type (RID_MAX, "unsigned long long _Fract", 4810 unsigned_long_long_fract_type_node); 4811 record_builtin_type (RID_MAX, "_Sat short _Fract", 4812 sat_short_fract_type_node); 4813 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node); 4814 record_builtin_type (RID_MAX, "_Sat long _Fract", 4815 sat_long_fract_type_node); 4816 record_builtin_type (RID_MAX, "_Sat long long _Fract", 4817 sat_long_long_fract_type_node); 4818 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract", 4819 sat_unsigned_short_fract_type_node); 4820 record_builtin_type (RID_MAX, "_Sat unsigned _Fract", 4821 sat_unsigned_fract_type_node); 4822 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract", 4823 sat_unsigned_long_fract_type_node); 4824 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract", 4825 sat_unsigned_long_long_fract_type_node); 4826 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node); 4827 record_builtin_type (RID_ACCUM, NULL, accum_type_node); 4828 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node); 4829 record_builtin_type (RID_MAX, "long long _Accum", 4830 long_long_accum_type_node); 4831 record_builtin_type (RID_MAX, "unsigned short _Accum", 4832 unsigned_short_accum_type_node); 4833 record_builtin_type (RID_MAX, "unsigned _Accum", 4834 unsigned_accum_type_node); 4835 record_builtin_type (RID_MAX, "unsigned long _Accum", 4836 unsigned_long_accum_type_node); 4837 record_builtin_type (RID_MAX, "unsigned long long _Accum", 4838 unsigned_long_long_accum_type_node); 4839 record_builtin_type (RID_MAX, "_Sat short _Accum", 4840 sat_short_accum_type_node); 4841 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node); 4842 record_builtin_type (RID_MAX, "_Sat long _Accum", 4843 sat_long_accum_type_node); 4844 record_builtin_type (RID_MAX, "_Sat long long _Accum", 4845 sat_long_long_accum_type_node); 4846 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum", 4847 sat_unsigned_short_accum_type_node); 4848 record_builtin_type (RID_MAX, "_Sat unsigned _Accum", 4849 sat_unsigned_accum_type_node); 4850 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum", 4851 sat_unsigned_long_accum_type_node); 4852 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum", 4853 sat_unsigned_long_long_accum_type_node); 4854 4855 } 4856 4857 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4858 TYPE_DECL, 4859 get_identifier ("complex int"), 4860 complex_integer_type_node)); 4861 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4862 TYPE_DECL, 4863 get_identifier ("complex float"), 4864 complex_float_type_node)); 4865 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4866 TYPE_DECL, 4867 get_identifier ("complex double"), 4868 complex_double_type_node)); 4869 lang_hooks.decls.pushdecl 4870 (build_decl (UNKNOWN_LOCATION, 4871 TYPE_DECL, get_identifier ("complex long double"), 4872 complex_long_double_type_node)); 4873 4874 if (c_dialect_cxx ()) 4875 /* For C++, make fileptr_type_node a distinct void * type until 4876 FILE type is defined. */ 4877 fileptr_type_node = build_variant_type_copy (ptr_type_node); 4878 4879 record_builtin_type (RID_VOID, NULL, void_type_node); 4880 4881 /* Set the TYPE_NAME for any variants that were built before 4882 record_builtin_type gave names to the built-in types. */ 4883 { 4884 tree void_name = TYPE_NAME (void_type_node); 4885 TYPE_NAME (void_type_node) = NULL_TREE; 4886 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST)) 4887 = void_name; 4888 TYPE_NAME (void_type_node) = void_name; 4889 } 4890 4891 /* This node must not be shared. */ 4892 void_zero_node = make_node (INTEGER_CST); 4893 TREE_TYPE (void_zero_node) = void_type_node; 4894 4895 void_list_node = build_void_list_node (); 4896 4897 /* Make a type to be the domain of a few array types 4898 whose domains don't really matter. 4899 200 is small enough that it always fits in size_t 4900 and large enough that it can hold most function names for the 4901 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */ 4902 array_domain_type = build_index_type (size_int (200)); 4903 4904 /* Make a type for arrays of characters. 4905 With luck nothing will ever really depend on the length of this 4906 array type. */ 4907 char_array_type_node 4908 = build_array_type (char_type_node, array_domain_type); 4909 4910 /* Likewise for arrays of ints. */ 4911 int_array_type_node 4912 = build_array_type (integer_type_node, array_domain_type); 4913 4914 string_type_node = build_pointer_type (char_type_node); 4915 const_string_type_node 4916 = build_pointer_type (build_qualified_type 4917 (char_type_node, TYPE_QUAL_CONST)); 4918 4919 /* This is special for C++ so functions can be overloaded. */ 4920 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE); 4921 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node)); 4922 wchar_type_size = TYPE_PRECISION (wchar_type_node); 4923 underlying_wchar_type_node = wchar_type_node; 4924 if (c_dialect_cxx ()) 4925 { 4926 if (TYPE_UNSIGNED (wchar_type_node)) 4927 wchar_type_node = make_unsigned_type (wchar_type_size); 4928 else 4929 wchar_type_node = make_signed_type (wchar_type_size); 4930 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node); 4931 } 4932 4933 /* This is for wide string constants. */ 4934 wchar_array_type_node 4935 = build_array_type (wchar_type_node, array_domain_type); 4936 4937 /* Define 'char16_t'. */ 4938 char16_type_node = get_identifier (CHAR16_TYPE); 4939 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node)); 4940 char16_type_size = TYPE_PRECISION (char16_type_node); 4941 if (c_dialect_cxx ()) 4942 { 4943 char16_type_node = make_unsigned_type (char16_type_size); 4944 4945 if (cxx_dialect == cxx0x) 4946 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node); 4947 } 4948 4949 /* This is for UTF-16 string constants. */ 4950 char16_array_type_node 4951 = build_array_type (char16_type_node, array_domain_type); 4952 4953 /* Define 'char32_t'. */ 4954 char32_type_node = get_identifier (CHAR32_TYPE); 4955 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node)); 4956 char32_type_size = TYPE_PRECISION (char32_type_node); 4957 if (c_dialect_cxx ()) 4958 { 4959 char32_type_node = make_unsigned_type (char32_type_size); 4960 4961 if (cxx_dialect == cxx0x) 4962 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node); 4963 } 4964 4965 /* This is for UTF-32 string constants. */ 4966 char32_array_type_node 4967 = build_array_type (char32_type_node, array_domain_type); 4968 4969 wint_type_node = 4970 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE))); 4971 4972 intmax_type_node = 4973 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE))); 4974 uintmax_type_node = 4975 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE))); 4976 4977 if (SIG_ATOMIC_TYPE) 4978 sig_atomic_type_node = 4979 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE))); 4980 if (INT8_TYPE) 4981 int8_type_node = 4982 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE))); 4983 if (INT16_TYPE) 4984 int16_type_node = 4985 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE))); 4986 if (INT32_TYPE) 4987 int32_type_node = 4988 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE))); 4989 if (INT64_TYPE) 4990 int64_type_node = 4991 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE))); 4992 if (UINT8_TYPE) 4993 uint8_type_node = 4994 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE))); 4995 if (UINT16_TYPE) 4996 uint16_type_node = 4997 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE))); 4998 if (UINT32_TYPE) 4999 c_uint32_type_node = 5000 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE))); 5001 if (UINT64_TYPE) 5002 c_uint64_type_node = 5003 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE))); 5004 if (INT_LEAST8_TYPE) 5005 int_least8_type_node = 5006 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE))); 5007 if (INT_LEAST16_TYPE) 5008 int_least16_type_node = 5009 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE))); 5010 if (INT_LEAST32_TYPE) 5011 int_least32_type_node = 5012 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE))); 5013 if (INT_LEAST64_TYPE) 5014 int_least64_type_node = 5015 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE))); 5016 if (UINT_LEAST8_TYPE) 5017 uint_least8_type_node = 5018 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE))); 5019 if (UINT_LEAST16_TYPE) 5020 uint_least16_type_node = 5021 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE))); 5022 if (UINT_LEAST32_TYPE) 5023 uint_least32_type_node = 5024 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE))); 5025 if (UINT_LEAST64_TYPE) 5026 uint_least64_type_node = 5027 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE))); 5028 if (INT_FAST8_TYPE) 5029 int_fast8_type_node = 5030 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE))); 5031 if (INT_FAST16_TYPE) 5032 int_fast16_type_node = 5033 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE))); 5034 if (INT_FAST32_TYPE) 5035 int_fast32_type_node = 5036 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE))); 5037 if (INT_FAST64_TYPE) 5038 int_fast64_type_node = 5039 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE))); 5040 if (UINT_FAST8_TYPE) 5041 uint_fast8_type_node = 5042 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE))); 5043 if (UINT_FAST16_TYPE) 5044 uint_fast16_type_node = 5045 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE))); 5046 if (UINT_FAST32_TYPE) 5047 uint_fast32_type_node = 5048 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE))); 5049 if (UINT_FAST64_TYPE) 5050 uint_fast64_type_node = 5051 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE))); 5052 if (INTPTR_TYPE) 5053 intptr_type_node = 5054 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE))); 5055 if (UINTPTR_TYPE) 5056 uintptr_type_node = 5057 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE))); 5058 5059 default_function_type = build_function_type (integer_type_node, NULL_TREE); 5060 ptrdiff_type_node 5061 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE))); 5062 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node); 5063 5064 lang_hooks.decls.pushdecl 5065 (build_decl (UNKNOWN_LOCATION, 5066 TYPE_DECL, get_identifier ("__builtin_va_list"), 5067 va_list_type_node)); 5068#ifdef TARGET_ENUM_VA_LIST 5069 { 5070 int l; 5071 const char *pname; 5072 tree ptype; 5073 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l) 5074 { 5075 lang_hooks.decls.pushdecl 5076 (build_decl (UNKNOWN_LOCATION, 5077 TYPE_DECL, get_identifier (pname), 5078 ptype)); 5079 5080 } 5081 } 5082#endif 5083 5084 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE) 5085 { 5086 va_list_arg_type_node = va_list_ref_type_node = 5087 build_pointer_type (TREE_TYPE (va_list_type_node)); 5088 } 5089 else 5090 { 5091 va_list_arg_type_node = va_list_type_node; 5092 va_list_ref_type_node = build_reference_type (va_list_type_node); 5093 } 5094 5095 if (!flag_preprocess_only) 5096 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node); 5097 5098 main_identifier_node = get_identifier ("main"); 5099 5100 /* Create the built-in __null node. It is important that this is 5101 not shared. */ 5102 null_node = make_node (INTEGER_CST); 5103 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); 5104 5105 /* Since builtin_types isn't gc'ed, don't export these nodes. */ 5106 memset (builtin_types, 0, sizeof (builtin_types)); 5107} 5108 5109/* The number of named compound-literals generated thus far. */ 5110static GTY(()) int compound_literal_number; 5111 5112/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */ 5113 5114void 5115set_compound_literal_name (tree decl) 5116{ 5117 char *name; 5118 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", 5119 compound_literal_number); 5120 compound_literal_number++; 5121 DECL_NAME (decl) = get_identifier (name); 5122} 5123 5124tree 5125build_va_arg (location_t loc, tree expr, tree type) 5126{ 5127 expr = build1 (VA_ARG_EXPR, type, expr); 5128 SET_EXPR_LOCATION (expr, loc); 5129 return expr; 5130} 5131 5132 5133/* Linked list of disabled built-in functions. */ 5134 5135typedef struct disabled_builtin 5136{ 5137 const char *name; 5138 struct disabled_builtin *next; 5139} disabled_builtin; 5140static disabled_builtin *disabled_builtins = NULL; 5141 5142static bool builtin_function_disabled_p (const char *); 5143 5144/* Disable a built-in function specified by -fno-builtin-NAME. If NAME 5145 begins with "__builtin_", give an error. */ 5146 5147void 5148disable_builtin_function (const char *name) 5149{ 5150 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0) 5151 error ("cannot disable built-in function %qs", name); 5152 else 5153 { 5154 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin); 5155 new_disabled_builtin->name = name; 5156 new_disabled_builtin->next = disabled_builtins; 5157 disabled_builtins = new_disabled_builtin; 5158 } 5159} 5160 5161 5162/* Return true if the built-in function NAME has been disabled, false 5163 otherwise. */ 5164 5165static bool 5166builtin_function_disabled_p (const char *name) 5167{ 5168 disabled_builtin *p; 5169 for (p = disabled_builtins; p != NULL; p = p->next) 5170 { 5171 if (strcmp (name, p->name) == 0) 5172 return true; 5173 } 5174 return false; 5175} 5176 5177 5178/* Worker for DEF_BUILTIN. 5179 Possibly define a builtin function with one or two names. 5180 Does not declare a non-__builtin_ function if flag_no_builtin, or if 5181 nonansi_p and flag_no_nonansi_builtin. */ 5182 5183static void 5184def_builtin_1 (enum built_in_function fncode, 5185 const char *name, 5186 enum built_in_class fnclass, 5187 tree fntype, tree libtype, 5188 bool both_p, bool fallback_p, bool nonansi_p, 5189 tree fnattrs, bool implicit_p) 5190{ 5191 tree decl; 5192 const char *libname; 5193 5194 if (fntype == error_mark_node) 5195 return; 5196 5197 gcc_assert ((!both_p && !fallback_p) 5198 || !strncmp (name, "__builtin_", 5199 strlen ("__builtin_"))); 5200 5201 libname = name + strlen ("__builtin_"); 5202 decl = add_builtin_function (name, fntype, fncode, fnclass, 5203 (fallback_p ? libname : NULL), 5204 fnattrs); 5205 if (both_p 5206 && !flag_no_builtin && !builtin_function_disabled_p (libname) 5207 && !(nonansi_p && flag_no_nonansi_builtin)) 5208 add_builtin_function (libname, libtype, fncode, fnclass, 5209 NULL, fnattrs); 5210 5211 built_in_decls[(int) fncode] = decl; 5212 if (implicit_p) 5213 implicit_built_in_decls[(int) fncode] = decl; 5214} 5215 5216/* Nonzero if the type T promotes to int. This is (nearly) the 5217 integral promotions defined in ISO C99 6.3.1.1/2. */ 5218 5219bool 5220c_promoting_integer_type_p (const_tree t) 5221{ 5222 switch (TREE_CODE (t)) 5223 { 5224 case INTEGER_TYPE: 5225 return (TYPE_MAIN_VARIANT (t) == char_type_node 5226 || TYPE_MAIN_VARIANT (t) == signed_char_type_node 5227 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node 5228 || TYPE_MAIN_VARIANT (t) == short_integer_type_node 5229 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node 5230 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node)); 5231 5232 case ENUMERAL_TYPE: 5233 /* ??? Technically all enumerations not larger than an int 5234 promote to an int. But this is used along code paths 5235 that only want to notice a size change. */ 5236 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node); 5237 5238 case BOOLEAN_TYPE: 5239 return 1; 5240 5241 default: 5242 return 0; 5243 } 5244} 5245 5246/* Return 1 if PARMS specifies a fixed number of parameters 5247 and none of their types is affected by default promotions. */ 5248 5249int 5250self_promoting_args_p (const_tree parms) 5251{ 5252 const_tree t; 5253 for (t = parms; t; t = TREE_CHAIN (t)) 5254 { 5255 tree type = TREE_VALUE (t); 5256 5257 if (type == error_mark_node) 5258 continue; 5259 5260 if (TREE_CHAIN (t) == 0 && type != void_type_node) 5261 return 0; 5262 5263 if (type == 0) 5264 return 0; 5265 5266 if (TYPE_MAIN_VARIANT (type) == float_type_node) 5267 return 0; 5268 5269 if (c_promoting_integer_type_p (type)) 5270 return 0; 5271 } 5272 return 1; 5273} 5274 5275/* Recursively remove any '*' or '&' operator from TYPE. */ 5276tree 5277strip_pointer_operator (tree t) 5278{ 5279 while (POINTER_TYPE_P (t)) 5280 t = TREE_TYPE (t); 5281 return t; 5282} 5283 5284/* Recursively remove pointer or array type from TYPE. */ 5285tree 5286strip_pointer_or_array_types (tree t) 5287{ 5288 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t)) 5289 t = TREE_TYPE (t); 5290 return t; 5291} 5292 5293/* Used to compare case labels. K1 and K2 are actually tree nodes 5294 representing case labels, or NULL_TREE for a `default' label. 5295 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after 5296 K2, and 0 if K1 and K2 are equal. */ 5297 5298int 5299case_compare (splay_tree_key k1, splay_tree_key k2) 5300{ 5301 /* Consider a NULL key (such as arises with a `default' label) to be 5302 smaller than anything else. */ 5303 if (!k1) 5304 return k2 ? -1 : 0; 5305 else if (!k2) 5306 return k1 ? 1 : 0; 5307 5308 return tree_int_cst_compare ((tree) k1, (tree) k2); 5309} 5310 5311/* Process a case label, located at LOC, for the range LOW_VALUE 5312 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE 5313 then this case label is actually a `default' label. If only 5314 HIGH_VALUE is NULL_TREE, then case label was declared using the 5315 usual C/C++ syntax, rather than the GNU case range extension. 5316 CASES is a tree containing all the case ranges processed so far; 5317 COND is the condition for the switch-statement itself. Returns the 5318 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR 5319 is created. */ 5320 5321tree 5322c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type, 5323 tree low_value, tree high_value) 5324{ 5325 tree type; 5326 tree label; 5327 tree case_label; 5328 splay_tree_node node; 5329 5330 /* Create the LABEL_DECL itself. */ 5331 label = create_artificial_label (loc); 5332 5333 /* If there was an error processing the switch condition, bail now 5334 before we get more confused. */ 5335 if (!cond || cond == error_mark_node) 5336 goto error_out; 5337 5338 if ((low_value && TREE_TYPE (low_value) 5339 && POINTER_TYPE_P (TREE_TYPE (low_value))) 5340 || (high_value && TREE_TYPE (high_value) 5341 && POINTER_TYPE_P (TREE_TYPE (high_value)))) 5342 { 5343 error_at (loc, "pointers are not permitted as case values"); 5344 goto error_out; 5345 } 5346 5347 /* Case ranges are a GNU extension. */ 5348 if (high_value) 5349 pedwarn (loc, OPT_pedantic, 5350 "range expressions in switch statements are non-standard"); 5351 5352 type = TREE_TYPE (cond); 5353 if (low_value) 5354 { 5355 low_value = check_case_value (low_value); 5356 low_value = convert_and_check (type, low_value); 5357 if (low_value == error_mark_node) 5358 goto error_out; 5359 } 5360 if (high_value) 5361 { 5362 high_value = check_case_value (high_value); 5363 high_value = convert_and_check (type, high_value); 5364 if (high_value == error_mark_node) 5365 goto error_out; 5366 } 5367 5368 if (low_value && high_value) 5369 { 5370 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't 5371 really a case range, even though it was written that way. 5372 Remove the HIGH_VALUE to simplify later processing. */ 5373 if (tree_int_cst_equal (low_value, high_value)) 5374 high_value = NULL_TREE; 5375 else if (!tree_int_cst_lt (low_value, high_value)) 5376 warning_at (loc, 0, "empty range specified"); 5377 } 5378 5379 /* See if the case is in range of the type of the original testing 5380 expression. If both low_value and high_value are out of range, 5381 don't insert the case label and return NULL_TREE. */ 5382 if (low_value 5383 && !check_case_bounds (type, orig_type, 5384 &low_value, high_value ? &high_value : NULL)) 5385 return NULL_TREE; 5386 5387 /* Look up the LOW_VALUE in the table of case labels we already 5388 have. */ 5389 node = splay_tree_lookup (cases, (splay_tree_key) low_value); 5390 /* If there was not an exact match, check for overlapping ranges. 5391 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE; 5392 that's a `default' label and the only overlap is an exact match. */ 5393 if (!node && (low_value || high_value)) 5394 { 5395 splay_tree_node low_bound; 5396 splay_tree_node high_bound; 5397 5398 /* Even though there wasn't an exact match, there might be an 5399 overlap between this case range and another case range. 5400 Since we've (inductively) not allowed any overlapping case 5401 ranges, we simply need to find the greatest low case label 5402 that is smaller that LOW_VALUE, and the smallest low case 5403 label that is greater than LOW_VALUE. If there is an overlap 5404 it will occur in one of these two ranges. */ 5405 low_bound = splay_tree_predecessor (cases, 5406 (splay_tree_key) low_value); 5407 high_bound = splay_tree_successor (cases, 5408 (splay_tree_key) low_value); 5409 5410 /* Check to see if the LOW_BOUND overlaps. It is smaller than 5411 the LOW_VALUE, so there is no need to check unless the 5412 LOW_BOUND is in fact itself a case range. */ 5413 if (low_bound 5414 && CASE_HIGH ((tree) low_bound->value) 5415 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value), 5416 low_value) >= 0) 5417 node = low_bound; 5418 /* Check to see if the HIGH_BOUND overlaps. The low end of that 5419 range is bigger than the low end of the current range, so we 5420 are only interested if the current range is a real range, and 5421 not an ordinary case label. */ 5422 else if (high_bound 5423 && high_value 5424 && (tree_int_cst_compare ((tree) high_bound->key, 5425 high_value) 5426 <= 0)) 5427 node = high_bound; 5428 } 5429 /* If there was an overlap, issue an error. */ 5430 if (node) 5431 { 5432 tree duplicate = CASE_LABEL ((tree) node->value); 5433 5434 if (high_value) 5435 { 5436 error_at (loc, "duplicate (or overlapping) case value"); 5437 error_at (DECL_SOURCE_LOCATION (duplicate), 5438 "this is the first entry overlapping that value"); 5439 } 5440 else if (low_value) 5441 { 5442 error_at (loc, "duplicate case value") ; 5443 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here"); 5444 } 5445 else 5446 { 5447 error_at (loc, "multiple default labels in one switch"); 5448 error_at (DECL_SOURCE_LOCATION (duplicate), 5449 "this is the first default label"); 5450 } 5451 goto error_out; 5452 } 5453 5454 /* Add a CASE_LABEL to the statement-tree. */ 5455 case_label = add_stmt (build_case_label (loc, low_value, high_value, label)); 5456 /* Register this case label in the splay tree. */ 5457 splay_tree_insert (cases, 5458 (splay_tree_key) low_value, 5459 (splay_tree_value) case_label); 5460 5461 return case_label; 5462 5463 error_out: 5464 /* Add a label so that the back-end doesn't think that the beginning of 5465 the switch is unreachable. Note that we do not add a case label, as 5466 that just leads to duplicates and thence to failure later on. */ 5467 if (!cases->root) 5468 { 5469 tree t = create_artificial_label (loc); 5470 add_stmt (build_stmt (loc, LABEL_EXPR, t)); 5471 } 5472 return error_mark_node; 5473} 5474 5475/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach. 5476 Used to verify that case values match up with enumerator values. */ 5477 5478static void 5479match_case_to_enum_1 (tree key, tree type, tree label) 5480{ 5481 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1]; 5482 5483 /* ??? Not working too hard to print the double-word value. 5484 Should perhaps be done with %lwd in the diagnostic routines? */ 5485 if (TREE_INT_CST_HIGH (key) == 0) 5486 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED, 5487 TREE_INT_CST_LOW (key)); 5488 else if (!TYPE_UNSIGNED (type) 5489 && TREE_INT_CST_HIGH (key) == -1 5490 && TREE_INT_CST_LOW (key) != 0) 5491 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED, 5492 -TREE_INT_CST_LOW (key)); 5493 else 5494 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX, 5495 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key), 5496 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key)); 5497 5498 if (TYPE_NAME (type) == 0) 5499 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)), 5500 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum, 5501 "case value %qs not in enumerated type", 5502 buf); 5503 else 5504 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)), 5505 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum, 5506 "case value %qs not in enumerated type %qT", 5507 buf, type); 5508} 5509 5510/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach. 5511 Used to verify that case values match up with enumerator values. */ 5512 5513static int 5514match_case_to_enum (splay_tree_node node, void *data) 5515{ 5516 tree label = (tree) node->value; 5517 tree type = (tree) data; 5518 5519 /* Skip default case. */ 5520 if (!CASE_LOW (label)) 5521 return 0; 5522 5523 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear 5524 when we did our enum->case scan. Reset our scratch bit after. */ 5525 if (!CASE_LOW_SEEN (label)) 5526 match_case_to_enum_1 (CASE_LOW (label), type, label); 5527 else 5528 CASE_LOW_SEEN (label) = 0; 5529 5530 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is 5531 not set, that means that CASE_HIGH did not appear when we did our 5532 enum->case scan. Reset our scratch bit after. */ 5533 if (CASE_HIGH (label)) 5534 { 5535 if (!CASE_HIGH_SEEN (label)) 5536 match_case_to_enum_1 (CASE_HIGH (label), type, label); 5537 else 5538 CASE_HIGH_SEEN (label) = 0; 5539 } 5540 5541 return 0; 5542} 5543 5544/* Handle -Wswitch*. Called from the front end after parsing the 5545 switch construct. */ 5546/* ??? Should probably be somewhere generic, since other languages 5547 besides C and C++ would want this. At the moment, however, C/C++ 5548 are the only tree-ssa languages that support enumerations at all, 5549 so the point is moot. */ 5550 5551void 5552c_do_switch_warnings (splay_tree cases, location_t switch_location, 5553 tree type, tree cond) 5554{ 5555 splay_tree_node default_node; 5556 splay_tree_node node; 5557 tree chain; 5558 5559 if (!warn_switch && !warn_switch_enum && !warn_switch_default) 5560 return; 5561 5562 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL); 5563 if (!default_node) 5564 warning_at (switch_location, OPT_Wswitch_default, 5565 "switch missing default case"); 5566 5567 /* From here on, we only care about about enumerated types. */ 5568 if (!type || TREE_CODE (type) != ENUMERAL_TYPE) 5569 return; 5570 5571 /* From here on, we only care about -Wswitch and -Wswitch-enum. */ 5572 if (!warn_switch_enum && !warn_switch) 5573 return; 5574 5575 /* Check the cases. Warn about case values which are not members of 5576 the enumerated type. For -Wswitch-enum, or for -Wswitch when 5577 there is no default case, check that exactly all enumeration 5578 literals are covered by the cases. */ 5579 5580 /* Clearing COND if it is not an integer constant simplifies 5581 the tests inside the loop below. */ 5582 if (TREE_CODE (cond) != INTEGER_CST) 5583 cond = NULL_TREE; 5584 5585 /* The time complexity here is O(N*lg(N)) worst case, but for the 5586 common case of monotonically increasing enumerators, it is 5587 O(N), since the nature of the splay tree will keep the next 5588 element adjacent to the root at all times. */ 5589 5590 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain)) 5591 { 5592 tree value = TREE_VALUE (chain); 5593 if (TREE_CODE (value) == CONST_DECL) 5594 value = DECL_INITIAL (value); 5595 node = splay_tree_lookup (cases, (splay_tree_key) value); 5596 if (node) 5597 { 5598 /* Mark the CASE_LOW part of the case entry as seen. */ 5599 tree label = (tree) node->value; 5600 CASE_LOW_SEEN (label) = 1; 5601 continue; 5602 } 5603 5604 /* Even though there wasn't an exact match, there might be a 5605 case range which includes the enumerator's value. */ 5606 node = splay_tree_predecessor (cases, (splay_tree_key) value); 5607 if (node && CASE_HIGH ((tree) node->value)) 5608 { 5609 tree label = (tree) node->value; 5610 int cmp = tree_int_cst_compare (CASE_HIGH (label), value); 5611 if (cmp >= 0) 5612 { 5613 /* If we match the upper bound exactly, mark the CASE_HIGH 5614 part of the case entry as seen. */ 5615 if (cmp == 0) 5616 CASE_HIGH_SEEN (label) = 1; 5617 continue; 5618 } 5619 } 5620 5621 /* We've now determined that this enumerated literal isn't 5622 handled by the case labels of the switch statement. */ 5623 5624 /* If the switch expression is a constant, we only really care 5625 about whether that constant is handled by the switch. */ 5626 if (cond && tree_int_cst_compare (cond, value)) 5627 continue; 5628 5629 /* If there is a default_node, the only relevant option is 5630 Wswitch-enum. Otherwise, if both are enabled then we prefer 5631 to warn using -Wswitch because -Wswitch is enabled by -Wall 5632 while -Wswitch-enum is explicit. */ 5633 warning_at (switch_location, 5634 (default_node || !warn_switch 5635 ? OPT_Wswitch_enum 5636 : OPT_Wswitch), 5637 "enumeration value %qE not handled in switch", 5638 TREE_PURPOSE (chain)); 5639 } 5640 5641 /* Warn if there are case expressions that don't correspond to 5642 enumerators. This can occur since C and C++ don't enforce 5643 type-checking of assignments to enumeration variables. 5644 5645 The time complexity here is now always O(N) worst case, since 5646 we should have marked both the lower bound and upper bound of 5647 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN 5648 above. This scan also resets those fields. */ 5649 5650 splay_tree_foreach (cases, match_case_to_enum, type); 5651} 5652 5653/* Finish an expression taking the address of LABEL (an 5654 IDENTIFIER_NODE). Returns an expression for the address. 5655 5656 LOC is the location for the expression returned. */ 5657 5658tree 5659finish_label_address_expr (tree label, location_t loc) 5660{ 5661 tree result; 5662 5663 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard"); 5664 5665 if (label == error_mark_node) 5666 return error_mark_node; 5667 5668 label = lookup_label (label); 5669 if (label == NULL_TREE) 5670 result = null_pointer_node; 5671 else 5672 { 5673 TREE_USED (label) = 1; 5674 result = build1 (ADDR_EXPR, ptr_type_node, label); 5675 /* The current function is not necessarily uninlinable. 5676 Computed gotos are incompatible with inlining, but the value 5677 here could be used only in a diagnostic, for example. */ 5678 protected_set_expr_location (result, loc); 5679 } 5680 5681 return result; 5682} 5683 5684 5685/* Given a boolean expression ARG, return a tree representing an increment 5686 or decrement (as indicated by CODE) of ARG. The front end must check for 5687 invalid cases (e.g., decrement in C++). */ 5688tree 5689boolean_increment (enum tree_code code, tree arg) 5690{ 5691 tree val; 5692 tree true_res = build_int_cst (TREE_TYPE (arg), 1); 5693 5694 arg = stabilize_reference (arg); 5695 switch (code) 5696 { 5697 case PREINCREMENT_EXPR: 5698 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 5699 break; 5700 case POSTINCREMENT_EXPR: 5701 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 5702 arg = save_expr (arg); 5703 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 5704 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 5705 break; 5706 case PREDECREMENT_EXPR: 5707 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 5708 invert_truthvalue_loc (input_location, arg)); 5709 break; 5710 case POSTDECREMENT_EXPR: 5711 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 5712 invert_truthvalue_loc (input_location, arg)); 5713 arg = save_expr (arg); 5714 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 5715 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 5716 break; 5717 default: 5718 gcc_unreachable (); 5719 } 5720 TREE_SIDE_EFFECTS (val) = 1; 5721 return val; 5722} 5723 5724/* Built-in macros for stddef.h and stdint.h, that require macros 5725 defined in this file. */ 5726void 5727c_stddef_cpp_builtins(void) 5728{ 5729 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0); 5730 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0); 5731 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0); 5732 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0); 5733 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0); 5734 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0); 5735 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0); 5736 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0); 5737 if (SIG_ATOMIC_TYPE) 5738 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0); 5739 if (INT8_TYPE) 5740 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0); 5741 if (INT16_TYPE) 5742 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0); 5743 if (INT32_TYPE) 5744 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0); 5745 if (INT64_TYPE) 5746 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0); 5747 if (UINT8_TYPE) 5748 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0); 5749 if (UINT16_TYPE) 5750 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0); 5751 if (UINT32_TYPE) 5752 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0); 5753 if (UINT64_TYPE) 5754 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0); 5755 if (INT_LEAST8_TYPE) 5756 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0); 5757 if (INT_LEAST16_TYPE) 5758 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0); 5759 if (INT_LEAST32_TYPE) 5760 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0); 5761 if (INT_LEAST64_TYPE) 5762 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0); 5763 if (UINT_LEAST8_TYPE) 5764 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0); 5765 if (UINT_LEAST16_TYPE) 5766 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0); 5767 if (UINT_LEAST32_TYPE) 5768 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0); 5769 if (UINT_LEAST64_TYPE) 5770 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0); 5771 if (INT_FAST8_TYPE) 5772 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0); 5773 if (INT_FAST16_TYPE) 5774 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0); 5775 if (INT_FAST32_TYPE) 5776 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0); 5777 if (INT_FAST64_TYPE) 5778 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0); 5779 if (UINT_FAST8_TYPE) 5780 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0); 5781 if (UINT_FAST16_TYPE) 5782 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0); 5783 if (UINT_FAST32_TYPE) 5784 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0); 5785 if (UINT_FAST64_TYPE) 5786 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0); 5787 if (INTPTR_TYPE) 5788 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0); 5789 if (UINTPTR_TYPE) 5790 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0); 5791} 5792 5793static void 5794c_init_attributes (void) 5795{ 5796 /* Fill in the built_in_attributes array. */ 5797#define DEF_ATTR_NULL_TREE(ENUM) \ 5798 built_in_attributes[(int) ENUM] = NULL_TREE; 5799#define DEF_ATTR_INT(ENUM, VALUE) \ 5800 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE); 5801#define DEF_ATTR_IDENT(ENUM, STRING) \ 5802 built_in_attributes[(int) ENUM] = get_identifier (STRING); 5803#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \ 5804 built_in_attributes[(int) ENUM] \ 5805 = tree_cons (built_in_attributes[(int) PURPOSE], \ 5806 built_in_attributes[(int) VALUE], \ 5807 built_in_attributes[(int) CHAIN]); 5808#include "builtin-attrs.def" 5809#undef DEF_ATTR_NULL_TREE 5810#undef DEF_ATTR_INT 5811#undef DEF_ATTR_IDENT 5812#undef DEF_ATTR_TREE_LIST 5813} 5814 5815/* Attribute handlers common to C front ends. */ 5816 5817/* Handle a "packed" attribute; arguments as in 5818 struct attribute_spec.handler. */ 5819 5820static tree 5821handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5822 int flags, bool *no_add_attrs) 5823{ 5824 if (TYPE_P (*node)) 5825 { 5826 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 5827 *node = build_variant_type_copy (*node); 5828 TYPE_PACKED (*node) = 1; 5829 } 5830 else if (TREE_CODE (*node) == FIELD_DECL) 5831 { 5832 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT 5833 /* Still pack bitfields. */ 5834 && ! DECL_INITIAL (*node)) 5835 warning (OPT_Wattributes, 5836 "%qE attribute ignored for field of type %qT", 5837 name, TREE_TYPE (*node)); 5838 else 5839 DECL_PACKED (*node) = 1; 5840 } 5841 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is 5842 used for DECL_REGISTER. It wouldn't mean anything anyway. 5843 We can't set DECL_PACKED on the type of a TYPE_DECL, because 5844 that changes what the typedef is typing. */ 5845 else 5846 { 5847 warning (OPT_Wattributes, "%qE attribute ignored", name); 5848 *no_add_attrs = true; 5849 } 5850 5851 return NULL_TREE; 5852} 5853 5854/* Handle a "nocommon" attribute; arguments as in 5855 struct attribute_spec.handler. */ 5856 5857static tree 5858handle_nocommon_attribute (tree *node, tree name, 5859 tree ARG_UNUSED (args), 5860 int ARG_UNUSED (flags), bool *no_add_attrs) 5861{ 5862 if (TREE_CODE (*node) == VAR_DECL) 5863 DECL_COMMON (*node) = 0; 5864 else 5865 { 5866 warning (OPT_Wattributes, "%qE attribute ignored", name); 5867 *no_add_attrs = true; 5868 } 5869 5870 return NULL_TREE; 5871} 5872 5873/* Handle a "common" attribute; arguments as in 5874 struct attribute_spec.handler. */ 5875 5876static tree 5877handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5878 int ARG_UNUSED (flags), bool *no_add_attrs) 5879{ 5880 if (TREE_CODE (*node) == VAR_DECL) 5881 DECL_COMMON (*node) = 1; 5882 else 5883 { 5884 warning (OPT_Wattributes, "%qE attribute ignored", name); 5885 *no_add_attrs = true; 5886 } 5887 5888 return NULL_TREE; 5889} 5890 5891/* Handle a "noreturn" attribute; arguments as in 5892 struct attribute_spec.handler. */ 5893 5894static tree 5895handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5896 int ARG_UNUSED (flags), bool *no_add_attrs) 5897{ 5898 tree type = TREE_TYPE (*node); 5899 5900 /* See FIXME comment in c_common_attribute_table. */ 5901 if (TREE_CODE (*node) == FUNCTION_DECL) 5902 TREE_THIS_VOLATILE (*node) = 1; 5903 else if (TREE_CODE (type) == POINTER_TYPE 5904 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 5905 TREE_TYPE (*node) 5906 = build_pointer_type 5907 (build_type_variant (TREE_TYPE (type), 5908 TYPE_READONLY (TREE_TYPE (type)), 1)); 5909 else 5910 { 5911 warning (OPT_Wattributes, "%qE attribute ignored", name); 5912 *no_add_attrs = true; 5913 } 5914 5915 return NULL_TREE; 5916} 5917 5918/* Handle a "hot" and attribute; arguments as in 5919 struct attribute_spec.handler. */ 5920 5921static tree 5922handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5923 int ARG_UNUSED (flags), bool *no_add_attrs) 5924{ 5925 if (TREE_CODE (*node) == FUNCTION_DECL) 5926 { 5927 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL) 5928 { 5929 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s", 5930 name, "cold"); 5931 *no_add_attrs = true; 5932 } 5933 /* Most of the rest of the hot processing is done later with 5934 lookup_attribute. */ 5935 } 5936 else 5937 { 5938 warning (OPT_Wattributes, "%qE attribute ignored", name); 5939 *no_add_attrs = true; 5940 } 5941 5942 return NULL_TREE; 5943} 5944/* Handle a "cold" and attribute; arguments as in 5945 struct attribute_spec.handler. */ 5946 5947static tree 5948handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args), 5949 int ARG_UNUSED (flags), bool *no_add_attrs) 5950{ 5951 if (TREE_CODE (*node) == FUNCTION_DECL) 5952 { 5953 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL) 5954 { 5955 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s", 5956 name, "hot"); 5957 *no_add_attrs = true; 5958 } 5959 /* Most of the rest of the cold processing is done later with 5960 lookup_attribute. */ 5961 } 5962 else 5963 { 5964 warning (OPT_Wattributes, "%qE attribute ignored", name); 5965 *no_add_attrs = true; 5966 } 5967 5968 return NULL_TREE; 5969} 5970 5971/* Handle a "noinline" attribute; arguments as in 5972 struct attribute_spec.handler. */ 5973 5974static tree 5975handle_noinline_attribute (tree *node, tree name, 5976 tree ARG_UNUSED (args), 5977 int ARG_UNUSED (flags), bool *no_add_attrs) 5978{ 5979 if (TREE_CODE (*node) == FUNCTION_DECL) 5980 DECL_UNINLINABLE (*node) = 1; 5981 else 5982 { 5983 warning (OPT_Wattributes, "%qE attribute ignored", name); 5984 *no_add_attrs = true; 5985 } 5986 5987 return NULL_TREE; 5988} 5989 5990/* Handle a "noclone" attribute; arguments as in 5991 struct attribute_spec.handler. */ 5992 5993static tree 5994handle_noclone_attribute (tree *node, tree name, 5995 tree ARG_UNUSED (args), 5996 int ARG_UNUSED (flags), bool *no_add_attrs) 5997{ 5998 if (TREE_CODE (*node) != FUNCTION_DECL) 5999 { 6000 warning (OPT_Wattributes, "%qE attribute ignored", name); 6001 *no_add_attrs = true; 6002 } 6003 6004 return NULL_TREE; 6005} 6006 6007/* Handle a "always_inline" attribute; arguments as in 6008 struct attribute_spec.handler. */ 6009 6010static tree 6011handle_always_inline_attribute (tree *node, tree name, 6012 tree ARG_UNUSED (args), 6013 int ARG_UNUSED (flags), 6014 bool *no_add_attrs) 6015{ 6016 if (TREE_CODE (*node) == FUNCTION_DECL) 6017 { 6018 /* Set the attribute and mark it for disregarding inline 6019 limits. */ 6020 DECL_DISREGARD_INLINE_LIMITS (*node) = 1; 6021 } 6022 else 6023 { 6024 warning (OPT_Wattributes, "%qE attribute ignored", name); 6025 *no_add_attrs = true; 6026 } 6027 6028 return NULL_TREE; 6029} 6030 6031/* Handle a "gnu_inline" attribute; arguments as in 6032 struct attribute_spec.handler. */ 6033 6034static tree 6035handle_gnu_inline_attribute (tree *node, tree name, 6036 tree ARG_UNUSED (args), 6037 int ARG_UNUSED (flags), 6038 bool *no_add_attrs) 6039{ 6040 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node)) 6041 { 6042 /* Do nothing else, just set the attribute. We'll get at 6043 it later with lookup_attribute. */ 6044 } 6045 else 6046 { 6047 warning (OPT_Wattributes, "%qE attribute ignored", name); 6048 *no_add_attrs = true; 6049 } 6050 6051 return NULL_TREE; 6052} 6053 6054/* Handle an "artificial" attribute; arguments as in 6055 struct attribute_spec.handler. */ 6056 6057static tree 6058handle_artificial_attribute (tree *node, tree name, 6059 tree ARG_UNUSED (args), 6060 int ARG_UNUSED (flags), 6061 bool *no_add_attrs) 6062{ 6063 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node)) 6064 { 6065 /* Do nothing else, just set the attribute. We'll get at 6066 it later with lookup_attribute. */ 6067 } 6068 else 6069 { 6070 warning (OPT_Wattributes, "%qE attribute ignored", name); 6071 *no_add_attrs = true; 6072 } 6073 6074 return NULL_TREE; 6075} 6076 6077/* Handle a "flatten" attribute; arguments as in 6078 struct attribute_spec.handler. */ 6079 6080static tree 6081handle_flatten_attribute (tree *node, tree name, 6082 tree args ATTRIBUTE_UNUSED, 6083 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs) 6084{ 6085 if (TREE_CODE (*node) == FUNCTION_DECL) 6086 /* Do nothing else, just set the attribute. We'll get at 6087 it later with lookup_attribute. */ 6088 ; 6089 else 6090 { 6091 warning (OPT_Wattributes, "%qE attribute ignored", name); 6092 *no_add_attrs = true; 6093 } 6094 6095 return NULL_TREE; 6096} 6097 6098/* Handle a "warning" or "error" attribute; arguments as in 6099 struct attribute_spec.handler. */ 6100 6101static tree 6102handle_error_attribute (tree *node, tree name, tree args, 6103 int ARG_UNUSED (flags), bool *no_add_attrs) 6104{ 6105 if (TREE_CODE (*node) == FUNCTION_DECL 6106 || TREE_CODE (TREE_VALUE (args)) == STRING_CST) 6107 /* Do nothing else, just set the attribute. We'll get at 6108 it later with lookup_attribute. */ 6109 ; 6110 else 6111 { 6112 warning (OPT_Wattributes, "%qE attribute ignored", name); 6113 *no_add_attrs = true; 6114 } 6115 6116 return NULL_TREE; 6117} 6118 6119/* Handle a "used" attribute; arguments as in 6120 struct attribute_spec.handler. */ 6121 6122static tree 6123handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args), 6124 int ARG_UNUSED (flags), bool *no_add_attrs) 6125{ 6126 tree node = *pnode; 6127 6128 if (TREE_CODE (node) == FUNCTION_DECL 6129 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node))) 6130 { 6131 TREE_USED (node) = 1; 6132 DECL_PRESERVE_P (node) = 1; 6133 } 6134 else 6135 { 6136 warning (OPT_Wattributes, "%qE attribute ignored", name); 6137 *no_add_attrs = true; 6138 } 6139 6140 return NULL_TREE; 6141} 6142 6143/* Handle a "unused" attribute; arguments as in 6144 struct attribute_spec.handler. */ 6145 6146static tree 6147handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args), 6148 int flags, bool *no_add_attrs) 6149{ 6150 if (DECL_P (*node)) 6151 { 6152 tree decl = *node; 6153 6154 if (TREE_CODE (decl) == PARM_DECL 6155 || TREE_CODE (decl) == VAR_DECL 6156 || TREE_CODE (decl) == FUNCTION_DECL 6157 || TREE_CODE (decl) == LABEL_DECL 6158 || TREE_CODE (decl) == TYPE_DECL) 6159 TREE_USED (decl) = 1; 6160 else 6161 { 6162 warning (OPT_Wattributes, "%qE attribute ignored", name); 6163 *no_add_attrs = true; 6164 } 6165 } 6166 else 6167 { 6168 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 6169 *node = build_variant_type_copy (*node); 6170 TREE_USED (*node) = 1; 6171 } 6172 6173 return NULL_TREE; 6174} 6175 6176/* Handle a "externally_visible" attribute; arguments as in 6177 struct attribute_spec.handler. */ 6178 6179static tree 6180handle_externally_visible_attribute (tree *pnode, tree name, 6181 tree ARG_UNUSED (args), 6182 int ARG_UNUSED (flags), 6183 bool *no_add_attrs) 6184{ 6185 tree node = *pnode; 6186 6187 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL) 6188 { 6189 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL 6190 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node)) 6191 { 6192 warning (OPT_Wattributes, 6193 "%qE attribute have effect only on public objects", name); 6194 *no_add_attrs = true; 6195 } 6196 } 6197 else 6198 { 6199 warning (OPT_Wattributes, "%qE attribute ignored", name); 6200 *no_add_attrs = true; 6201 } 6202 6203 return NULL_TREE; 6204} 6205 6206/* Handle a "const" attribute; arguments as in 6207 struct attribute_spec.handler. */ 6208 6209static tree 6210handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args), 6211 int ARG_UNUSED (flags), bool *no_add_attrs) 6212{ 6213 tree type = TREE_TYPE (*node); 6214 6215 /* See FIXME comment on noreturn in c_common_attribute_table. */ 6216 if (TREE_CODE (*node) == FUNCTION_DECL) 6217 TREE_READONLY (*node) = 1; 6218 else if (TREE_CODE (type) == POINTER_TYPE 6219 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 6220 TREE_TYPE (*node) 6221 = build_pointer_type 6222 (build_type_variant (TREE_TYPE (type), 1, 6223 TREE_THIS_VOLATILE (TREE_TYPE (type)))); 6224 else 6225 { 6226 warning (OPT_Wattributes, "%qE attribute ignored", name); 6227 *no_add_attrs = true; 6228 } 6229 6230 return NULL_TREE; 6231} 6232 6233/* Handle a "transparent_union" attribute; arguments as in 6234 struct attribute_spec.handler. */ 6235 6236static tree 6237handle_transparent_union_attribute (tree *node, tree name, 6238 tree ARG_UNUSED (args), int flags, 6239 bool *no_add_attrs) 6240{ 6241 tree type; 6242 6243 *no_add_attrs = true; 6244 6245 if (TREE_CODE (*node) == TYPE_DECL) 6246 node = &TREE_TYPE (*node); 6247 type = *node; 6248 6249 if (TREE_CODE (type) == UNION_TYPE) 6250 { 6251 /* When IN_PLACE is set, leave the check for FIELDS and MODE to 6252 the code in finish_struct. */ 6253 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 6254 { 6255 if (TYPE_FIELDS (type) == NULL_TREE 6256 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type))) 6257 goto ignored; 6258 6259 /* A type variant isn't good enough, since we don't a cast 6260 to such a type removed as a no-op. */ 6261 *node = type = build_duplicate_type (type); 6262 } 6263 6264 TYPE_TRANSPARENT_AGGR (type) = 1; 6265 return NULL_TREE; 6266 } 6267 6268 ignored: 6269 warning (OPT_Wattributes, "%qE attribute ignored", name); 6270 return NULL_TREE; 6271} 6272 6273/* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to 6274 get the requested priority for a constructor or destructor, 6275 possibly issuing diagnostics for invalid or reserved 6276 priorities. */ 6277 6278static priority_type 6279get_priority (tree args, bool is_destructor) 6280{ 6281 HOST_WIDE_INT pri; 6282 tree arg; 6283 6284 if (!args) 6285 return DEFAULT_INIT_PRIORITY; 6286 6287 if (!SUPPORTS_INIT_PRIORITY) 6288 { 6289 if (is_destructor) 6290 error ("destructor priorities are not supported"); 6291 else 6292 error ("constructor priorities are not supported"); 6293 return DEFAULT_INIT_PRIORITY; 6294 } 6295 6296 arg = TREE_VALUE (args); 6297 if (!host_integerp (arg, /*pos=*/0) 6298 || !INTEGRAL_TYPE_P (TREE_TYPE (arg))) 6299 goto invalid; 6300 6301 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0); 6302 if (pri < 0 || pri > MAX_INIT_PRIORITY) 6303 goto invalid; 6304 6305 if (pri <= MAX_RESERVED_INIT_PRIORITY) 6306 { 6307 if (is_destructor) 6308 warning (0, 6309 "destructor priorities from 0 to %d are reserved " 6310 "for the implementation", 6311 MAX_RESERVED_INIT_PRIORITY); 6312 else 6313 warning (0, 6314 "constructor priorities from 0 to %d are reserved " 6315 "for the implementation", 6316 MAX_RESERVED_INIT_PRIORITY); 6317 } 6318 return pri; 6319 6320 invalid: 6321 if (is_destructor) 6322 error ("destructor priorities must be integers from 0 to %d inclusive", 6323 MAX_INIT_PRIORITY); 6324 else 6325 error ("constructor priorities must be integers from 0 to %d inclusive", 6326 MAX_INIT_PRIORITY); 6327 return DEFAULT_INIT_PRIORITY; 6328} 6329 6330/* Handle a "constructor" attribute; arguments as in 6331 struct attribute_spec.handler. */ 6332 6333static tree 6334handle_constructor_attribute (tree *node, tree name, tree args, 6335 int ARG_UNUSED (flags), 6336 bool *no_add_attrs) 6337{ 6338 tree decl = *node; 6339 tree type = TREE_TYPE (decl); 6340 6341 if (TREE_CODE (decl) == FUNCTION_DECL 6342 && TREE_CODE (type) == FUNCTION_TYPE 6343 && decl_function_context (decl) == 0) 6344 { 6345 priority_type priority; 6346 DECL_STATIC_CONSTRUCTOR (decl) = 1; 6347 priority = get_priority (args, /*is_destructor=*/false); 6348 SET_DECL_INIT_PRIORITY (decl, priority); 6349 TREE_USED (decl) = 1; 6350 } 6351 else 6352 { 6353 warning (OPT_Wattributes, "%qE attribute ignored", name); 6354 *no_add_attrs = true; 6355 } 6356 6357 return NULL_TREE; 6358} 6359 6360/* Handle a "destructor" attribute; arguments as in 6361 struct attribute_spec.handler. */ 6362 6363static tree 6364handle_destructor_attribute (tree *node, tree name, tree args, 6365 int ARG_UNUSED (flags), 6366 bool *no_add_attrs) 6367{ 6368 tree decl = *node; 6369 tree type = TREE_TYPE (decl); 6370 6371 if (TREE_CODE (decl) == FUNCTION_DECL 6372 && TREE_CODE (type) == FUNCTION_TYPE 6373 && decl_function_context (decl) == 0) 6374 { 6375 priority_type priority; 6376 DECL_STATIC_DESTRUCTOR (decl) = 1; 6377 priority = get_priority (args, /*is_destructor=*/true); 6378 SET_DECL_FINI_PRIORITY (decl, priority); 6379 TREE_USED (decl) = 1; 6380 } 6381 else 6382 { 6383 warning (OPT_Wattributes, "%qE attribute ignored", name); 6384 *no_add_attrs = true; 6385 } 6386 6387 return NULL_TREE; 6388} 6389 6390/* Handle a "mode" attribute; arguments as in 6391 struct attribute_spec.handler. */ 6392 6393static tree 6394handle_mode_attribute (tree *node, tree name, tree args, 6395 int ARG_UNUSED (flags), bool *no_add_attrs) 6396{ 6397 tree type = *node; 6398 tree ident = TREE_VALUE (args); 6399 6400 *no_add_attrs = true; 6401 6402 if (TREE_CODE (ident) != IDENTIFIER_NODE) 6403 warning (OPT_Wattributes, "%qE attribute ignored", name); 6404 else 6405 { 6406 int j; 6407 const char *p = IDENTIFIER_POINTER (ident); 6408 int len = strlen (p); 6409 enum machine_mode mode = VOIDmode; 6410 tree typefm; 6411 bool valid_mode; 6412 6413 if (len > 4 && p[0] == '_' && p[1] == '_' 6414 && p[len - 1] == '_' && p[len - 2] == '_') 6415 { 6416 char *newp = (char *) alloca (len - 1); 6417 6418 strcpy (newp, &p[2]); 6419 newp[len - 4] = '\0'; 6420 p = newp; 6421 } 6422 6423 /* Change this type to have a type with the specified mode. 6424 First check for the special modes. */ 6425 if (!strcmp (p, "byte")) 6426 mode = byte_mode; 6427 else if (!strcmp (p, "word")) 6428 mode = word_mode; 6429 else if (!strcmp (p, "pointer")) 6430 mode = ptr_mode; 6431 else if (!strcmp (p, "libgcc_cmp_return")) 6432 mode = targetm.libgcc_cmp_return_mode (); 6433 else if (!strcmp (p, "libgcc_shift_count")) 6434 mode = targetm.libgcc_shift_count_mode (); 6435 else if (!strcmp (p, "unwind_word")) 6436 mode = targetm.unwind_word_mode (); 6437 else 6438 for (j = 0; j < NUM_MACHINE_MODES; j++) 6439 if (!strcmp (p, GET_MODE_NAME (j))) 6440 { 6441 mode = (enum machine_mode) j; 6442 break; 6443 } 6444 6445 if (mode == VOIDmode) 6446 { 6447 error ("unknown machine mode %qE", ident); 6448 return NULL_TREE; 6449 } 6450 6451 valid_mode = false; 6452 switch (GET_MODE_CLASS (mode)) 6453 { 6454 case MODE_INT: 6455 case MODE_PARTIAL_INT: 6456 case MODE_FLOAT: 6457 case MODE_DECIMAL_FLOAT: 6458 case MODE_FRACT: 6459 case MODE_UFRACT: 6460 case MODE_ACCUM: 6461 case MODE_UACCUM: 6462 valid_mode = targetm.scalar_mode_supported_p (mode); 6463 break; 6464 6465 case MODE_COMPLEX_INT: 6466 case MODE_COMPLEX_FLOAT: 6467 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode)); 6468 break; 6469 6470 case MODE_VECTOR_INT: 6471 case MODE_VECTOR_FLOAT: 6472 case MODE_VECTOR_FRACT: 6473 case MODE_VECTOR_UFRACT: 6474 case MODE_VECTOR_ACCUM: 6475 case MODE_VECTOR_UACCUM: 6476 warning (OPT_Wattributes, "specifying vector types with " 6477 "__attribute__ ((mode)) is deprecated"); 6478 warning (OPT_Wattributes, 6479 "use __attribute__ ((vector_size)) instead"); 6480 valid_mode = vector_mode_valid_p (mode); 6481 break; 6482 6483 default: 6484 break; 6485 } 6486 if (!valid_mode) 6487 { 6488 error ("unable to emulate %qs", p); 6489 return NULL_TREE; 6490 } 6491 6492 if (POINTER_TYPE_P (type)) 6493 { 6494 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type)); 6495 tree (*fn)(tree, enum machine_mode, bool); 6496 6497 if (!targetm.addr_space.valid_pointer_mode (mode, as)) 6498 { 6499 error ("invalid pointer mode %qs", p); 6500 return NULL_TREE; 6501 } 6502 6503 if (TREE_CODE (type) == POINTER_TYPE) 6504 fn = build_pointer_type_for_mode; 6505 else 6506 fn = build_reference_type_for_mode; 6507 typefm = fn (TREE_TYPE (type), mode, false); 6508 } 6509 else 6510 { 6511 /* For fixed-point modes, we need to test if the signness of type 6512 and the machine mode are consistent. */ 6513 if (ALL_FIXED_POINT_MODE_P (mode) 6514 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode)) 6515 { 6516 error ("signness of type and machine mode %qs don't match", p); 6517 return NULL_TREE; 6518 } 6519 /* For fixed-point modes, we need to pass saturating info. */ 6520 typefm = lang_hooks.types.type_for_mode (mode, 6521 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type) 6522 : TYPE_UNSIGNED (type)); 6523 } 6524 6525 if (typefm == NULL_TREE) 6526 { 6527 error ("no data type for mode %qs", p); 6528 return NULL_TREE; 6529 } 6530 else if (TREE_CODE (type) == ENUMERAL_TYPE) 6531 { 6532 /* For enumeral types, copy the precision from the integer 6533 type returned above. If not an INTEGER_TYPE, we can't use 6534 this mode for this type. */ 6535 if (TREE_CODE (typefm) != INTEGER_TYPE) 6536 { 6537 error ("cannot use mode %qs for enumeral types", p); 6538 return NULL_TREE; 6539 } 6540 6541 if (flags & ATTR_FLAG_TYPE_IN_PLACE) 6542 { 6543 TYPE_PRECISION (type) = TYPE_PRECISION (typefm); 6544 typefm = type; 6545 } 6546 else 6547 { 6548 /* We cannot build a type variant, as there's code that assumes 6549 that TYPE_MAIN_VARIANT has the same mode. This includes the 6550 debug generators. Instead, create a subrange type. This 6551 results in all of the enumeral values being emitted only once 6552 in the original, and the subtype gets them by reference. */ 6553 if (TYPE_UNSIGNED (type)) 6554 typefm = make_unsigned_type (TYPE_PRECISION (typefm)); 6555 else 6556 typefm = make_signed_type (TYPE_PRECISION (typefm)); 6557 TREE_TYPE (typefm) = type; 6558 } 6559 } 6560 else if (VECTOR_MODE_P (mode) 6561 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm)) 6562 : TREE_CODE (type) != TREE_CODE (typefm)) 6563 { 6564 error ("mode %qs applied to inappropriate type", p); 6565 return NULL_TREE; 6566 } 6567 6568 *node = typefm; 6569 } 6570 6571 return NULL_TREE; 6572} 6573 6574/* Handle a "section" attribute; arguments as in 6575 struct attribute_spec.handler. */ 6576 6577static tree 6578handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args, 6579 int ARG_UNUSED (flags), bool *no_add_attrs) 6580{ 6581 tree decl = *node; 6582 6583 if (targetm.have_named_sections) 6584 { 6585 user_defined_section_attribute = true; 6586 6587 if ((TREE_CODE (decl) == FUNCTION_DECL 6588 || TREE_CODE (decl) == VAR_DECL) 6589 && TREE_CODE (TREE_VALUE (args)) == STRING_CST) 6590 { 6591 if (TREE_CODE (decl) == VAR_DECL 6592 && current_function_decl != NULL_TREE 6593 && !TREE_STATIC (decl)) 6594 { 6595 error_at (DECL_SOURCE_LOCATION (decl), 6596 "section attribute cannot be specified for " 6597 "local variables"); 6598 *no_add_attrs = true; 6599 } 6600 6601 /* The decl may have already been given a section attribute 6602 from a previous declaration. Ensure they match. */ 6603 else if (DECL_SECTION_NAME (decl) != NULL_TREE 6604 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), 6605 TREE_STRING_POINTER (TREE_VALUE (args))) != 0) 6606 { 6607 error ("section of %q+D conflicts with previous declaration", 6608 *node); 6609 *no_add_attrs = true; 6610 } 6611 else if (TREE_CODE (decl) == VAR_DECL 6612 && !targetm.have_tls && targetm.emutls.tmpl_section 6613 && DECL_THREAD_LOCAL_P (decl)) 6614 { 6615 error ("section of %q+D cannot be overridden", *node); 6616 *no_add_attrs = true; 6617 } 6618 else 6619 DECL_SECTION_NAME (decl) = TREE_VALUE (args); 6620 } 6621 else 6622 { 6623 error ("section attribute not allowed for %q+D", *node); 6624 *no_add_attrs = true; 6625 } 6626 } 6627 else 6628 { 6629 error_at (DECL_SOURCE_LOCATION (*node), 6630 "section attributes are not supported for this target"); 6631 *no_add_attrs = true; 6632 } 6633 6634 return NULL_TREE; 6635} 6636 6637/* Handle a "aligned" attribute; arguments as in 6638 struct attribute_spec.handler. */ 6639 6640static tree 6641handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args, 6642 int flags, bool *no_add_attrs) 6643{ 6644 tree decl = NULL_TREE; 6645 tree *type = NULL; 6646 int is_type = 0; 6647 tree align_expr = (args ? TREE_VALUE (args) 6648 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT)); 6649 int i; 6650 6651 if (DECL_P (*node)) 6652 { 6653 decl = *node; 6654 type = &TREE_TYPE (decl); 6655 is_type = TREE_CODE (*node) == TYPE_DECL; 6656 } 6657 else if (TYPE_P (*node)) 6658 type = node, is_type = 1; 6659 6660 if (TREE_CODE (align_expr) != INTEGER_CST) 6661 { 6662 error ("requested alignment is not a constant"); 6663 *no_add_attrs = true; 6664 } 6665 else if ((i = tree_log2 (align_expr)) == -1) 6666 { 6667 error ("requested alignment is not a power of 2"); 6668 *no_add_attrs = true; 6669 } 6670 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG) 6671 { 6672 error ("requested alignment is too large"); 6673 *no_add_attrs = true; 6674 } 6675 else if (is_type) 6676 { 6677 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 6678 /* OK, modify the type in place. */; 6679 /* If we have a TYPE_DECL, then copy the type, so that we 6680 don't accidentally modify a builtin type. See pushdecl. */ 6681 else if (decl && TREE_TYPE (decl) != error_mark_node 6682 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE) 6683 { 6684 tree tt = TREE_TYPE (decl); 6685 *type = build_variant_type_copy (*type); 6686 DECL_ORIGINAL_TYPE (decl) = tt; 6687 TYPE_NAME (*type) = decl; 6688 TREE_USED (*type) = TREE_USED (decl); 6689 TREE_TYPE (decl) = *type; 6690 } 6691 else 6692 *type = build_variant_type_copy (*type); 6693 6694 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT; 6695 TYPE_USER_ALIGN (*type) = 1; 6696 } 6697 else if (! VAR_OR_FUNCTION_DECL_P (decl) 6698 && TREE_CODE (decl) != FIELD_DECL) 6699 { 6700 error ("alignment may not be specified for %q+D", decl); 6701 *no_add_attrs = true; 6702 } 6703 else if (TREE_CODE (decl) == FUNCTION_DECL 6704 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT) 6705 { 6706 if (DECL_USER_ALIGN (decl)) 6707 error ("alignment for %q+D was previously specified as %d " 6708 "and may not be decreased", decl, 6709 DECL_ALIGN (decl) / BITS_PER_UNIT); 6710 else 6711 error ("alignment for %q+D must be at least %d", decl, 6712 DECL_ALIGN (decl) / BITS_PER_UNIT); 6713 *no_add_attrs = true; 6714 } 6715 else 6716 { 6717 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT; 6718 DECL_USER_ALIGN (decl) = 1; 6719 } 6720 6721 return NULL_TREE; 6722} 6723 6724/* Handle a "weak" attribute; arguments as in 6725 struct attribute_spec.handler. */ 6726 6727static tree 6728handle_weak_attribute (tree *node, tree name, 6729 tree ARG_UNUSED (args), 6730 int ARG_UNUSED (flags), 6731 bool * ARG_UNUSED (no_add_attrs)) 6732{ 6733 if (TREE_CODE (*node) == FUNCTION_DECL 6734 && DECL_DECLARED_INLINE_P (*node)) 6735 { 6736 error ("inline function %q+D cannot be declared weak", *node); 6737 *no_add_attrs = true; 6738 } 6739 else if (TREE_CODE (*node) == FUNCTION_DECL 6740 || TREE_CODE (*node) == VAR_DECL) 6741 declare_weak (*node); 6742 else 6743 warning (OPT_Wattributes, "%qE attribute ignored", name); 6744 6745 return NULL_TREE; 6746} 6747 6748/* Handle an "alias" attribute; arguments as in 6749 struct attribute_spec.handler. */ 6750 6751static tree 6752handle_alias_attribute (tree *node, tree name, tree args, 6753 int ARG_UNUSED (flags), bool *no_add_attrs) 6754{ 6755 tree decl = *node; 6756 6757 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL) 6758 { 6759 warning (OPT_Wattributes, "%qE attribute ignored", name); 6760 *no_add_attrs = true; 6761 } 6762 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl)) 6763 || (TREE_CODE (decl) != FUNCTION_DECL 6764 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) 6765 /* A static variable declaration is always a tentative definition, 6766 but the alias is a non-tentative definition which overrides. */ 6767 || (TREE_CODE (decl) != FUNCTION_DECL 6768 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl))) 6769 { 6770 error ("%q+D defined both normally and as an alias", decl); 6771 *no_add_attrs = true; 6772 } 6773 6774 /* Note that the very first time we process a nested declaration, 6775 decl_function_context will not be set. Indeed, *would* never 6776 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that 6777 we do below. After such frobbery, pushdecl would set the context. 6778 In any case, this is never what we want. */ 6779 else if (decl_function_context (decl) == 0 && current_function_decl == NULL) 6780 { 6781 tree id; 6782 6783 id = TREE_VALUE (args); 6784 if (TREE_CODE (id) != STRING_CST) 6785 { 6786 error ("alias argument not a string"); 6787 *no_add_attrs = true; 6788 return NULL_TREE; 6789 } 6790 id = get_identifier (TREE_STRING_POINTER (id)); 6791 /* This counts as a use of the object pointed to. */ 6792 TREE_USED (id) = 1; 6793 6794 if (TREE_CODE (decl) == FUNCTION_DECL) 6795 DECL_INITIAL (decl) = error_mark_node; 6796 else 6797 { 6798 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 6799 DECL_EXTERNAL (decl) = 1; 6800 else 6801 DECL_EXTERNAL (decl) = 0; 6802 TREE_STATIC (decl) = 1; 6803 } 6804 } 6805 else 6806 { 6807 warning (OPT_Wattributes, "%qE attribute ignored", name); 6808 *no_add_attrs = true; 6809 } 6810 6811 return NULL_TREE; 6812} 6813 6814/* Handle a "weakref" attribute; arguments as in struct 6815 attribute_spec.handler. */ 6816 6817static tree 6818handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args, 6819 int flags, bool *no_add_attrs) 6820{ 6821 tree attr = NULL_TREE; 6822 6823 /* We must ignore the attribute when it is associated with 6824 local-scoped decls, since attribute alias is ignored and many 6825 such symbols do not even have a DECL_WEAK field. */ 6826 if (decl_function_context (*node) 6827 || current_function_decl 6828 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL)) 6829 { 6830 warning (OPT_Wattributes, "%qE attribute ignored", name); 6831 *no_add_attrs = true; 6832 return NULL_TREE; 6833 } 6834 6835 /* The idea here is that `weakref("name")' mutates into `weakref, 6836 alias("name")', and weakref without arguments, in turn, 6837 implicitly adds weak. */ 6838 6839 if (args) 6840 { 6841 attr = tree_cons (get_identifier ("alias"), args, attr); 6842 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr); 6843 6844 *no_add_attrs = true; 6845 6846 decl_attributes (node, attr, flags); 6847 } 6848 else 6849 { 6850 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node))) 6851 error_at (DECL_SOURCE_LOCATION (*node), 6852 "weakref attribute must appear before alias attribute"); 6853 6854 /* Can't call declare_weak because it wants this to be TREE_PUBLIC, 6855 and that isn't supported; and because it wants to add it to 6856 the list of weak decls, which isn't helpful. */ 6857 DECL_WEAK (*node) = 1; 6858 } 6859 6860 return NULL_TREE; 6861} 6862 6863/* Handle an "visibility" attribute; arguments as in 6864 struct attribute_spec.handler. */ 6865 6866static tree 6867handle_visibility_attribute (tree *node, tree name, tree args, 6868 int ARG_UNUSED (flags), 6869 bool *ARG_UNUSED (no_add_attrs)) 6870{ 6871 tree decl = *node; 6872 tree id = TREE_VALUE (args); 6873 enum symbol_visibility vis; 6874 6875 if (TYPE_P (*node)) 6876 { 6877 if (TREE_CODE (*node) == ENUMERAL_TYPE) 6878 /* OK */; 6879 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE) 6880 { 6881 warning (OPT_Wattributes, "%qE attribute ignored on non-class types", 6882 name); 6883 return NULL_TREE; 6884 } 6885 else if (TYPE_FIELDS (*node)) 6886 { 6887 error ("%qE attribute ignored because %qT is already defined", 6888 name, *node); 6889 return NULL_TREE; 6890 } 6891 } 6892 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl)) 6893 { 6894 warning (OPT_Wattributes, "%qE attribute ignored", name); 6895 return NULL_TREE; 6896 } 6897 6898 if (TREE_CODE (id) != STRING_CST) 6899 { 6900 error ("visibility argument not a string"); 6901 return NULL_TREE; 6902 } 6903 6904 /* If this is a type, set the visibility on the type decl. */ 6905 if (TYPE_P (decl)) 6906 { 6907 decl = TYPE_NAME (decl); 6908 if (!decl) 6909 return NULL_TREE; 6910 if (TREE_CODE (decl) == IDENTIFIER_NODE) 6911 { 6912 warning (OPT_Wattributes, "%qE attribute ignored on types", 6913 name); 6914 return NULL_TREE; 6915 } 6916 } 6917 6918 if (strcmp (TREE_STRING_POINTER (id), "default") == 0) 6919 vis = VISIBILITY_DEFAULT; 6920 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0) 6921 vis = VISIBILITY_INTERNAL; 6922 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0) 6923 vis = VISIBILITY_HIDDEN; 6924 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0) 6925 vis = VISIBILITY_PROTECTED; 6926 else 6927 { 6928 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\""); 6929 vis = VISIBILITY_DEFAULT; 6930 } 6931 6932 if (DECL_VISIBILITY_SPECIFIED (decl) 6933 && vis != DECL_VISIBILITY (decl)) 6934 { 6935 tree attributes = (TYPE_P (*node) 6936 ? TYPE_ATTRIBUTES (*node) 6937 : DECL_ATTRIBUTES (decl)); 6938 if (lookup_attribute ("visibility", attributes)) 6939 error ("%qD redeclared with different visibility", decl); 6940 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES 6941 && lookup_attribute ("dllimport", attributes)) 6942 error ("%qD was declared %qs which implies default visibility", 6943 decl, "dllimport"); 6944 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES 6945 && lookup_attribute ("dllexport", attributes)) 6946 error ("%qD was declared %qs which implies default visibility", 6947 decl, "dllexport"); 6948 } 6949 6950 DECL_VISIBILITY (decl) = vis; 6951 DECL_VISIBILITY_SPECIFIED (decl) = 1; 6952 6953 /* Go ahead and attach the attribute to the node as well. This is needed 6954 so we can determine whether we have VISIBILITY_DEFAULT because the 6955 visibility was not specified, or because it was explicitly overridden 6956 from the containing scope. */ 6957 6958 return NULL_TREE; 6959} 6960 6961/* Determine the ELF symbol visibility for DECL, which is either a 6962 variable or a function. It is an error to use this function if a 6963 definition of DECL is not available in this translation unit. 6964 Returns true if the final visibility has been determined by this 6965 function; false if the caller is free to make additional 6966 modifications. */ 6967 6968bool 6969c_determine_visibility (tree decl) 6970{ 6971 gcc_assert (TREE_CODE (decl) == VAR_DECL 6972 || TREE_CODE (decl) == FUNCTION_DECL); 6973 6974 /* If the user explicitly specified the visibility with an 6975 attribute, honor that. DECL_VISIBILITY will have been set during 6976 the processing of the attribute. We check for an explicit 6977 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED, 6978 to distinguish the use of an attribute from the use of a "#pragma 6979 GCC visibility push(...)"; in the latter case we still want other 6980 considerations to be able to overrule the #pragma. */ 6981 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)) 6982 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES 6983 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)) 6984 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))))) 6985 return true; 6986 6987 /* Set default visibility to whatever the user supplied with 6988 visibility_specified depending on #pragma GCC visibility. */ 6989 if (!DECL_VISIBILITY_SPECIFIED (decl)) 6990 { 6991 if (visibility_options.inpragma 6992 || DECL_VISIBILITY (decl) != default_visibility) 6993 { 6994 DECL_VISIBILITY (decl) = default_visibility; 6995 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma; 6996 /* If visibility changed and DECL already has DECL_RTL, ensure 6997 symbol flags are updated. */ 6998 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 6999 || TREE_CODE (decl) == FUNCTION_DECL) 7000 && DECL_RTL_SET_P (decl)) 7001 make_decl_rtl (decl); 7002 } 7003 } 7004 return false; 7005} 7006 7007/* Handle an "tls_model" attribute; arguments as in 7008 struct attribute_spec.handler. */ 7009 7010static tree 7011handle_tls_model_attribute (tree *node, tree name, tree args, 7012 int ARG_UNUSED (flags), bool *no_add_attrs) 7013{ 7014 tree id; 7015 tree decl = *node; 7016 enum tls_model kind; 7017 7018 *no_add_attrs = true; 7019 7020 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl)) 7021 { 7022 warning (OPT_Wattributes, "%qE attribute ignored", name); 7023 return NULL_TREE; 7024 } 7025 7026 kind = DECL_TLS_MODEL (decl); 7027 id = TREE_VALUE (args); 7028 if (TREE_CODE (id) != STRING_CST) 7029 { 7030 error ("tls_model argument not a string"); 7031 return NULL_TREE; 7032 } 7033 7034 if (!strcmp (TREE_STRING_POINTER (id), "local-exec")) 7035 kind = TLS_MODEL_LOCAL_EXEC; 7036 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec")) 7037 kind = TLS_MODEL_INITIAL_EXEC; 7038 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic")) 7039 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC; 7040 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic")) 7041 kind = TLS_MODEL_GLOBAL_DYNAMIC; 7042 else 7043 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\""); 7044 7045 DECL_TLS_MODEL (decl) = kind; 7046 return NULL_TREE; 7047} 7048 7049/* Handle a "no_instrument_function" attribute; arguments as in 7050 struct attribute_spec.handler. */ 7051 7052static tree 7053handle_no_instrument_function_attribute (tree *node, tree name, 7054 tree ARG_UNUSED (args), 7055 int ARG_UNUSED (flags), 7056 bool *no_add_attrs) 7057{ 7058 tree decl = *node; 7059 7060 if (TREE_CODE (decl) != FUNCTION_DECL) 7061 { 7062 error_at (DECL_SOURCE_LOCATION (decl), 7063 "%qE attribute applies only to functions", name); 7064 *no_add_attrs = true; 7065 } 7066 else if (DECL_INITIAL (decl)) 7067 { 7068 error_at (DECL_SOURCE_LOCATION (decl), 7069 "can%'t set %qE attribute after definition", name); 7070 *no_add_attrs = true; 7071 } 7072 else 7073 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1; 7074 7075 return NULL_TREE; 7076} 7077 7078/* Handle a "malloc" attribute; arguments as in 7079 struct attribute_spec.handler. */ 7080 7081static tree 7082handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args), 7083 int ARG_UNUSED (flags), bool *no_add_attrs) 7084{ 7085 if (TREE_CODE (*node) == FUNCTION_DECL 7086 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node)))) 7087 DECL_IS_MALLOC (*node) = 1; 7088 else 7089 { 7090 warning (OPT_Wattributes, "%qE attribute ignored", name); 7091 *no_add_attrs = true; 7092 } 7093 7094 return NULL_TREE; 7095} 7096 7097/* Handle a "alloc_size" attribute; arguments as in 7098 struct attribute_spec.handler. */ 7099 7100static tree 7101handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args, 7102 int ARG_UNUSED (flags), bool *no_add_attrs) 7103{ 7104 unsigned arg_count = type_num_arguments (*node); 7105 for (; args; args = TREE_CHAIN (args)) 7106 { 7107 tree position = TREE_VALUE (args); 7108 7109 if (TREE_CODE (position) != INTEGER_CST 7110 || TREE_INT_CST_HIGH (position) 7111 || TREE_INT_CST_LOW (position) < 1 7112 || TREE_INT_CST_LOW (position) > arg_count ) 7113 { 7114 warning (OPT_Wattributes, 7115 "alloc_size parameter outside range"); 7116 *no_add_attrs = true; 7117 return NULL_TREE; 7118 } 7119 } 7120 return NULL_TREE; 7121} 7122 7123/* Handle a "returns_twice" attribute; arguments as in 7124 struct attribute_spec.handler. */ 7125 7126static tree 7127handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args), 7128 int ARG_UNUSED (flags), bool *no_add_attrs) 7129{ 7130 if (TREE_CODE (*node) == FUNCTION_DECL) 7131 DECL_IS_RETURNS_TWICE (*node) = 1; 7132 else 7133 { 7134 warning (OPT_Wattributes, "%qE attribute ignored", name); 7135 *no_add_attrs = true; 7136 } 7137 7138 return NULL_TREE; 7139} 7140 7141/* Handle a "no_limit_stack" attribute; arguments as in 7142 struct attribute_spec.handler. */ 7143 7144static tree 7145handle_no_limit_stack_attribute (tree *node, tree name, 7146 tree ARG_UNUSED (args), 7147 int ARG_UNUSED (flags), 7148 bool *no_add_attrs) 7149{ 7150 tree decl = *node; 7151 7152 if (TREE_CODE (decl) != FUNCTION_DECL) 7153 { 7154 error_at (DECL_SOURCE_LOCATION (decl), 7155 "%qE attribute applies only to functions", name); 7156 *no_add_attrs = true; 7157 } 7158 else if (DECL_INITIAL (decl)) 7159 { 7160 error_at (DECL_SOURCE_LOCATION (decl), 7161 "can%'t set %qE attribute after definition", name); 7162 *no_add_attrs = true; 7163 } 7164 else 7165 DECL_NO_LIMIT_STACK (decl) = 1; 7166 7167 return NULL_TREE; 7168} 7169 7170/* Handle a "pure" attribute; arguments as in 7171 struct attribute_spec.handler. */ 7172 7173static tree 7174handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args), 7175 int ARG_UNUSED (flags), bool *no_add_attrs) 7176{ 7177 if (TREE_CODE (*node) == FUNCTION_DECL) 7178 DECL_PURE_P (*node) = 1; 7179 /* ??? TODO: Support types. */ 7180 else 7181 { 7182 warning (OPT_Wattributes, "%qE attribute ignored", name); 7183 *no_add_attrs = true; 7184 } 7185 7186 return NULL_TREE; 7187} 7188 7189/* Handle a "no vops" attribute; arguments as in 7190 struct attribute_spec.handler. */ 7191 7192static tree 7193handle_novops_attribute (tree *node, tree ARG_UNUSED (name), 7194 tree ARG_UNUSED (args), int ARG_UNUSED (flags), 7195 bool *ARG_UNUSED (no_add_attrs)) 7196{ 7197 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL); 7198 DECL_IS_NOVOPS (*node) = 1; 7199 return NULL_TREE; 7200} 7201 7202/* Handle a "deprecated" attribute; arguments as in 7203 struct attribute_spec.handler. */ 7204 7205static tree 7206handle_deprecated_attribute (tree *node, tree name, 7207 tree args, int flags, 7208 bool *no_add_attrs) 7209{ 7210 tree type = NULL_TREE; 7211 int warn = 0; 7212 tree what = NULL_TREE; 7213 7214 if (!args) 7215 *no_add_attrs = true; 7216 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST) 7217 { 7218 error ("deprecated message is not a string"); 7219 *no_add_attrs = true; 7220 } 7221 7222 if (DECL_P (*node)) 7223 { 7224 tree decl = *node; 7225 type = TREE_TYPE (decl); 7226 7227 if (TREE_CODE (decl) == TYPE_DECL 7228 || TREE_CODE (decl) == PARM_DECL 7229 || TREE_CODE (decl) == VAR_DECL 7230 || TREE_CODE (decl) == FUNCTION_DECL 7231 || TREE_CODE (decl) == FIELD_DECL) 7232 TREE_DEPRECATED (decl) = 1; 7233 else 7234 warn = 1; 7235 } 7236 else if (TYPE_P (*node)) 7237 { 7238 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE)) 7239 *node = build_variant_type_copy (*node); 7240 TREE_DEPRECATED (*node) = 1; 7241 type = *node; 7242 } 7243 else 7244 warn = 1; 7245 7246 if (warn) 7247 { 7248 *no_add_attrs = true; 7249 if (type && TYPE_NAME (type)) 7250 { 7251 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 7252 what = TYPE_NAME (*node); 7253 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 7254 && DECL_NAME (TYPE_NAME (type))) 7255 what = DECL_NAME (TYPE_NAME (type)); 7256 } 7257 if (what) 7258 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what); 7259 else 7260 warning (OPT_Wattributes, "%qE attribute ignored", name); 7261 } 7262 7263 return NULL_TREE; 7264} 7265 7266/* Handle a "vector_size" attribute; arguments as in 7267 struct attribute_spec.handler. */ 7268 7269static tree 7270handle_vector_size_attribute (tree *node, tree name, tree args, 7271 int ARG_UNUSED (flags), 7272 bool *no_add_attrs) 7273{ 7274 unsigned HOST_WIDE_INT vecsize, nunits; 7275 enum machine_mode orig_mode; 7276 tree type = *node, new_type, size; 7277 7278 *no_add_attrs = true; 7279 7280 size = TREE_VALUE (args); 7281 7282 if (!host_integerp (size, 1)) 7283 { 7284 warning (OPT_Wattributes, "%qE attribute ignored", name); 7285 return NULL_TREE; 7286 } 7287 7288 /* Get the vector size (in bytes). */ 7289 vecsize = tree_low_cst (size, 1); 7290 7291 /* We need to provide for vector pointers, vector arrays, and 7292 functions returning vectors. For example: 7293 7294 __attribute__((vector_size(16))) short *foo; 7295 7296 In this case, the mode is SI, but the type being modified is 7297 HI, so we need to look further. */ 7298 7299 while (POINTER_TYPE_P (type) 7300 || TREE_CODE (type) == FUNCTION_TYPE 7301 || TREE_CODE (type) == METHOD_TYPE 7302 || TREE_CODE (type) == ARRAY_TYPE 7303 || TREE_CODE (type) == OFFSET_TYPE) 7304 type = TREE_TYPE (type); 7305 7306 /* Get the mode of the type being modified. */ 7307 orig_mode = TYPE_MODE (type); 7308 7309 if ((!INTEGRAL_TYPE_P (type) 7310 && !SCALAR_FLOAT_TYPE_P (type) 7311 && !FIXED_POINT_TYPE_P (type)) 7312 || (!SCALAR_FLOAT_MODE_P (orig_mode) 7313 && GET_MODE_CLASS (orig_mode) != MODE_INT 7314 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode)) 7315 || !host_integerp (TYPE_SIZE_UNIT (type), 1) 7316 || TREE_CODE (type) == BOOLEAN_TYPE) 7317 { 7318 error ("invalid vector type for attribute %qE", name); 7319 return NULL_TREE; 7320 } 7321 7322 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1)) 7323 { 7324 error ("vector size not an integral multiple of component size"); 7325 return NULL; 7326 } 7327 7328 if (vecsize == 0) 7329 { 7330 error ("zero vector size"); 7331 return NULL; 7332 } 7333 7334 /* Calculate how many units fit in the vector. */ 7335 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1); 7336 if (nunits & (nunits - 1)) 7337 { 7338 error ("number of components of the vector not a power of two"); 7339 return NULL_TREE; 7340 } 7341 7342 new_type = build_vector_type (type, nunits); 7343 7344 /* Build back pointers if needed. */ 7345 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type); 7346 7347 return NULL_TREE; 7348} 7349 7350/* Handle the "nonnull" attribute. */ 7351static tree 7352handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name), 7353 tree args, int ARG_UNUSED (flags), 7354 bool *no_add_attrs) 7355{ 7356 tree type = *node; 7357 unsigned HOST_WIDE_INT attr_arg_num; 7358 7359 /* If no arguments are specified, all pointer arguments should be 7360 non-null. Verify a full prototype is given so that the arguments 7361 will have the correct types when we actually check them later. */ 7362 if (!args) 7363 { 7364 if (!TYPE_ARG_TYPES (type)) 7365 { 7366 error ("nonnull attribute without arguments on a non-prototype"); 7367 *no_add_attrs = true; 7368 } 7369 return NULL_TREE; 7370 } 7371 7372 /* Argument list specified. Verify that each argument number references 7373 a pointer argument. */ 7374 for (attr_arg_num = 1; args; args = TREE_CHAIN (args)) 7375 { 7376 tree argument; 7377 unsigned HOST_WIDE_INT arg_num = 0, ck_num; 7378 7379 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num)) 7380 { 7381 error ("nonnull argument has invalid operand number (argument %lu)", 7382 (unsigned long) attr_arg_num); 7383 *no_add_attrs = true; 7384 return NULL_TREE; 7385 } 7386 7387 argument = TYPE_ARG_TYPES (type); 7388 if (argument) 7389 { 7390 for (ck_num = 1; ; ck_num++) 7391 { 7392 if (!argument || ck_num == arg_num) 7393 break; 7394 argument = TREE_CHAIN (argument); 7395 } 7396 7397 if (!argument 7398 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE) 7399 { 7400 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)", 7401 (unsigned long) attr_arg_num, (unsigned long) arg_num); 7402 *no_add_attrs = true; 7403 return NULL_TREE; 7404 } 7405 7406 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE) 7407 { 7408 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)", 7409 (unsigned long) attr_arg_num, (unsigned long) arg_num); 7410 *no_add_attrs = true; 7411 return NULL_TREE; 7412 } 7413 } 7414 } 7415 7416 return NULL_TREE; 7417} 7418 7419/* Check the argument list of a function call for null in argument slots 7420 that are marked as requiring a non-null pointer argument. The NARGS 7421 arguments are passed in the array ARGARRAY. 7422*/ 7423 7424static void 7425check_function_nonnull (tree attrs, int nargs, tree *argarray) 7426{ 7427 tree a, args; 7428 int i; 7429 7430 for (a = attrs; a; a = TREE_CHAIN (a)) 7431 { 7432 if (is_attribute_p ("nonnull", TREE_PURPOSE (a))) 7433 { 7434 args = TREE_VALUE (a); 7435 7436 /* Walk the argument list. If we encounter an argument number we 7437 should check for non-null, do it. If the attribute has no args, 7438 then every pointer argument is checked (in which case the check 7439 for pointer type is done in check_nonnull_arg). */ 7440 for (i = 0; i < nargs; i++) 7441 { 7442 if (!args || nonnull_check_p (args, i + 1)) 7443 check_function_arguments_recurse (check_nonnull_arg, NULL, 7444 argarray[i], 7445 i + 1); 7446 } 7447 } 7448 } 7449} 7450 7451/* Check that the Nth argument of a function call (counting backwards 7452 from the end) is a (pointer)0. The NARGS arguments are passed in the 7453 array ARGARRAY. */ 7454 7455static void 7456check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist) 7457{ 7458 tree attr = lookup_attribute ("sentinel", attrs); 7459 7460 if (attr) 7461 { 7462 int len = 0; 7463 int pos = 0; 7464 tree sentinel; 7465 7466 /* Skip over the named arguments. */ 7467 while (typelist && len < nargs) 7468 { 7469 typelist = TREE_CHAIN (typelist); 7470 len++; 7471 } 7472 7473 if (TREE_VALUE (attr)) 7474 { 7475 tree p = TREE_VALUE (TREE_VALUE (attr)); 7476 pos = TREE_INT_CST_LOW (p); 7477 } 7478 7479 /* The sentinel must be one of the varargs, i.e. 7480 in position >= the number of fixed arguments. */ 7481 if ((nargs - 1 - pos) < len) 7482 { 7483 warning (OPT_Wformat, 7484 "not enough variable arguments to fit a sentinel"); 7485 return; 7486 } 7487 7488 /* Validate the sentinel. */ 7489 sentinel = argarray[nargs - 1 - pos]; 7490 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel)) 7491 || !integer_zerop (sentinel)) 7492 /* Although __null (in C++) is only an integer we allow it 7493 nevertheless, as we are guaranteed that it's exactly 7494 as wide as a pointer, and we don't want to force 7495 users to cast the NULL they have written there. 7496 We warn with -Wstrict-null-sentinel, though. */ 7497 && (warn_strict_null_sentinel || null_node != sentinel)) 7498 warning (OPT_Wformat, "missing sentinel in function call"); 7499 } 7500} 7501 7502/* Helper for check_function_nonnull; given a list of operands which 7503 must be non-null in ARGS, determine if operand PARAM_NUM should be 7504 checked. */ 7505 7506static bool 7507nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num) 7508{ 7509 unsigned HOST_WIDE_INT arg_num = 0; 7510 7511 for (; args; args = TREE_CHAIN (args)) 7512 { 7513 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num); 7514 7515 gcc_assert (found); 7516 7517 if (arg_num == param_num) 7518 return true; 7519 } 7520 return false; 7521} 7522 7523/* Check that the function argument PARAM (which is operand number 7524 PARAM_NUM) is non-null. This is called by check_function_nonnull 7525 via check_function_arguments_recurse. */ 7526 7527static void 7528check_nonnull_arg (void * ARG_UNUSED (ctx), tree param, 7529 unsigned HOST_WIDE_INT param_num) 7530{ 7531 /* Just skip checking the argument if it's not a pointer. This can 7532 happen if the "nonnull" attribute was given without an operand 7533 list (which means to check every pointer argument). */ 7534 7535 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE) 7536 return; 7537 7538 if (integer_zerop (param)) 7539 warning (OPT_Wnonnull, "null argument where non-null required " 7540 "(argument %lu)", (unsigned long) param_num); 7541} 7542 7543/* Helper for nonnull attribute handling; fetch the operand number 7544 from the attribute argument list. */ 7545 7546static bool 7547get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp) 7548{ 7549 /* Verify the arg number is a constant. */ 7550 if (TREE_CODE (arg_num_expr) != INTEGER_CST 7551 || TREE_INT_CST_HIGH (arg_num_expr) != 0) 7552 return false; 7553 7554 *valp = TREE_INT_CST_LOW (arg_num_expr); 7555 return true; 7556} 7557 7558/* Handle a "nothrow" attribute; arguments as in 7559 struct attribute_spec.handler. */ 7560 7561static tree 7562handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args), 7563 int ARG_UNUSED (flags), bool *no_add_attrs) 7564{ 7565 if (TREE_CODE (*node) == FUNCTION_DECL) 7566 TREE_NOTHROW (*node) = 1; 7567 /* ??? TODO: Support types. */ 7568 else 7569 { 7570 warning (OPT_Wattributes, "%qE attribute ignored", name); 7571 *no_add_attrs = true; 7572 } 7573 7574 return NULL_TREE; 7575} 7576 7577/* Handle a "cleanup" attribute; arguments as in 7578 struct attribute_spec.handler. */ 7579 7580static tree 7581handle_cleanup_attribute (tree *node, tree name, tree args, 7582 int ARG_UNUSED (flags), bool *no_add_attrs) 7583{ 7584 tree decl = *node; 7585 tree cleanup_id, cleanup_decl; 7586 7587 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do 7588 for global destructors in C++. This requires infrastructure that 7589 we don't have generically at the moment. It's also not a feature 7590 we'd be missing too much, since we do have attribute constructor. */ 7591 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)) 7592 { 7593 warning (OPT_Wattributes, "%qE attribute ignored", name); 7594 *no_add_attrs = true; 7595 return NULL_TREE; 7596 } 7597 7598 /* Verify that the argument is a function in scope. */ 7599 /* ??? We could support pointers to functions here as well, if 7600 that was considered desirable. */ 7601 cleanup_id = TREE_VALUE (args); 7602 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE) 7603 { 7604 error ("cleanup argument not an identifier"); 7605 *no_add_attrs = true; 7606 return NULL_TREE; 7607 } 7608 cleanup_decl = lookup_name (cleanup_id); 7609 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL) 7610 { 7611 error ("cleanup argument not a function"); 7612 *no_add_attrs = true; 7613 return NULL_TREE; 7614 } 7615 7616 /* That the function has proper type is checked with the 7617 eventual call to build_function_call. */ 7618 7619 return NULL_TREE; 7620} 7621 7622/* Handle a "warn_unused_result" attribute. No special handling. */ 7623 7624static tree 7625handle_warn_unused_result_attribute (tree *node, tree name, 7626 tree ARG_UNUSED (args), 7627 int ARG_UNUSED (flags), bool *no_add_attrs) 7628{ 7629 /* Ignore the attribute for functions not returning any value. */ 7630 if (VOID_TYPE_P (TREE_TYPE (*node))) 7631 { 7632 warning (OPT_Wattributes, "%qE attribute ignored", name); 7633 *no_add_attrs = true; 7634 } 7635 7636 return NULL_TREE; 7637} 7638 7639/* Handle a "sentinel" attribute. */ 7640 7641static tree 7642handle_sentinel_attribute (tree *node, tree name, tree args, 7643 int ARG_UNUSED (flags), bool *no_add_attrs) 7644{ 7645 tree params = TYPE_ARG_TYPES (*node); 7646 7647 if (!params) 7648 { 7649 warning (OPT_Wattributes, 7650 "%qE attribute requires prototypes with named arguments", name); 7651 *no_add_attrs = true; 7652 } 7653 else 7654 { 7655 while (TREE_CHAIN (params)) 7656 params = TREE_CHAIN (params); 7657 7658 if (VOID_TYPE_P (TREE_VALUE (params))) 7659 { 7660 warning (OPT_Wattributes, 7661 "%qE attribute only applies to variadic functions", name); 7662 *no_add_attrs = true; 7663 } 7664 } 7665 7666 if (args) 7667 { 7668 tree position = TREE_VALUE (args); 7669 7670 if (TREE_CODE (position) != INTEGER_CST) 7671 { 7672 warning (OPT_Wattributes, 7673 "requested position is not an integer constant"); 7674 *no_add_attrs = true; 7675 } 7676 else 7677 { 7678 if (tree_int_cst_lt (position, integer_zero_node)) 7679 { 7680 warning (OPT_Wattributes, 7681 "requested position is less than zero"); 7682 *no_add_attrs = true; 7683 } 7684 } 7685 } 7686 7687 return NULL_TREE; 7688} 7689 7690/* Handle a "type_generic" attribute. */ 7691 7692static tree 7693handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name), 7694 tree ARG_UNUSED (args), int ARG_UNUSED (flags), 7695 bool * ARG_UNUSED (no_add_attrs)) 7696{ 7697 tree params; 7698 7699 /* Ensure we have a function type. */ 7700 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE); 7701 7702 params = TYPE_ARG_TYPES (*node); 7703 while (params && ! VOID_TYPE_P (TREE_VALUE (params))) 7704 params = TREE_CHAIN (params); 7705 7706 /* Ensure we have a variadic function. */ 7707 gcc_assert (!params); 7708 7709 return NULL_TREE; 7710} 7711 7712/* Handle a "target" attribute. */ 7713 7714static tree 7715handle_target_attribute (tree *node, tree name, tree args, int flags, 7716 bool *no_add_attrs) 7717{ 7718 /* Ensure we have a function type. */ 7719 if (TREE_CODE (*node) != FUNCTION_DECL) 7720 { 7721 warning (OPT_Wattributes, "%qE attribute ignored", name); 7722 *no_add_attrs = true; 7723 } 7724 else if (! targetm.target_option.valid_attribute_p (*node, name, args, 7725 flags)) 7726 *no_add_attrs = true; 7727 7728 return NULL_TREE; 7729} 7730 7731/* Arguments being collected for optimization. */ 7732typedef const char *const_char_p; /* For DEF_VEC_P. */ 7733DEF_VEC_P(const_char_p); 7734DEF_VEC_ALLOC_P(const_char_p, gc); 7735static GTY(()) VEC(const_char_p, gc) *optimize_args; 7736 7737 7738/* Inner function to convert a TREE_LIST to argv string to parse the optimize 7739 options in ARGS. ATTR_P is true if this is for attribute(optimize), and 7740 false for #pragma GCC optimize. */ 7741 7742bool 7743parse_optimize_options (tree args, bool attr_p) 7744{ 7745 bool ret = true; 7746 unsigned opt_argc; 7747 unsigned i; 7748 int saved_flag_strict_aliasing; 7749 const char **opt_argv; 7750 tree ap; 7751 7752 /* Build up argv vector. Just in case the string is stored away, use garbage 7753 collected strings. */ 7754 VEC_truncate (const_char_p, optimize_args, 0); 7755 VEC_safe_push (const_char_p, gc, optimize_args, NULL); 7756 7757 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap)) 7758 { 7759 tree value = TREE_VALUE (ap); 7760 7761 if (TREE_CODE (value) == INTEGER_CST) 7762 { 7763 char buffer[20]; 7764 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value)); 7765 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer)); 7766 } 7767 7768 else if (TREE_CODE (value) == STRING_CST) 7769 { 7770 /* Split string into multiple substrings. */ 7771 size_t len = TREE_STRING_LENGTH (value); 7772 char *p = ASTRDUP (TREE_STRING_POINTER (value)); 7773 char *end = p + len; 7774 char *comma; 7775 char *next_p = p; 7776 7777 while (next_p != NULL) 7778 { 7779 size_t len2; 7780 char *q, *r; 7781 7782 p = next_p; 7783 comma = strchr (p, ','); 7784 if (comma) 7785 { 7786 len2 = comma - p; 7787 *comma = '\0'; 7788 next_p = comma+1; 7789 } 7790 else 7791 { 7792 len2 = end - p; 7793 next_p = NULL; 7794 } 7795 7796 r = q = (char *) ggc_alloc (len2 + 3); 7797 7798 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx 7799 options. */ 7800 if (*p == '-' && p[1] != 'O' && p[1] != 'f') 7801 { 7802 ret = false; 7803 if (attr_p) 7804 warning (OPT_Wattributes, 7805 "Bad option %s to optimize attribute.", p); 7806 else 7807 warning (OPT_Wpragmas, 7808 "Bad option %s to pragma attribute", p); 7809 continue; 7810 } 7811 7812 if (*p != '-') 7813 { 7814 *r++ = '-'; 7815 7816 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by 7817 itself is -Os, and any other switch begins with a -f. */ 7818 if ((*p >= '0' && *p <= '9') 7819 || (p[0] == 's' && p[1] == '\0')) 7820 *r++ = 'O'; 7821 else if (*p != 'O') 7822 *r++ = 'f'; 7823 } 7824 7825 memcpy (r, p, len2); 7826 r[len2] = '\0'; 7827 VEC_safe_push (const_char_p, gc, optimize_args, q); 7828 } 7829 7830 } 7831 } 7832 7833 opt_argc = VEC_length (const_char_p, optimize_args); 7834 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1)); 7835 7836 for (i = 1; i < opt_argc; i++) 7837 opt_argv[i] = VEC_index (const_char_p, optimize_args, i); 7838 7839 saved_flag_strict_aliasing = flag_strict_aliasing; 7840 7841 /* Now parse the options. */ 7842 decode_options (opt_argc, opt_argv); 7843 7844 targetm.override_options_after_change(); 7845 7846 /* Don't allow changing -fstrict-aliasing. */ 7847 flag_strict_aliasing = saved_flag_strict_aliasing; 7848 7849 VEC_truncate (const_char_p, optimize_args, 0); 7850 return ret; 7851} 7852 7853/* For handling "optimize" attribute. arguments as in 7854 struct attribute_spec.handler. */ 7855 7856static tree 7857handle_optimize_attribute (tree *node, tree name, tree args, 7858 int ARG_UNUSED (flags), bool *no_add_attrs) 7859{ 7860 /* Ensure we have a function type. */ 7861 if (TREE_CODE (*node) != FUNCTION_DECL) 7862 { 7863 warning (OPT_Wattributes, "%qE attribute ignored", name); 7864 *no_add_attrs = true; 7865 } 7866 else 7867 { 7868 struct cl_optimization cur_opts; 7869 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node); 7870 7871 /* Save current options. */ 7872 cl_optimization_save (&cur_opts); 7873 7874 /* If we previously had some optimization options, use them as the 7875 default. */ 7876 if (old_opts) 7877 cl_optimization_restore (TREE_OPTIMIZATION (old_opts)); 7878 7879 /* Parse options, and update the vector. */ 7880 parse_optimize_options (args, true); 7881 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) 7882 = build_optimization_node (); 7883 7884 /* Restore current options. */ 7885 cl_optimization_restore (&cur_opts); 7886 } 7887 7888 return NULL_TREE; 7889} 7890 7891/* Check for valid arguments being passed to a function. 7892 ATTRS is a list of attributes. There are NARGS arguments in the array 7893 ARGARRAY. TYPELIST is the list of argument types for the function. 7894 */ 7895void 7896check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist) 7897{ 7898 /* Check for null being passed in a pointer argument that must be 7899 non-null. We also need to do this if format checking is enabled. */ 7900 7901 if (warn_nonnull) 7902 check_function_nonnull (attrs, nargs, argarray); 7903 7904 /* Check for errors in format strings. */ 7905 7906 if (warn_format || warn_missing_format_attribute) 7907 check_function_format (attrs, nargs, argarray); 7908 7909 if (warn_format) 7910 check_function_sentinel (attrs, nargs, argarray, typelist); 7911} 7912 7913/* Generic argument checking recursion routine. PARAM is the argument to 7914 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked 7915 once the argument is resolved. CTX is context for the callback. */ 7916void 7917check_function_arguments_recurse (void (*callback) 7918 (void *, tree, unsigned HOST_WIDE_INT), 7919 void *ctx, tree param, 7920 unsigned HOST_WIDE_INT param_num) 7921{ 7922 if (CONVERT_EXPR_P (param) 7923 && (TYPE_PRECISION (TREE_TYPE (param)) 7924 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0))))) 7925 { 7926 /* Strip coercion. */ 7927 check_function_arguments_recurse (callback, ctx, 7928 TREE_OPERAND (param, 0), param_num); 7929 return; 7930 } 7931 7932 if (TREE_CODE (param) == CALL_EXPR) 7933 { 7934 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param))); 7935 tree attrs; 7936 bool found_format_arg = false; 7937 7938 /* See if this is a call to a known internationalization function 7939 that modifies a format arg. Such a function may have multiple 7940 format_arg attributes (for example, ngettext). */ 7941 7942 for (attrs = TYPE_ATTRIBUTES (type); 7943 attrs; 7944 attrs = TREE_CHAIN (attrs)) 7945 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs))) 7946 { 7947 tree inner_arg; 7948 tree format_num_expr; 7949 int format_num; 7950 int i; 7951 call_expr_arg_iterator iter; 7952 7953 /* Extract the argument number, which was previously checked 7954 to be valid. */ 7955 format_num_expr = TREE_VALUE (TREE_VALUE (attrs)); 7956 7957 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST 7958 && !TREE_INT_CST_HIGH (format_num_expr)); 7959 7960 format_num = TREE_INT_CST_LOW (format_num_expr); 7961 7962 for (inner_arg = first_call_expr_arg (param, &iter), i = 1; 7963 inner_arg != 0; 7964 inner_arg = next_call_expr_arg (&iter), i++) 7965 if (i == format_num) 7966 { 7967 check_function_arguments_recurse (callback, ctx, 7968 inner_arg, param_num); 7969 found_format_arg = true; 7970 break; 7971 } 7972 } 7973 7974 /* If we found a format_arg attribute and did a recursive check, 7975 we are done with checking this argument. Otherwise, we continue 7976 and this will be considered a non-literal. */ 7977 if (found_format_arg) 7978 return; 7979 } 7980 7981 if (TREE_CODE (param) == COND_EXPR) 7982 { 7983 /* Check both halves of the conditional expression. */ 7984 check_function_arguments_recurse (callback, ctx, 7985 TREE_OPERAND (param, 1), param_num); 7986 check_function_arguments_recurse (callback, ctx, 7987 TREE_OPERAND (param, 2), param_num); 7988 return; 7989 } 7990 7991 (*callback) (ctx, param, param_num); 7992} 7993 7994/* Checks for a builtin function FNDECL that the number of arguments 7995 NARGS against the required number REQUIRED and issues an error if 7996 there is a mismatch. Returns true if the number of arguments is 7997 correct, otherwise false. */ 7998 7999static bool 8000builtin_function_validate_nargs (tree fndecl, int nargs, int required) 8001{ 8002 if (nargs < required) 8003 { 8004 error_at (input_location, 8005 "not enough arguments to function %qE", fndecl); 8006 return false; 8007 } 8008 else if (nargs > required) 8009 { 8010 error_at (input_location, 8011 "too many arguments to function %qE", fndecl); 8012 return false; 8013 } 8014 return true; 8015} 8016 8017/* Verifies the NARGS arguments ARGS to the builtin function FNDECL. 8018 Returns false if there was an error, otherwise true. */ 8019 8020bool 8021check_builtin_function_arguments (tree fndecl, int nargs, tree *args) 8022{ 8023 if (!DECL_BUILT_IN (fndecl) 8024 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL) 8025 return true; 8026 8027 switch (DECL_FUNCTION_CODE (fndecl)) 8028 { 8029 case BUILT_IN_CONSTANT_P: 8030 return builtin_function_validate_nargs (fndecl, nargs, 1); 8031 8032 case BUILT_IN_ISFINITE: 8033 case BUILT_IN_ISINF: 8034 case BUILT_IN_ISINF_SIGN: 8035 case BUILT_IN_ISNAN: 8036 case BUILT_IN_ISNORMAL: 8037 if (builtin_function_validate_nargs (fndecl, nargs, 1)) 8038 { 8039 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE) 8040 { 8041 error ("non-floating-point argument in call to " 8042 "function %qE", fndecl); 8043 return false; 8044 } 8045 return true; 8046 } 8047 return false; 8048 8049 case BUILT_IN_ISGREATER: 8050 case BUILT_IN_ISGREATEREQUAL: 8051 case BUILT_IN_ISLESS: 8052 case BUILT_IN_ISLESSEQUAL: 8053 case BUILT_IN_ISLESSGREATER: 8054 case BUILT_IN_ISUNORDERED: 8055 if (builtin_function_validate_nargs (fndecl, nargs, 2)) 8056 { 8057 enum tree_code code0, code1; 8058 code0 = TREE_CODE (TREE_TYPE (args[0])); 8059 code1 = TREE_CODE (TREE_TYPE (args[1])); 8060 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE) 8061 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE) 8062 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE))) 8063 { 8064 error ("non-floating-point arguments in call to " 8065 "function %qE", fndecl); 8066 return false; 8067 } 8068 return true; 8069 } 8070 return false; 8071 8072 case BUILT_IN_FPCLASSIFY: 8073 if (builtin_function_validate_nargs (fndecl, nargs, 6)) 8074 { 8075 unsigned i; 8076 8077 for (i=0; i<5; i++) 8078 if (TREE_CODE (args[i]) != INTEGER_CST) 8079 { 8080 error ("non-const integer argument %u in call to function %qE", 8081 i+1, fndecl); 8082 return false; 8083 } 8084 8085 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE) 8086 { 8087 error ("non-floating-point argument in call to function %qE", 8088 fndecl); 8089 return false; 8090 } 8091 return true; 8092 } 8093 return false; 8094 8095 default: 8096 return true; 8097 } 8098} 8099 8100/* Function to help qsort sort FIELD_DECLs by name order. */ 8101 8102int 8103field_decl_cmp (const void *x_p, const void *y_p) 8104{ 8105 const tree *const x = (const tree *const) x_p; 8106 const tree *const y = (const tree *const) y_p; 8107 8108 if (DECL_NAME (*x) == DECL_NAME (*y)) 8109 /* A nontype is "greater" than a type. */ 8110 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL); 8111 if (DECL_NAME (*x) == NULL_TREE) 8112 return -1; 8113 if (DECL_NAME (*y) == NULL_TREE) 8114 return 1; 8115 if (DECL_NAME (*x) < DECL_NAME (*y)) 8116 return -1; 8117 return 1; 8118} 8119 8120static struct { 8121 gt_pointer_operator new_value; 8122 void *cookie; 8123} resort_data; 8124 8125/* This routine compares two fields like field_decl_cmp but using the 8126pointer operator in resort_data. */ 8127 8128static int 8129resort_field_decl_cmp (const void *x_p, const void *y_p) 8130{ 8131 const tree *const x = (const tree *const) x_p; 8132 const tree *const y = (const tree *const) y_p; 8133 8134 if (DECL_NAME (*x) == DECL_NAME (*y)) 8135 /* A nontype is "greater" than a type. */ 8136 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL); 8137 if (DECL_NAME (*x) == NULL_TREE) 8138 return -1; 8139 if (DECL_NAME (*y) == NULL_TREE) 8140 return 1; 8141 { 8142 tree d1 = DECL_NAME (*x); 8143 tree d2 = DECL_NAME (*y); 8144 resort_data.new_value (&d1, resort_data.cookie); 8145 resort_data.new_value (&d2, resort_data.cookie); 8146 if (d1 < d2) 8147 return -1; 8148 } 8149 return 1; 8150} 8151 8152/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */ 8153 8154void 8155resort_sorted_fields (void *obj, 8156 void * ARG_UNUSED (orig_obj), 8157 gt_pointer_operator new_value, 8158 void *cookie) 8159{ 8160 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj; 8161 resort_data.new_value = new_value; 8162 resort_data.cookie = cookie; 8163 qsort (&sf->elts[0], sf->len, sizeof (tree), 8164 resort_field_decl_cmp); 8165} 8166 8167/* Subroutine of c_parse_error. 8168 Return the result of concatenating LHS and RHS. RHS is really 8169 a string literal, its first character is indicated by RHS_START and 8170 RHS_SIZE is its length (including the terminating NUL character). 8171 8172 The caller is responsible for deleting the returned pointer. */ 8173 8174static char * 8175catenate_strings (const char *lhs, const char *rhs_start, int rhs_size) 8176{ 8177 const int lhs_size = strlen (lhs); 8178 char *result = XNEWVEC (char, lhs_size + rhs_size); 8179 strncpy (result, lhs, lhs_size); 8180 strncpy (result + lhs_size, rhs_start, rhs_size); 8181 return result; 8182} 8183 8184/* Issue the error given by GMSGID, indicating that it occurred before 8185 TOKEN, which had the associated VALUE. */ 8186 8187void 8188c_parse_error (const char *gmsgid, enum cpp_ttype token_type, 8189 tree value, unsigned char token_flags) 8190{ 8191#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2)) 8192 8193 char *message = NULL; 8194 8195 if (token_type == CPP_EOF) 8196 message = catenate_messages (gmsgid, " at end of input"); 8197 else if (token_type == CPP_CHAR 8198 || token_type == CPP_WCHAR 8199 || token_type == CPP_CHAR16 8200 || token_type == CPP_CHAR32) 8201 { 8202 unsigned int val = TREE_INT_CST_LOW (value); 8203 const char *prefix; 8204 8205 switch (token_type) 8206 { 8207 default: 8208 prefix = ""; 8209 break; 8210 case CPP_WCHAR: 8211 prefix = "L"; 8212 break; 8213 case CPP_CHAR16: 8214 prefix = "u"; 8215 break; 8216 case CPP_CHAR32: 8217 prefix = "U"; 8218 break; 8219 } 8220 8221 if (val <= UCHAR_MAX && ISGRAPH (val)) 8222 message = catenate_messages (gmsgid, " before %s'%c'"); 8223 else 8224 message = catenate_messages (gmsgid, " before %s'\\x%x'"); 8225 8226 error (message, prefix, val); 8227 free (message); 8228 message = NULL; 8229 } 8230 else if (token_type == CPP_STRING 8231 || token_type == CPP_WSTRING 8232 || token_type == CPP_STRING16 8233 || token_type == CPP_STRING32 8234 || token_type == CPP_UTF8STRING) 8235 message = catenate_messages (gmsgid, " before string constant"); 8236 else if (token_type == CPP_NUMBER) 8237 message = catenate_messages (gmsgid, " before numeric constant"); 8238 else if (token_type == CPP_NAME) 8239 { 8240 message = catenate_messages (gmsgid, " before %qE"); 8241 error (message, value); 8242 free (message); 8243 message = NULL; 8244 } 8245 else if (token_type == CPP_PRAGMA) 8246 message = catenate_messages (gmsgid, " before %<#pragma%>"); 8247 else if (token_type == CPP_PRAGMA_EOL) 8248 message = catenate_messages (gmsgid, " before end of line"); 8249 else if (token_type < N_TTYPES) 8250 { 8251 message = catenate_messages (gmsgid, " before %qs token"); 8252 error (message, cpp_type2name (token_type, token_flags)); 8253 free (message); 8254 message = NULL; 8255 } 8256 else 8257 error (gmsgid); 8258 8259 if (message) 8260 { 8261 error (message); 8262 free (message); 8263 } 8264#undef catenate_messages 8265} 8266 8267/* Callback from cpp_error for PFILE to print diagnostics from the 8268 preprocessor. The diagnostic is of type LEVEL, at location 8269 LOCATION unless this is after lexing and the compiler's location 8270 should be used instead, with column number possibly overridden by 8271 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP 8272 the arguments. Returns true if a diagnostic was emitted, false 8273 otherwise. */ 8274 8275bool 8276c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, 8277 location_t location, unsigned int column_override, 8278 const char *msg, va_list *ap) 8279{ 8280 diagnostic_info diagnostic; 8281 diagnostic_t dlevel; 8282 int save_warn_system_headers = warn_system_headers; 8283 bool ret; 8284 8285 switch (level) 8286 { 8287 case CPP_DL_WARNING_SYSHDR: 8288 if (flag_no_output) 8289 return false; 8290 warn_system_headers = 1; 8291 /* Fall through. */ 8292 case CPP_DL_WARNING: 8293 if (flag_no_output) 8294 return false; 8295 dlevel = DK_WARNING; 8296 break; 8297 case CPP_DL_PEDWARN: 8298 if (flag_no_output && !flag_pedantic_errors) 8299 return false; 8300 dlevel = DK_PEDWARN; 8301 break; 8302 case CPP_DL_ERROR: 8303 dlevel = DK_ERROR; 8304 break; 8305 case CPP_DL_ICE: 8306 dlevel = DK_ICE; 8307 break; 8308 case CPP_DL_NOTE: 8309 dlevel = DK_NOTE; 8310 break; 8311 case CPP_DL_FATAL: 8312 dlevel = DK_FATAL; 8313 break; 8314 default: 8315 gcc_unreachable (); 8316 } 8317 if (done_lexing) 8318 location = input_location; 8319 diagnostic_set_info_translated (&diagnostic, msg, ap, 8320 location, dlevel); 8321 if (column_override) 8322 diagnostic_override_column (&diagnostic, column_override); 8323 ret = report_diagnostic (&diagnostic); 8324 if (level == CPP_DL_WARNING_SYSHDR) 8325 warn_system_headers = save_warn_system_headers; 8326 return ret; 8327} 8328 8329/* Convert a character from the host to the target execution character 8330 set. cpplib handles this, mostly. */ 8331 8332HOST_WIDE_INT 8333c_common_to_target_charset (HOST_WIDE_INT c) 8334{ 8335 /* Character constants in GCC proper are sign-extended under -fsigned-char, 8336 zero-extended under -fno-signed-char. cpplib insists that characters 8337 and character constants are always unsigned. Hence we must convert 8338 back and forth. */ 8339 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1); 8340 8341 uc = cpp_host_to_exec_charset (parse_in, uc); 8342 8343 if (flag_signed_char) 8344 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE) 8345 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE); 8346 else 8347 return uc; 8348} 8349 8350/* Build the result of __builtin_offsetof. EXPR is a nested sequence of 8351 component references, with STOP_REF, or alternatively an INDIRECT_REF of 8352 NULL, at the bottom; much like the traditional rendering of offsetof as a 8353 macro. Returns the folded and properly cast result. */ 8354 8355static tree 8356fold_offsetof_1 (tree expr, tree stop_ref) 8357{ 8358 enum tree_code code = PLUS_EXPR; 8359 tree base, off, t; 8360 8361 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK) 8362 return size_zero_node; 8363 8364 switch (TREE_CODE (expr)) 8365 { 8366 case ERROR_MARK: 8367 return expr; 8368 8369 case VAR_DECL: 8370 error ("cannot apply %<offsetof%> to static data member %qD", expr); 8371 return error_mark_node; 8372 8373 case CALL_EXPR: 8374 case TARGET_EXPR: 8375 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded"); 8376 return error_mark_node; 8377 8378 case NOP_EXPR: 8379 case INDIRECT_REF: 8380 if (!integer_zerop (TREE_OPERAND (expr, 0))) 8381 { 8382 error ("cannot apply %<offsetof%> to a non constant address"); 8383 return error_mark_node; 8384 } 8385 return size_zero_node; 8386 8387 case COMPONENT_REF: 8388 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref); 8389 if (base == error_mark_node) 8390 return base; 8391 8392 t = TREE_OPERAND (expr, 1); 8393 if (DECL_C_BIT_FIELD (t)) 8394 { 8395 error ("attempt to take address of bit-field structure " 8396 "member %qD", t); 8397 return error_mark_node; 8398 } 8399 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t), 8400 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 8401 1) 8402 / BITS_PER_UNIT)); 8403 break; 8404 8405 case ARRAY_REF: 8406 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref); 8407 if (base == error_mark_node) 8408 return base; 8409 8410 t = TREE_OPERAND (expr, 1); 8411 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0) 8412 { 8413 code = MINUS_EXPR; 8414 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t); 8415 } 8416 t = convert (sizetype, t); 8417 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t); 8418 8419 /* Check if the offset goes beyond the upper bound of the array. */ 8420 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST) 8421 { 8422 tree upbound = array_ref_up_bound (expr); 8423 if (upbound != NULL_TREE 8424 && TREE_CODE (upbound) == INTEGER_CST 8425 && !tree_int_cst_equal (upbound, 8426 TYPE_MAX_VALUE (TREE_TYPE (upbound)))) 8427 { 8428 upbound = size_binop (PLUS_EXPR, upbound, 8429 build_int_cst (TREE_TYPE (upbound), 1)); 8430 if (tree_int_cst_lt (upbound, t)) 8431 { 8432 tree v; 8433 8434 for (v = TREE_OPERAND (expr, 0); 8435 TREE_CODE (v) == COMPONENT_REF; 8436 v = TREE_OPERAND (v, 0)) 8437 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) 8438 == RECORD_TYPE) 8439 { 8440 tree fld_chain = TREE_CHAIN (TREE_OPERAND (v, 1)); 8441 for (; fld_chain; fld_chain = TREE_CHAIN (fld_chain)) 8442 if (TREE_CODE (fld_chain) == FIELD_DECL) 8443 break; 8444 8445 if (fld_chain) 8446 break; 8447 } 8448 /* Don't warn if the array might be considered a poor 8449 man's flexible array member with a very permissive 8450 definition thereof. */ 8451 if (TREE_CODE (v) == ARRAY_REF 8452 || TREE_CODE (v) == COMPONENT_REF) 8453 warning (OPT_Warray_bounds, 8454 "index %E denotes an offset " 8455 "greater than size of %qT", 8456 t, TREE_TYPE (TREE_OPERAND (expr, 0))); 8457 } 8458 } 8459 } 8460 break; 8461 8462 case COMPOUND_EXPR: 8463 /* Handle static members of volatile structs. */ 8464 t = TREE_OPERAND (expr, 1); 8465 gcc_assert (TREE_CODE (t) == VAR_DECL); 8466 return fold_offsetof_1 (t, stop_ref); 8467 8468 default: 8469 gcc_unreachable (); 8470 } 8471 8472 return size_binop (code, base, off); 8473} 8474 8475tree 8476fold_offsetof (tree expr, tree stop_ref) 8477{ 8478 /* Convert back from the internal sizetype to size_t. */ 8479 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref)); 8480} 8481 8482/* Print an error message for an invalid lvalue. USE says 8483 how the lvalue is being used and so selects the error message. */ 8484 8485void 8486lvalue_error (enum lvalue_use use) 8487{ 8488 switch (use) 8489 { 8490 case lv_assign: 8491 error ("lvalue required as left operand of assignment"); 8492 break; 8493 case lv_increment: 8494 error ("lvalue required as increment operand"); 8495 break; 8496 case lv_decrement: 8497 error ("lvalue required as decrement operand"); 8498 break; 8499 case lv_addressof: 8500 error ("lvalue required as unary %<&%> operand"); 8501 break; 8502 case lv_asm: 8503 error ("lvalue required in asm statement"); 8504 break; 8505 default: 8506 gcc_unreachable (); 8507 } 8508} 8509 8510/* *PTYPE is an incomplete array. Complete it with a domain based on 8511 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT 8512 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 8513 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */ 8514 8515int 8516complete_array_type (tree *ptype, tree initial_value, bool do_default) 8517{ 8518 tree maxindex, type, main_type, elt, unqual_elt; 8519 int failure = 0, quals; 8520 hashval_t hashcode = 0; 8521 8522 maxindex = size_zero_node; 8523 if (initial_value) 8524 { 8525 if (TREE_CODE (initial_value) == STRING_CST) 8526 { 8527 int eltsize 8528 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); 8529 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1); 8530 } 8531 else if (TREE_CODE (initial_value) == CONSTRUCTOR) 8532 { 8533 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value); 8534 8535 if (VEC_empty (constructor_elt, v)) 8536 { 8537 if (pedantic) 8538 failure = 3; 8539 maxindex = integer_minus_one_node; 8540 } 8541 else 8542 { 8543 tree curindex; 8544 unsigned HOST_WIDE_INT cnt; 8545 constructor_elt *ce; 8546 bool fold_p = false; 8547 8548 if (VEC_index (constructor_elt, v, 0)->index) 8549 maxindex = fold_convert_loc (input_location, sizetype, 8550 VEC_index (constructor_elt, 8551 v, 0)->index); 8552 curindex = maxindex; 8553 8554 for (cnt = 1; 8555 VEC_iterate (constructor_elt, v, cnt, ce); 8556 cnt++) 8557 { 8558 bool curfold_p = false; 8559 if (ce->index) 8560 curindex = ce->index, curfold_p = true; 8561 else 8562 { 8563 if (fold_p) 8564 curindex = fold_convert (sizetype, curindex); 8565 curindex = size_binop (PLUS_EXPR, curindex, 8566 size_one_node); 8567 } 8568 if (tree_int_cst_lt (maxindex, curindex)) 8569 maxindex = curindex, fold_p = curfold_p; 8570 } 8571 if (fold_p) 8572 maxindex = fold_convert (sizetype, maxindex); 8573 } 8574 } 8575 else 8576 { 8577 /* Make an error message unless that happened already. */ 8578 if (initial_value != error_mark_node) 8579 failure = 1; 8580 } 8581 } 8582 else 8583 { 8584 failure = 2; 8585 if (!do_default) 8586 return failure; 8587 } 8588 8589 type = *ptype; 8590 elt = TREE_TYPE (type); 8591 quals = TYPE_QUALS (strip_array_types (elt)); 8592 if (quals == 0) 8593 unqual_elt = elt; 8594 else 8595 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals)); 8596 8597 /* Using build_distinct_type_copy and modifying things afterward instead 8598 of using build_array_type to create a new type preserves all of the 8599 TYPE_LANG_FLAG_? bits that the front end may have set. */ 8600 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 8601 TREE_TYPE (main_type) = unqual_elt; 8602 TYPE_DOMAIN (main_type) = build_index_type (maxindex); 8603 layout_type (main_type); 8604 8605 /* Make sure we have the canonical MAIN_TYPE. */ 8606 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode); 8607 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)), 8608 hashcode); 8609 main_type = type_hash_canon (hashcode, main_type); 8610 8611 /* Fix the canonical type. */ 8612 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type)) 8613 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type))) 8614 SET_TYPE_STRUCTURAL_EQUALITY (main_type); 8615 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type) 8616 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type)) 8617 != TYPE_DOMAIN (main_type))) 8618 TYPE_CANONICAL (main_type) 8619 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)), 8620 TYPE_CANONICAL (TYPE_DOMAIN (main_type))); 8621 else 8622 TYPE_CANONICAL (main_type) = main_type; 8623 8624 if (quals == 0) 8625 type = main_type; 8626 else 8627 type = c_build_qualified_type (main_type, quals); 8628 8629 if (COMPLETE_TYPE_P (type) 8630 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST 8631 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type))) 8632 { 8633 error ("size of array is too large"); 8634 /* If we proceed with the array type as it is, we'll eventually 8635 crash in tree_low_cst(). */ 8636 type = error_mark_node; 8637 } 8638 8639 *ptype = type; 8640 return failure; 8641} 8642 8643 8644/* Used to help initialize the builtin-types.def table. When a type of 8645 the correct size doesn't exist, use error_mark_node instead of NULL. 8646 The later results in segfaults even when a decl using the type doesn't 8647 get invoked. */ 8648 8649tree 8650builtin_type_for_size (int size, bool unsignedp) 8651{ 8652 tree type = lang_hooks.types.type_for_size (size, unsignedp); 8653 return type ? type : error_mark_node; 8654} 8655 8656/* A helper function for resolve_overloaded_builtin in resolving the 8657 overloaded __sync_ builtins. Returns a positive power of 2 if the 8658 first operand of PARAMS is a pointer to a supported data type. 8659 Returns 0 if an error is encountered. */ 8660 8661static int 8662sync_resolve_size (tree function, VEC(tree,gc) *params) 8663{ 8664 tree type; 8665 int size; 8666 8667 if (VEC_empty (tree, params)) 8668 { 8669 error ("too few arguments to function %qE", function); 8670 return 0; 8671 } 8672 8673 type = TREE_TYPE (VEC_index (tree, params, 0)); 8674 if (TREE_CODE (type) != POINTER_TYPE) 8675 goto incompatible; 8676 8677 type = TREE_TYPE (type); 8678 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type)) 8679 goto incompatible; 8680 8681 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1); 8682 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16) 8683 return size; 8684 8685 incompatible: 8686 error ("incompatible type for argument %d of %qE", 1, function); 8687 return 0; 8688} 8689 8690/* A helper function for resolve_overloaded_builtin. Adds casts to 8691 PARAMS to make arguments match up with those of FUNCTION. Drops 8692 the variadic arguments at the end. Returns false if some error 8693 was encountered; true on success. */ 8694 8695static bool 8696sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params) 8697{ 8698 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function)); 8699 tree ptype; 8700 int number; 8701 unsigned int parmnum; 8702 8703 /* We've declared the implementation functions to use "volatile void *" 8704 as the pointer parameter, so we shouldn't get any complaints from the 8705 call to check_function_arguments what ever type the user used. */ 8706 arg_types = TREE_CHAIN (arg_types); 8707 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0))); 8708 number = 2; 8709 8710 /* For the rest of the values, we need to cast these to FTYPE, so that we 8711 don't get warnings for passing pointer types, etc. */ 8712 parmnum = 0; 8713 while (arg_types != void_list_node) 8714 { 8715 tree val; 8716 8717 ++parmnum; 8718 if (VEC_length (tree, params) <= parmnum) 8719 { 8720 error ("too few arguments to function %qE", orig_function); 8721 return false; 8722 } 8723 8724 /* ??? Ideally for the first conversion we'd use convert_for_assignment 8725 so that we get warnings for anything that doesn't match the pointer 8726 type. This isn't portable across the C and C++ front ends atm. */ 8727 val = VEC_index (tree, params, parmnum); 8728 val = convert (ptype, val); 8729 val = convert (TREE_VALUE (arg_types), val); 8730 VEC_replace (tree, params, parmnum, val); 8731 8732 arg_types = TREE_CHAIN (arg_types); 8733 number++; 8734 } 8735 8736 /* The definition of these primitives is variadic, with the remaining 8737 being "an optional list of variables protected by the memory barrier". 8738 No clue what that's supposed to mean, precisely, but we consider all 8739 call-clobbered variables to be protected so we're safe. */ 8740 VEC_truncate (tree, params, parmnum + 1); 8741 8742 return true; 8743} 8744 8745/* A helper function for resolve_overloaded_builtin. Adds a cast to 8746 RESULT to make it match the type of the first pointer argument in 8747 PARAMS. */ 8748 8749static tree 8750sync_resolve_return (tree first_param, tree result) 8751{ 8752 tree ptype = TREE_TYPE (TREE_TYPE (first_param)); 8753 ptype = TYPE_MAIN_VARIANT (ptype); 8754 return convert (ptype, result); 8755} 8756 8757/* Some builtin functions are placeholders for other expressions. This 8758 function should be called immediately after parsing the call expression 8759 before surrounding code has committed to the type of the expression. 8760 8761 LOC is the location of the builtin call. 8762 8763 FUNCTION is the DECL that has been invoked; it is known to be a builtin. 8764 PARAMS is the argument list for the call. The return value is non-null 8765 when expansion is complete, and null if normal processing should 8766 continue. */ 8767 8768tree 8769resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params) 8770{ 8771 enum built_in_function orig_code = DECL_FUNCTION_CODE (function); 8772 switch (DECL_BUILT_IN_CLASS (function)) 8773 { 8774 case BUILT_IN_NORMAL: 8775 break; 8776 case BUILT_IN_MD: 8777 if (targetm.resolve_overloaded_builtin) 8778 return targetm.resolve_overloaded_builtin (loc, function, params); 8779 else 8780 return NULL_TREE; 8781 default: 8782 return NULL_TREE; 8783 } 8784 8785 /* Handle BUILT_IN_NORMAL here. */ 8786 switch (orig_code) 8787 { 8788 case BUILT_IN_FETCH_AND_ADD_N: 8789 case BUILT_IN_FETCH_AND_SUB_N: 8790 case BUILT_IN_FETCH_AND_OR_N: 8791 case BUILT_IN_FETCH_AND_AND_N: 8792 case BUILT_IN_FETCH_AND_XOR_N: 8793 case BUILT_IN_FETCH_AND_NAND_N: 8794 case BUILT_IN_ADD_AND_FETCH_N: 8795 case BUILT_IN_SUB_AND_FETCH_N: 8796 case BUILT_IN_OR_AND_FETCH_N: 8797 case BUILT_IN_AND_AND_FETCH_N: 8798 case BUILT_IN_XOR_AND_FETCH_N: 8799 case BUILT_IN_NAND_AND_FETCH_N: 8800 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N: 8801 case BUILT_IN_VAL_COMPARE_AND_SWAP_N: 8802 case BUILT_IN_LOCK_TEST_AND_SET_N: 8803 case BUILT_IN_LOCK_RELEASE_N: 8804 { 8805 int n = sync_resolve_size (function, params); 8806 tree new_function, first_param, result; 8807 8808 if (n == 0) 8809 return error_mark_node; 8810 8811 new_function = built_in_decls[orig_code + exact_log2 (n) + 1]; 8812 if (!sync_resolve_params (function, new_function, params)) 8813 return error_mark_node; 8814 8815 first_param = VEC_index (tree, params, 0); 8816 result = build_function_call_vec (loc, new_function, params, NULL); 8817 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N 8818 && orig_code != BUILT_IN_LOCK_RELEASE_N) 8819 result = sync_resolve_return (first_param, result); 8820 8821 return result; 8822 } 8823 8824 default: 8825 return NULL_TREE; 8826 } 8827} 8828 8829/* Ignoring their sign, return true if two scalar types are the same. */ 8830bool 8831same_scalar_type_ignoring_signedness (tree t1, tree t2) 8832{ 8833 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2); 8834 8835 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE) 8836 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE 8837 || c2 == FIXED_POINT_TYPE)); 8838 8839 /* Equality works here because c_common_signed_type uses 8840 TYPE_MAIN_VARIANT. */ 8841 return c_common_signed_type (t1) 8842 == c_common_signed_type (t2); 8843} 8844 8845/* Check for missing format attributes on function pointers. LTYPE is 8846 the new type or left-hand side type. RTYPE is the old type or 8847 right-hand side type. Returns TRUE if LTYPE is missing the desired 8848 attribute. */ 8849 8850bool 8851check_missing_format_attribute (tree ltype, tree rtype) 8852{ 8853 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype); 8854 tree ra; 8855 8856 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra)) 8857 if (is_attribute_p ("format", TREE_PURPOSE (ra))) 8858 break; 8859 if (ra) 8860 { 8861 tree la; 8862 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la)) 8863 if (is_attribute_p ("format", TREE_PURPOSE (la))) 8864 break; 8865 return !la; 8866 } 8867 else 8868 return false; 8869} 8870 8871/* Subscripting with type char is likely to lose on a machine where 8872 chars are signed. So warn on any machine, but optionally. Don't 8873 warn for unsigned char since that type is safe. Don't warn for 8874 signed char because anyone who uses that must have done so 8875 deliberately. Furthermore, we reduce the false positive load by 8876 warning only for non-constant value of type char. */ 8877 8878void 8879warn_array_subscript_with_type_char (tree index) 8880{ 8881 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node 8882 && TREE_CODE (index) != INTEGER_CST) 8883 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>"); 8884} 8885 8886/* Implement -Wparentheses for the unexpected C precedence rules, to 8887 cover cases like x + y << z which readers are likely to 8888 misinterpret. We have seen an expression in which CODE is a binary 8889 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which 8890 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and 8891 CODE_RIGHT may be ERROR_MARK, which means that that side of the 8892 expression was not formed using a binary or unary operator, or it 8893 was enclosed in parentheses. */ 8894 8895void 8896warn_about_parentheses (enum tree_code code, 8897 enum tree_code code_left, tree arg_left, 8898 enum tree_code code_right, tree arg_right) 8899{ 8900 if (!warn_parentheses) 8901 return; 8902 8903 /* This macro tests that the expression ARG with original tree code 8904 CODE appears to be a boolean expression. or the result of folding a 8905 boolean expression. */ 8906#define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \ 8907 (truth_value_p (TREE_CODE (ARG)) \ 8908 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \ 8909 /* Folding may create 0 or 1 integers from other expressions. */ \ 8910 || ((CODE) != INTEGER_CST \ 8911 && (integer_onep (ARG) || integer_zerop (ARG)))) 8912 8913 switch (code) 8914 { 8915 case LSHIFT_EXPR: 8916 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR) 8917 warning (OPT_Wparentheses, 8918 "suggest parentheses around %<+%> inside %<<<%>"); 8919 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR) 8920 warning (OPT_Wparentheses, 8921 "suggest parentheses around %<-%> inside %<<<%>"); 8922 return; 8923 8924 case RSHIFT_EXPR: 8925 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR) 8926 warning (OPT_Wparentheses, 8927 "suggest parentheses around %<+%> inside %<>>%>"); 8928 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR) 8929 warning (OPT_Wparentheses, 8930 "suggest parentheses around %<-%> inside %<>>%>"); 8931 return; 8932 8933 case TRUTH_ORIF_EXPR: 8934 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR) 8935 warning (OPT_Wparentheses, 8936 "suggest parentheses around %<&&%> within %<||%>"); 8937 return; 8938 8939 case BIT_IOR_EXPR: 8940 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR 8941 || code_left == PLUS_EXPR || code_left == MINUS_EXPR 8942 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR 8943 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 8944 warning (OPT_Wparentheses, 8945 "suggest parentheses around arithmetic in operand of %<|%>"); 8946 /* Check cases like x|y==z */ 8947 else if (TREE_CODE_CLASS (code_left) == tcc_comparison 8948 || TREE_CODE_CLASS (code_right) == tcc_comparison) 8949 warning (OPT_Wparentheses, 8950 "suggest parentheses around comparison in operand of %<|%>"); 8951 /* Check cases like !x | y */ 8952 else if (code_left == TRUTH_NOT_EXPR 8953 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right)) 8954 warning (OPT_Wparentheses, "suggest parentheses around operand of " 8955 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>"); 8956 return; 8957 8958 case BIT_XOR_EXPR: 8959 if (code_left == BIT_AND_EXPR 8960 || code_left == PLUS_EXPR || code_left == MINUS_EXPR 8961 || code_right == BIT_AND_EXPR 8962 || code_right == PLUS_EXPR || code_right == MINUS_EXPR) 8963 warning (OPT_Wparentheses, 8964 "suggest parentheses around arithmetic in operand of %<^%>"); 8965 /* Check cases like x^y==z */ 8966 else if (TREE_CODE_CLASS (code_left) == tcc_comparison 8967 || TREE_CODE_CLASS (code_right) == tcc_comparison) 8968 warning (OPT_Wparentheses, 8969 "suggest parentheses around comparison in operand of %<^%>"); 8970 return; 8971 8972 case BIT_AND_EXPR: 8973 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR) 8974 warning (OPT_Wparentheses, 8975 "suggest parentheses around %<+%> in operand of %<&%>"); 8976 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR) 8977 warning (OPT_Wparentheses, 8978 "suggest parentheses around %<-%> in operand of %<&%>"); 8979 /* Check cases like x&y==z */ 8980 else if (TREE_CODE_CLASS (code_left) == tcc_comparison 8981 || TREE_CODE_CLASS (code_right) == tcc_comparison) 8982 warning (OPT_Wparentheses, 8983 "suggest parentheses around comparison in operand of %<&%>"); 8984 /* Check cases like !x & y */ 8985 else if (code_left == TRUTH_NOT_EXPR 8986 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right)) 8987 warning (OPT_Wparentheses, "suggest parentheses around operand of " 8988 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>"); 8989 return; 8990 8991 case EQ_EXPR: 8992 if (TREE_CODE_CLASS (code_left) == tcc_comparison 8993 || TREE_CODE_CLASS (code_right) == tcc_comparison) 8994 warning (OPT_Wparentheses, 8995 "suggest parentheses around comparison in operand of %<==%>"); 8996 return; 8997 case NE_EXPR: 8998 if (TREE_CODE_CLASS (code_left) == tcc_comparison 8999 || TREE_CODE_CLASS (code_right) == tcc_comparison) 9000 warning (OPT_Wparentheses, 9001 "suggest parentheses around comparison in operand of %<!=%>"); 9002 return; 9003 9004 default: 9005 if (TREE_CODE_CLASS (code) == tcc_comparison 9006 && ((TREE_CODE_CLASS (code_left) == tcc_comparison 9007 && code_left != NE_EXPR && code_left != EQ_EXPR 9008 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left))) 9009 || (TREE_CODE_CLASS (code_right) == tcc_comparison 9010 && code_right != NE_EXPR && code_right != EQ_EXPR 9011 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right))))) 9012 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not " 9013 "have their mathematical meaning"); 9014 return; 9015 } 9016#undef NOT_A_BOOLEAN_EXPR_P 9017} 9018 9019/* If LABEL (a LABEL_DECL) has not been used, issue a warning. */ 9020 9021void 9022warn_for_unused_label (tree label) 9023{ 9024 if (!TREE_USED (label)) 9025 { 9026 if (DECL_INITIAL (label)) 9027 warning (OPT_Wunused_label, "label %q+D defined but not used", label); 9028 else 9029 warning (OPT_Wunused_label, "label %q+D declared but not defined", label); 9030 } 9031} 9032 9033#ifndef TARGET_HAS_TARGETCM 9034struct gcc_targetcm targetcm = TARGETCM_INITIALIZER; 9035#endif 9036 9037/* Warn for division by zero according to the value of DIVISOR. LOC 9038 is the location of the division operator. */ 9039 9040void 9041warn_for_div_by_zero (location_t loc, tree divisor) 9042{ 9043 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning 9044 about division by zero. Do not issue a warning if DIVISOR has a 9045 floating-point type, since we consider 0.0/0.0 a valid way of 9046 generating a NaN. */ 9047 if (c_inhibit_evaluation_warnings == 0 9048 && (integer_zerop (divisor) || fixed_zerop (divisor))) 9049 warning_at (loc, OPT_Wdiv_by_zero, "division by zero"); 9050} 9051 9052/* Subroutine of build_binary_op. Give warnings for comparisons 9053 between signed and unsigned quantities that may fail. Do the 9054 checking based on the original operand trees ORIG_OP0 and ORIG_OP1, 9055 so that casts will be considered, but default promotions won't 9056 be. 9057 9058 LOCATION is the location of the comparison operator. 9059 9060 The arguments of this function map directly to local variables 9061 of build_binary_op. */ 9062 9063void 9064warn_for_sign_compare (location_t location, 9065 tree orig_op0, tree orig_op1, 9066 tree op0, tree op1, 9067 tree result_type, enum tree_code resultcode) 9068{ 9069 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 9070 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 9071 int unsignedp0, unsignedp1; 9072 9073 /* In C++, check for comparison of different enum types. */ 9074 if (c_dialect_cxx() 9075 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE 9076 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE 9077 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) 9078 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) 9079 { 9080 warning_at (location, 9081 OPT_Wsign_compare, "comparison between types %qT and %qT", 9082 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); 9083 } 9084 9085 /* Do not warn if the comparison is being done in a signed type, 9086 since the signed type will only be chosen if it can represent 9087 all the values of the unsigned type. */ 9088 if (!TYPE_UNSIGNED (result_type)) 9089 /* OK */; 9090 /* Do not warn if both operands are unsigned. */ 9091 else if (op0_signed == op1_signed) 9092 /* OK */; 9093 else 9094 { 9095 tree sop, uop, base_type; 9096 bool ovf; 9097 9098 if (op0_signed) 9099 sop = orig_op0, uop = orig_op1; 9100 else 9101 sop = orig_op1, uop = orig_op0; 9102 9103 STRIP_TYPE_NOPS (sop); 9104 STRIP_TYPE_NOPS (uop); 9105 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE 9106 ? TREE_TYPE (result_type) : result_type); 9107 9108 /* Do not warn if the signed quantity is an unsuffixed integer 9109 literal (or some static constant expression involving such 9110 literals or a conditional expression involving such literals) 9111 and it is non-negative. */ 9112 if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 9113 /* OK */; 9114 /* Do not warn if the comparison is an equality operation, the 9115 unsigned quantity is an integral constant, and it would fit 9116 in the result if the result were signed. */ 9117 else if (TREE_CODE (uop) == INTEGER_CST 9118 && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 9119 && int_fits_type_p (uop, c_common_signed_type (base_type))) 9120 /* OK */; 9121 /* In C, do not warn if the unsigned quantity is an enumeration 9122 constant and its maximum value would fit in the result if the 9123 result were signed. */ 9124 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST 9125 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 9126 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)), 9127 c_common_signed_type (base_type))) 9128 /* OK */; 9129 else 9130 warning_at (location, 9131 OPT_Wsign_compare, 9132 "comparison between signed and unsigned integer expressions"); 9133 } 9134 9135 /* Warn if two unsigned values are being compared in a size larger 9136 than their original size, and one (and only one) is the result of 9137 a `~' operator. This comparison will always fail. 9138 9139 Also warn if one operand is a constant, and the constant does not 9140 have all bits set that are set in the ~ operand when it is 9141 extended. */ 9142 9143 op0 = get_narrower (op0, &unsignedp0); 9144 op1 = get_narrower (op1, &unsignedp1); 9145 9146 if ((TREE_CODE (op0) == BIT_NOT_EXPR) 9147 ^ (TREE_CODE (op1) == BIT_NOT_EXPR)) 9148 { 9149 if (TREE_CODE (op0) == BIT_NOT_EXPR) 9150 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0); 9151 if (TREE_CODE (op1) == BIT_NOT_EXPR) 9152 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1); 9153 9154 if (host_integerp (op0, 0) || host_integerp (op1, 0)) 9155 { 9156 tree primop; 9157 HOST_WIDE_INT constant, mask; 9158 int unsignedp; 9159 unsigned int bits; 9160 9161 if (host_integerp (op0, 0)) 9162 { 9163 primop = op1; 9164 unsignedp = unsignedp1; 9165 constant = tree_low_cst (op0, 0); 9166 } 9167 else 9168 { 9169 primop = op0; 9170 unsignedp = unsignedp0; 9171 constant = tree_low_cst (op1, 0); 9172 } 9173 9174 bits = TYPE_PRECISION (TREE_TYPE (primop)); 9175 if (bits < TYPE_PRECISION (result_type) 9176 && bits < HOST_BITS_PER_LONG && unsignedp) 9177 { 9178 mask = (~ (HOST_WIDE_INT) 0) << bits; 9179 if ((mask & constant) != mask) 9180 { 9181 if (constant == 0) 9182 warning (OPT_Wsign_compare, 9183 "promoted ~unsigned is always non-zero"); 9184 else 9185 warning_at (location, OPT_Wsign_compare, 9186 "comparison of promoted ~unsigned with constant"); 9187 } 9188 } 9189 } 9190 else if (unsignedp0 && unsignedp1 9191 && (TYPE_PRECISION (TREE_TYPE (op0)) 9192 < TYPE_PRECISION (result_type)) 9193 && (TYPE_PRECISION (TREE_TYPE (op1)) 9194 < TYPE_PRECISION (result_type))) 9195 warning_at (location, OPT_Wsign_compare, 9196 "comparison of promoted ~unsigned with unsigned"); 9197 } 9198} 9199 9200/* Setup a TYPE_DECL node as a typedef representation. 9201 9202 X is a TYPE_DECL for a typedef statement. Create a brand new 9203 ..._TYPE node (which will be just a variant of the existing 9204 ..._TYPE node with identical properties) and then install X 9205 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node. 9206 9207 The whole point here is to end up with a situation where each 9208 and every ..._TYPE node the compiler creates will be uniquely 9209 associated with AT MOST one node representing a typedef name. 9210 This way, even though the compiler substitutes corresponding 9211 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very 9212 early on, later parts of the compiler can always do the reverse 9213 translation and get back the corresponding typedef name. For 9214 example, given: 9215 9216 typedef struct S MY_TYPE; 9217 MY_TYPE object; 9218 9219 Later parts of the compiler might only know that `object' was of 9220 type `struct S' if it were not for code just below. With this 9221 code however, later parts of the compiler see something like: 9222 9223 struct S' == struct S 9224 typedef struct S' MY_TYPE; 9225 struct S' object; 9226 9227 And they can then deduce (from the node for type struct S') that 9228 the original object declaration was: 9229 9230 MY_TYPE object; 9231 9232 Being able to do this is important for proper support of protoize, 9233 and also for generating precise symbolic debugging information 9234 which takes full account of the programmer's (typedef) vocabulary. 9235 9236 Obviously, we don't want to generate a duplicate ..._TYPE node if 9237 the TYPE_DECL node that we are now processing really represents a 9238 standard built-in type. */ 9239 9240void 9241set_underlying_type (tree x) 9242{ 9243 if (x == error_mark_node) 9244 return; 9245 if (DECL_IS_BUILTIN (x)) 9246 { 9247 if (TYPE_NAME (TREE_TYPE (x)) == 0) 9248 TYPE_NAME (TREE_TYPE (x)) = x; 9249 } 9250 else if (TREE_TYPE (x) != error_mark_node 9251 && DECL_ORIGINAL_TYPE (x) == NULL_TREE) 9252 { 9253 tree tt = TREE_TYPE (x); 9254 DECL_ORIGINAL_TYPE (x) = tt; 9255 tt = build_variant_type_copy (tt); 9256 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x)); 9257 TYPE_NAME (tt) = x; 9258 TREE_USED (tt) = TREE_USED (x); 9259 TREE_TYPE (x) = tt; 9260 } 9261} 9262 9263/* Returns true if X is a typedef decl. */ 9264 9265bool 9266is_typedef_decl (tree x) 9267{ 9268 return (x && TREE_CODE (x) == TYPE_DECL 9269 && DECL_ORIGINAL_TYPE (x) != NULL_TREE); 9270} 9271 9272/* Record the types used by the current global variable declaration 9273 being parsed, so that we can decide later to emit their debug info. 9274 Those types are in types_used_by_cur_var_decl, and we are going to 9275 store them in the types_used_by_vars_hash hash table. 9276 DECL is the declaration of the global variable that has been parsed. */ 9277 9278void 9279record_types_used_by_current_var_decl (tree decl) 9280{ 9281 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl)); 9282 9283 if (types_used_by_cur_var_decl) 9284 { 9285 tree node; 9286 for (node = types_used_by_cur_var_decl; 9287 node; 9288 node = TREE_CHAIN (node)) 9289 { 9290 tree type = TREE_PURPOSE (node); 9291 types_used_by_var_decl_insert (type, decl); 9292 } 9293 types_used_by_cur_var_decl = NULL; 9294 } 9295} 9296 9297/* The C and C++ parsers both use vectors to hold function arguments. 9298 For efficiency, we keep a cache of unused vectors. This is the 9299 cache. */ 9300 9301typedef VEC(tree,gc)* tree_gc_vec; 9302DEF_VEC_P(tree_gc_vec); 9303DEF_VEC_ALLOC_P(tree_gc_vec,gc); 9304static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache; 9305 9306/* Return a new vector from the cache. If the cache is empty, 9307 allocate a new vector. These vectors are GC'ed, so it is OK if the 9308 pointer is not released.. */ 9309 9310VEC(tree,gc) * 9311make_tree_vector (void) 9312{ 9313 if (!VEC_empty (tree_gc_vec, tree_vector_cache)) 9314 return VEC_pop (tree_gc_vec, tree_vector_cache); 9315 else 9316 { 9317 /* Passing 0 to VEC_alloc returns NULL, and our callers require 9318 that we always return a non-NULL value. The vector code uses 9319 4 when growing a NULL vector, so we do too. */ 9320 return VEC_alloc (tree, gc, 4); 9321 } 9322} 9323 9324/* Release a vector of trees back to the cache. */ 9325 9326void 9327release_tree_vector (VEC(tree,gc) *vec) 9328{ 9329 if (vec != NULL) 9330 { 9331 VEC_truncate (tree, vec, 0); 9332 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec); 9333 } 9334} 9335 9336/* Get a new tree vector holding a single tree. */ 9337 9338VEC(tree,gc) * 9339make_tree_vector_single (tree t) 9340{ 9341 VEC(tree,gc) *ret = make_tree_vector (); 9342 VEC_quick_push (tree, ret, t); 9343 return ret; 9344} 9345 9346/* Get a new tree vector which is a copy of an existing one. */ 9347 9348VEC(tree,gc) * 9349make_tree_vector_copy (const VEC(tree,gc) *orig) 9350{ 9351 VEC(tree,gc) *ret; 9352 unsigned int ix; 9353 tree t; 9354 9355 ret = make_tree_vector (); 9356 VEC_reserve (tree, gc, ret, VEC_length (tree, orig)); 9357 for (ix = 0; VEC_iterate (tree, orig, ix, t); ++ix) 9358 VEC_quick_push (tree, ret, t); 9359 return ret; 9360} 9361 9362#include "gt-c-common.h" 9363