1 /* Subroutines shared by all languages that are variants of C. 2 Copyright (C) 1992-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #define GCC_C_COMMON_C 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "target.h" 26 #include "function.h" 27 #include "tree.h" 28 #include "memmodel.h" 29 #include "c-common.h" 30 #include "gimple-expr.h" 31 #include "tm_p.h" 32 #include "stringpool.h" 33 #include "cgraph.h" 34 #include "diagnostic.h" 35 #include "intl.h" 36 #include "stor-layout.h" 37 #include "calls.h" 38 #include "attribs.h" 39 #include "varasm.h" 40 #include "trans-mem.h" 41 #include "c-objc.h" 42 #include "common/common-target.h" 43 #include "langhooks.h" 44 #include "tree-inline.h" 45 #include "toplev.h" 46 #include "tree-iterator.h" 47 #include "opts.h" 48 #include "gimplify.h" 49 #include "substring-locations.h" 50 #include "spellcheck.h" 51 #include "selftest.h" 52 53 cpp_reader *parse_in; /* Declared in c-pragma.h. */ 54 55 /* Mode used to build pointers (VOIDmode means ptr_mode). */ 56 57 machine_mode c_default_pointer_mode = VOIDmode; 58 59 /* The following symbols are subsumed in the c_global_trees array, and 60 listed here individually for documentation purposes. 61 62 INTEGER_TYPE and REAL_TYPE nodes for the standard data types. 63 64 tree short_integer_type_node; 65 tree long_integer_type_node; 66 tree long_long_integer_type_node; 67 68 tree short_unsigned_type_node; 69 tree long_unsigned_type_node; 70 tree long_long_unsigned_type_node; 71 72 tree truthvalue_type_node; 73 tree truthvalue_false_node; 74 tree truthvalue_true_node; 75 76 tree ptrdiff_type_node; 77 78 tree unsigned_char_type_node; 79 tree signed_char_type_node; 80 tree wchar_type_node; 81 82 tree char16_type_node; 83 tree char32_type_node; 84 85 tree float_type_node; 86 tree double_type_node; 87 tree long_double_type_node; 88 89 tree complex_integer_type_node; 90 tree complex_float_type_node; 91 tree complex_double_type_node; 92 tree complex_long_double_type_node; 93 94 tree dfloat32_type_node; 95 tree dfloat64_type_node; 96 tree_dfloat128_type_node; 97 98 tree intQI_type_node; 99 tree intHI_type_node; 100 tree intSI_type_node; 101 tree intDI_type_node; 102 tree intTI_type_node; 103 104 tree unsigned_intQI_type_node; 105 tree unsigned_intHI_type_node; 106 tree unsigned_intSI_type_node; 107 tree unsigned_intDI_type_node; 108 tree unsigned_intTI_type_node; 109 110 tree widest_integer_literal_type_node; 111 tree widest_unsigned_literal_type_node; 112 113 Nodes for types `void *' and `const void *'. 114 115 tree ptr_type_node, const_ptr_type_node; 116 117 Nodes for types `char *' and `const char *'. 118 119 tree string_type_node, const_string_type_node; 120 121 Type `char[SOMENUMBER]'. 122 Used when an array of char is needed and the size is irrelevant. 123 124 tree char_array_type_node; 125 126 Type `wchar_t[SOMENUMBER]' or something like it. 127 Used when a wide string literal is created. 128 129 tree wchar_array_type_node; 130 131 Type `char16_t[SOMENUMBER]' or something like it. 132 Used when a UTF-16 string literal is created. 133 134 tree char16_array_type_node; 135 136 Type `char32_t[SOMENUMBER]' or something like it. 137 Used when a UTF-32 string literal is created. 138 139 tree char32_array_type_node; 140 141 Type `int ()' -- used for implicit declaration of functions. 142 143 tree default_function_type; 144 145 A VOID_TYPE node, packaged in a TREE_LIST. 146 147 tree void_list_node; 148 149 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__, 150 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__ 151 VAR_DECLS, but C++ does.) 152 153 tree function_name_decl_node; 154 tree pretty_function_name_decl_node; 155 tree c99_function_name_decl_node; 156 157 Stack of nested function name VAR_DECLs. 158 159 tree saved_function_name_decls; 160 161 */ 162 163 tree c_global_trees[CTI_MAX]; 164 165 /* Switches common to the C front ends. */ 166 167 /* Nonzero means don't output line number information. */ 168 169 char flag_no_line_commands; 170 171 /* Nonzero causes -E output not to be done, but directives such as 172 #define that have side effects are still obeyed. */ 173 174 char flag_no_output; 175 176 /* Nonzero means dump macros in some fashion. */ 177 178 char flag_dump_macros; 179 180 /* Nonzero means pass #include lines through to the output. */ 181 182 char flag_dump_includes; 183 184 /* Nonzero means process PCH files while preprocessing. */ 185 186 bool flag_pch_preprocess; 187 188 /* The file name to which we should write a precompiled header, or 189 NULL if no header will be written in this compile. */ 190 191 const char *pch_file; 192 193 /* Nonzero if an ISO standard was selected. It rejects macros in the 194 user's namespace. */ 195 int flag_iso; 196 197 /* C/ObjC language option variables. */ 198 199 200 /* Nonzero means allow type mismatches in conditional expressions; 201 just make their values `void'. */ 202 203 int flag_cond_mismatch; 204 205 /* Nonzero means enable C89 Amendment 1 features. */ 206 207 int flag_isoc94; 208 209 /* Nonzero means use the ISO C99 (or C11) dialect of C. */ 210 211 int flag_isoc99; 212 213 /* Nonzero means use the ISO C11 dialect of C. */ 214 215 int flag_isoc11; 216 217 /* Nonzero means that we have builtin functions, and main is an int. */ 218 219 int flag_hosted = 1; 220 221 222 /* ObjC language option variables. */ 223 224 225 /* Tells the compiler that this is a special run. Do not perform any 226 compiling, instead we are to test some platform dependent features 227 and output a C header file with appropriate definitions. */ 228 229 int print_struct_values; 230 231 /* Tells the compiler what is the constant string class for ObjC. */ 232 233 const char *constant_string_class_name; 234 235 236 /* C++ language option variables. */ 237 238 /* The reference version of the ABI for -Wabi. */ 239 240 int warn_abi_version = -1; 241 242 /* Nonzero means generate separate instantiation control files and 243 juggle them at link time. */ 244 245 int flag_use_repository; 246 247 /* The C++ dialect being used. Default set in c_common_post_options. */ 248 249 enum cxx_dialect cxx_dialect = cxx_unset; 250 251 /* Maximum template instantiation depth. This limit exists to limit the 252 time it takes to notice excessively recursive template instantiations. 253 254 The default is lower than the 1024 recommended by the C++0x standard 255 because G++ runs out of stack before 1024 with highly recursive template 256 argument deduction substitution (g++.dg/cpp0x/enum11.C). */ 257 258 int max_tinst_depth = 900; 259 260 /* The elements of `ridpointers' are identifier nodes for the reserved 261 type names and storage classes. It is indexed by a RID_... value. */ 262 tree *ridpointers; 263 264 tree (*make_fname_decl) (location_t, tree, int); 265 266 /* Nonzero means don't warn about problems that occur when the code is 267 executed. */ 268 int c_inhibit_evaluation_warnings; 269 270 /* Whether we are building a boolean conversion inside 271 convert_for_assignment, or some other late binary operation. If 272 build_binary_op is called for C (from code shared by C and C++) in 273 this case, then the operands have already been folded and the 274 result will not be folded again, so C_MAYBE_CONST_EXPR should not 275 be generated. */ 276 bool in_late_binary_op; 277 278 /* Whether lexing has been completed, so subsequent preprocessor 279 errors should use the compiler's input_location. */ 280 bool done_lexing = false; 281 282 /* Information about how a function name is generated. */ 283 struct fname_var_t 284 { 285 tree *const decl; /* pointer to the VAR_DECL. */ 286 const unsigned rid; /* RID number for the identifier. */ 287 const int pretty; /* How pretty is it? */ 288 }; 289 290 /* The three ways of getting then name of the current function. */ 291 292 const struct fname_var_t fname_vars[] = 293 { 294 /* C99 compliant __func__, must be first. */ 295 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0}, 296 /* GCC __FUNCTION__ compliant. */ 297 {&function_name_decl_node, RID_FUNCTION_NAME, 0}, 298 /* GCC __PRETTY_FUNCTION__ compliant. */ 299 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1}, 300 {NULL, 0, 0}, 301 }; 302 303 /* Global visibility options. */ 304 struct visibility_flags visibility_options; 305 306 static tree check_case_value (location_t, tree); 307 static bool check_case_bounds (location_t, tree, tree, tree *, tree *, 308 bool *); 309 310 311 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT); 312 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT); 313 314 /* Reserved words. The third field is a mask: keywords are disabled 315 if they match the mask. 316 317 Masks for languages: 318 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC 319 C --std=c99: D_CXXONLY | D_OBJC 320 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set 321 C++ --std=c++98: D_CONLY | D_CXX11 | D_OBJC 322 C++ --std=c++11: D_CONLY | D_OBJC 323 ObjC++ is like C++ except that D_OBJC is not set 324 325 If -fno-asm is used, D_ASM is added to the mask. If 326 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in 327 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords. 328 In C with -Wc++-compat, we warn if D_CXXWARN is set. 329 330 Note the complication of the D_CXX_OBJC keywords. These are 331 reserved words such as 'class'. In C++, 'class' is a reserved 332 word. In Objective-C++ it is too. In Objective-C, it is a 333 reserved word too, but only if it follows an '@' sign. 334 */ 335 const struct c_common_resword c_common_reswords[] = 336 { 337 { "_Alignas", RID_ALIGNAS, D_CONLY }, 338 { "_Alignof", RID_ALIGNOF, D_CONLY }, 339 { "_Atomic", RID_ATOMIC, D_CONLY }, 340 { "_Bool", RID_BOOL, D_CONLY }, 341 { "_Complex", RID_COMPLEX, 0 }, 342 { "_Imaginary", RID_IMAGINARY, D_CONLY }, 343 { "_Float16", RID_FLOAT16, D_CONLY }, 344 { "_Float32", RID_FLOAT32, D_CONLY }, 345 { "_Float64", RID_FLOAT64, D_CONLY }, 346 { "_Float128", RID_FLOAT128, D_CONLY }, 347 { "_Float32x", RID_FLOAT32X, D_CONLY }, 348 { "_Float64x", RID_FLOAT64X, D_CONLY }, 349 { "_Float128x", RID_FLOAT128X, D_CONLY }, 350 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT }, 351 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT }, 352 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT }, 353 { "_Fract", RID_FRACT, D_CONLY | D_EXT }, 354 { "_Accum", RID_ACCUM, D_CONLY | D_EXT }, 355 { "_Sat", RID_SAT, D_CONLY | D_EXT }, 356 { "_Static_assert", RID_STATIC_ASSERT, D_CONLY }, 357 { "_Noreturn", RID_NORETURN, D_CONLY }, 358 { "_Generic", RID_GENERIC, D_CONLY }, 359 { "_Thread_local", RID_THREAD, D_CONLY }, 360 { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, 361 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, 362 { "__alignof", RID_ALIGNOF, 0 }, 363 { "__alignof__", RID_ALIGNOF, 0 }, 364 { "__asm", RID_ASM, 0 }, 365 { "__asm__", RID_ASM, 0 }, 366 { "__attribute", RID_ATTRIBUTE, 0 }, 367 { "__attribute__", RID_ATTRIBUTE, 0 }, 368 { "__auto_type", RID_AUTO_TYPE, D_CONLY }, 369 { "__bases", RID_BASES, D_CXXONLY }, 370 { "__builtin_addressof", RID_ADDRESSOF, D_CXXONLY }, 371 { "__builtin_call_with_static_chain", 372 RID_BUILTIN_CALL_WITH_STATIC_CHAIN, D_CONLY }, 373 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY }, 374 { "__builtin_complex", RID_BUILTIN_COMPLEX, D_CONLY }, 375 { "__builtin_launder", RID_BUILTIN_LAUNDER, D_CXXONLY }, 376 { "__builtin_shuffle", RID_BUILTIN_SHUFFLE, 0 }, 377 { "__builtin_tgmath", RID_BUILTIN_TGMATH, D_CONLY }, 378 { "__builtin_offsetof", RID_OFFSETOF, 0 }, 379 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY }, 380 { "__builtin_va_arg", RID_VA_ARG, 0 }, 381 { "__complex", RID_COMPLEX, 0 }, 382 { "__complex__", RID_COMPLEX, 0 }, 383 { "__const", RID_CONST, 0 }, 384 { "__const__", RID_CONST, 0 }, 385 { "__decltype", RID_DECLTYPE, D_CXXONLY }, 386 { "__direct_bases", RID_DIRECT_BASES, D_CXXONLY }, 387 { "__extension__", RID_EXTENSION, 0 }, 388 { "__func__", RID_C99_FUNCTION_NAME, 0 }, 389 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY }, 390 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY }, 391 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY }, 392 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY }, 393 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY }, 394 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY }, 395 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY }, 396 { "__has_unique_object_representations", RID_HAS_UNIQUE_OBJ_REPRESENTATIONS, 397 D_CXXONLY }, 398 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY }, 399 { "__imag", RID_IMAGPART, 0 }, 400 { "__imag__", RID_IMAGPART, 0 }, 401 { "__inline", RID_INLINE, 0 }, 402 { "__inline__", RID_INLINE, 0 }, 403 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY }, 404 { "__is_aggregate", RID_IS_AGGREGATE, D_CXXONLY }, 405 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY }, 406 { "__is_class", RID_IS_CLASS, D_CXXONLY }, 407 { "__is_empty", RID_IS_EMPTY, D_CXXONLY }, 408 { "__is_enum", RID_IS_ENUM, D_CXXONLY }, 409 { "__is_final", RID_IS_FINAL, D_CXXONLY }, 410 { "__is_literal_type", RID_IS_LITERAL_TYPE, D_CXXONLY }, 411 { "__is_pod", RID_IS_POD, D_CXXONLY }, 412 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY }, 413 { "__is_same_as", RID_IS_SAME_AS, D_CXXONLY }, 414 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY }, 415 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY }, 416 { "__is_trivially_assignable", RID_IS_TRIVIALLY_ASSIGNABLE, D_CXXONLY }, 417 { "__is_trivially_constructible", RID_IS_TRIVIALLY_CONSTRUCTIBLE, D_CXXONLY }, 418 { "__is_trivially_copyable", RID_IS_TRIVIALLY_COPYABLE, D_CXXONLY }, 419 { "__is_union", RID_IS_UNION, D_CXXONLY }, 420 { "__label__", RID_LABEL, 0 }, 421 { "__null", RID_NULL, 0 }, 422 { "__real", RID_REALPART, 0 }, 423 { "__real__", RID_REALPART, 0 }, 424 { "__restrict", RID_RESTRICT, 0 }, 425 { "__restrict__", RID_RESTRICT, 0 }, 426 { "__signed", RID_SIGNED, 0 }, 427 { "__signed__", RID_SIGNED, 0 }, 428 { "__thread", RID_THREAD, 0 }, 429 { "__transaction_atomic", RID_TRANSACTION_ATOMIC, 0 }, 430 { "__transaction_relaxed", RID_TRANSACTION_RELAXED, 0 }, 431 { "__transaction_cancel", RID_TRANSACTION_CANCEL, 0 }, 432 { "__typeof", RID_TYPEOF, 0 }, 433 { "__typeof__", RID_TYPEOF, 0 }, 434 { "__underlying_type", RID_UNDERLYING_TYPE, D_CXXONLY }, 435 { "__volatile", RID_VOLATILE, 0 }, 436 { "__volatile__", RID_VOLATILE, 0 }, 437 { "__GIMPLE", RID_GIMPLE, D_CONLY }, 438 { "__PHI", RID_PHI, D_CONLY }, 439 { "__RTL", RID_RTL, D_CONLY }, 440 { "alignas", RID_ALIGNAS, D_CXXONLY | D_CXX11 | D_CXXWARN }, 441 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX11 | D_CXXWARN }, 442 { "asm", RID_ASM, D_ASM }, 443 { "auto", RID_AUTO, 0 }, 444 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN }, 445 { "break", RID_BREAK, 0 }, 446 { "case", RID_CASE, 0 }, 447 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN }, 448 { "char", RID_CHAR, 0 }, 449 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX11 | D_CXXWARN }, 450 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX11 | D_CXXWARN }, 451 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN }, 452 { "const", RID_CONST, 0 }, 453 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX11 | D_CXXWARN }, 454 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN }, 455 { "continue", RID_CONTINUE, 0 }, 456 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX11 | D_CXXWARN }, 457 { "default", RID_DEFAULT, 0 }, 458 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN }, 459 { "do", RID_DO, 0 }, 460 { "double", RID_DOUBLE, 0 }, 461 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN }, 462 { "else", RID_ELSE, 0 }, 463 { "enum", RID_ENUM, 0 }, 464 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN }, 465 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN }, 466 { "extern", RID_EXTERN, 0 }, 467 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN }, 468 { "float", RID_FLOAT, 0 }, 469 { "for", RID_FOR, 0 }, 470 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN }, 471 { "goto", RID_GOTO, 0 }, 472 { "if", RID_IF, 0 }, 473 { "inline", RID_INLINE, D_EXT89 }, 474 { "int", RID_INT, 0 }, 475 { "long", RID_LONG, 0 }, 476 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN }, 477 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN }, 478 { "new", RID_NEW, D_CXXONLY | D_CXXWARN }, 479 { "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX11 | D_CXXWARN }, 480 { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX11 | D_CXXWARN }, 481 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN }, 482 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN }, 483 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN }, 484 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN }, 485 { "register", RID_REGISTER, 0 }, 486 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN }, 487 { "restrict", RID_RESTRICT, D_CONLY | D_C99 }, 488 { "return", RID_RETURN, 0 }, 489 { "short", RID_SHORT, 0 }, 490 { "signed", RID_SIGNED, 0 }, 491 { "sizeof", RID_SIZEOF, 0 }, 492 { "static", RID_STATIC, 0 }, 493 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX11 | D_CXXWARN }, 494 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN }, 495 { "struct", RID_STRUCT, 0 }, 496 { "switch", RID_SWITCH, 0 }, 497 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN }, 498 { "this", RID_THIS, D_CXXONLY | D_CXXWARN }, 499 { "thread_local", RID_THREAD, D_CXXONLY | D_CXX11 | D_CXXWARN }, 500 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN }, 501 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN }, 502 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN }, 503 { "typedef", RID_TYPEDEF, 0 }, 504 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN }, 505 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN }, 506 { "typeof", RID_TYPEOF, D_ASM | D_EXT }, 507 { "union", RID_UNION, 0 }, 508 { "unsigned", RID_UNSIGNED, 0 }, 509 { "using", RID_USING, D_CXXONLY | D_CXXWARN }, 510 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN }, 511 { "void", RID_VOID, 0 }, 512 { "volatile", RID_VOLATILE, 0 }, 513 { "wchar_t", RID_WCHAR, D_CXXONLY }, 514 { "while", RID_WHILE, 0 }, 515 { "__is_assignable", RID_IS_ASSIGNABLE, D_CXXONLY }, 516 { "__is_constructible", RID_IS_CONSTRUCTIBLE, D_CXXONLY }, 517 518 /* C++ transactional memory. */ 519 { "synchronized", RID_SYNCHRONIZED, D_CXX_OBJC | D_TRANSMEM }, 520 { "atomic_noexcept", RID_ATOMIC_NOEXCEPT, D_CXXONLY | D_TRANSMEM }, 521 { "atomic_cancel", RID_ATOMIC_CANCEL, D_CXXONLY | D_TRANSMEM }, 522 { "atomic_commit", RID_TRANSACTION_ATOMIC, D_CXXONLY | D_TRANSMEM }, 523 524 /* Concepts-related keywords */ 525 { "concept", RID_CONCEPT, D_CXX_CONCEPTS_FLAGS | D_CXXWARN }, 526 { "requires", RID_REQUIRES, D_CXX_CONCEPTS_FLAGS | D_CXXWARN }, 527 528 /* These Objective-C keywords are recognized only immediately after 529 an '@'. */ 530 { "compatibility_alias", RID_AT_ALIAS, D_OBJC }, 531 { "defs", RID_AT_DEFS, D_OBJC }, 532 { "encode", RID_AT_ENCODE, D_OBJC }, 533 { "end", RID_AT_END, D_OBJC }, 534 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC }, 535 { "interface", RID_AT_INTERFACE, D_OBJC }, 536 { "protocol", RID_AT_PROTOCOL, D_OBJC }, 537 { "selector", RID_AT_SELECTOR, D_OBJC }, 538 { "finally", RID_AT_FINALLY, D_OBJC }, 539 { "optional", RID_AT_OPTIONAL, D_OBJC }, 540 { "required", RID_AT_REQUIRED, D_OBJC }, 541 { "property", RID_AT_PROPERTY, D_OBJC }, 542 { "package", RID_AT_PACKAGE, D_OBJC }, 543 { "synthesize", RID_AT_SYNTHESIZE, D_OBJC }, 544 { "dynamic", RID_AT_DYNAMIC, D_OBJC }, 545 /* These are recognized only in protocol-qualifier context 546 (see above) */ 547 { "bycopy", RID_BYCOPY, D_OBJC }, 548 { "byref", RID_BYREF, D_OBJC }, 549 { "in", RID_IN, D_OBJC }, 550 { "inout", RID_INOUT, D_OBJC }, 551 { "oneway", RID_ONEWAY, D_OBJC }, 552 { "out", RID_OUT, D_OBJC }, 553 /* These are recognized inside a property attribute list */ 554 { "assign", RID_ASSIGN, D_OBJC }, 555 { "copy", RID_COPY, D_OBJC }, 556 { "getter", RID_GETTER, D_OBJC }, 557 { "nonatomic", RID_NONATOMIC, D_OBJC }, 558 { "readonly", RID_READONLY, D_OBJC }, 559 { "readwrite", RID_READWRITE, D_OBJC }, 560 { "retain", RID_RETAIN, D_OBJC }, 561 { "setter", RID_SETTER, D_OBJC }, 562 }; 563 564 const unsigned int num_c_common_reswords = 565 sizeof c_common_reswords / sizeof (struct c_common_resword); 566 567 /* Return identifier for address space AS. */ 568 569 const char * 570 c_addr_space_name (addr_space_t as) 571 { 572 int rid = RID_FIRST_ADDR_SPACE + as; 573 gcc_assert (ridpointers [rid]); 574 return IDENTIFIER_POINTER (ridpointers [rid]); 575 } 576 577 /* Push current bindings for the function name VAR_DECLS. */ 578 579 void 580 start_fname_decls (void) 581 { 582 unsigned ix; 583 tree saved = NULL_TREE; 584 585 for (ix = 0; fname_vars[ix].decl; ix++) 586 { 587 tree decl = *fname_vars[ix].decl; 588 589 if (decl) 590 { 591 saved = tree_cons (decl, build_int_cst (integer_type_node, ix), 592 saved); 593 *fname_vars[ix].decl = NULL_TREE; 594 } 595 } 596 if (saved || saved_function_name_decls) 597 /* Normally they'll have been NULL, so only push if we've got a 598 stack, or they are non-NULL. */ 599 saved_function_name_decls = tree_cons (saved, NULL_TREE, 600 saved_function_name_decls); 601 } 602 603 /* Finish up the current bindings, adding them into the current function's 604 statement tree. This must be done _before_ finish_stmt_tree is called. 605 If there is no current function, we must be at file scope and no statements 606 are involved. Pop the previous bindings. */ 607 608 void 609 finish_fname_decls (void) 610 { 611 unsigned ix; 612 tree stmts = NULL_TREE; 613 tree stack = saved_function_name_decls; 614 615 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack)) 616 append_to_statement_list (TREE_VALUE (stack), &stmts); 617 618 if (stmts) 619 { 620 tree *bodyp = &DECL_SAVED_TREE (current_function_decl); 621 622 if (TREE_CODE (*bodyp) == BIND_EXPR) 623 bodyp = &BIND_EXPR_BODY (*bodyp); 624 625 append_to_statement_list_force (*bodyp, &stmts); 626 *bodyp = stmts; 627 } 628 629 for (ix = 0; fname_vars[ix].decl; ix++) 630 *fname_vars[ix].decl = NULL_TREE; 631 632 if (stack) 633 { 634 /* We had saved values, restore them. */ 635 tree saved; 636 637 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved)) 638 { 639 tree decl = TREE_PURPOSE (saved); 640 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved)); 641 642 *fname_vars[ix].decl = decl; 643 } 644 stack = TREE_CHAIN (stack); 645 } 646 saved_function_name_decls = stack; 647 } 648 649 /* Return the text name of the current function, suitably prettified 650 by PRETTY_P. Return string must be freed by caller. */ 651 652 const char * 653 fname_as_string (int pretty_p) 654 { 655 const char *name = "top level"; 656 char *namep; 657 int vrb = 2, len; 658 cpp_string cstr = { 0, 0 }, strname; 659 660 if (!pretty_p) 661 { 662 name = ""; 663 vrb = 0; 664 } 665 666 if (current_function_decl) 667 name = lang_hooks.decl_printable_name (current_function_decl, vrb); 668 669 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */ 670 671 namep = XNEWVEC (char, len); 672 snprintf (namep, len, "\"%s\"", name); 673 strname.text = (unsigned char *) namep; 674 strname.len = len - 1; 675 676 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING)) 677 { 678 XDELETEVEC (namep); 679 return (const char *) cstr.text; 680 } 681 682 return namep; 683 } 684 685 /* Return the VAR_DECL for a const char array naming the current 686 function. If the VAR_DECL has not yet been created, create it 687 now. RID indicates how it should be formatted and IDENTIFIER_NODE 688 ID is its name (unfortunately C and C++ hold the RID values of 689 keywords in different places, so we can't derive RID from ID in 690 this language independent code. LOC is the location of the 691 function. */ 692 693 tree 694 fname_decl (location_t loc, unsigned int rid, tree id) 695 { 696 unsigned ix; 697 tree decl = NULL_TREE; 698 699 for (ix = 0; fname_vars[ix].decl; ix++) 700 if (fname_vars[ix].rid == rid) 701 break; 702 703 decl = *fname_vars[ix].decl; 704 if (!decl) 705 { 706 /* If a tree is built here, it would normally have the lineno of 707 the current statement. Later this tree will be moved to the 708 beginning of the function and this line number will be wrong. 709 To avoid this problem set the lineno to 0 here; that prevents 710 it from appearing in the RTL. */ 711 tree stmts; 712 location_t saved_location = input_location; 713 input_location = UNKNOWN_LOCATION; 714 715 stmts = push_stmt_list (); 716 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty); 717 stmts = pop_stmt_list (stmts); 718 if (!IS_EMPTY_STMT (stmts)) 719 saved_function_name_decls 720 = tree_cons (decl, stmts, saved_function_name_decls); 721 *fname_vars[ix].decl = decl; 722 input_location = saved_location; 723 } 724 if (!ix && !current_function_decl) 725 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl); 726 727 return decl; 728 } 729 730 /* Given a STRING_CST, give it a suitable array-of-chars data type. */ 731 732 tree 733 fix_string_type (tree value) 734 { 735 int length = TREE_STRING_LENGTH (value); 736 int nchars; 737 tree e_type, i_type, a_type; 738 739 /* Compute the number of elements, for the array type. */ 740 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value)) 741 { 742 nchars = length; 743 e_type = char_type_node; 744 } 745 else if (TREE_TYPE (value) == char16_array_type_node) 746 { 747 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT); 748 e_type = char16_type_node; 749 } 750 else if (TREE_TYPE (value) == char32_array_type_node) 751 { 752 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT); 753 e_type = char32_type_node; 754 } 755 else 756 { 757 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT); 758 e_type = wchar_type_node; 759 } 760 761 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous 762 limit in C++98 Annex B is very large (65536) and is not normative, 763 so we do not diagnose it (warn_overlength_strings is forced off 764 in c_common_post_options). */ 765 if (warn_overlength_strings) 766 { 767 const int nchars_max = flag_isoc99 ? 4095 : 509; 768 const int relevant_std = flag_isoc99 ? 99 : 90; 769 if (nchars - 1 > nchars_max) 770 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not 771 separate the %d from the 'C'. 'ISO' should not be 772 translated, but it may be moved after 'C%d' in languages 773 where modifiers follow nouns. */ 774 pedwarn (input_location, OPT_Woverlength_strings, 775 "string length %qd is greater than the length %qd " 776 "ISO C%d compilers are required to support", 777 nchars - 1, nchars_max, relevant_std); 778 } 779 780 /* Create the array type for the string constant. The ISO C++ 781 standard says that a string literal has type `const char[N]' or 782 `const wchar_t[N]'. We use the same logic when invoked as a C 783 front-end with -Wwrite-strings. 784 ??? We should change the type of an expression depending on the 785 state of a warning flag. We should just be warning -- see how 786 this is handled in the C++ front-end for the deprecated implicit 787 conversion from string literals to `char*' or `wchar_t*'. 788 789 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified 790 array type being the unqualified version of that type. 791 Therefore, if we are constructing an array of const char, we must 792 construct the matching unqualified array type first. The C front 793 end does not require this, but it does no harm, so we do it 794 unconditionally. */ 795 i_type = build_index_type (size_int (nchars - 1)); 796 a_type = build_array_type (e_type, i_type); 797 if (c_dialect_cxx() || warn_write_strings) 798 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST); 799 800 TREE_TYPE (value) = a_type; 801 TREE_CONSTANT (value) = 1; 802 TREE_READONLY (value) = 1; 803 TREE_STATIC (value) = 1; 804 return value; 805 } 806 807 /* Given a string of type STRING_TYPE, determine what kind of string 808 token would give an equivalent execution encoding: CPP_STRING, 809 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error. 810 This may not be exactly the string token type that initially created 811 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit 812 string type at this point. 813 814 This effectively reverses part of the logic in lex_string and 815 fix_string_type. */ 816 817 static enum cpp_ttype 818 get_cpp_ttype_from_string_type (tree string_type) 819 { 820 gcc_assert (string_type); 821 if (TREE_CODE (string_type) == POINTER_TYPE) 822 string_type = TREE_TYPE (string_type); 823 824 if (TREE_CODE (string_type) != ARRAY_TYPE) 825 return CPP_OTHER; 826 827 tree element_type = TREE_TYPE (string_type); 828 if (TREE_CODE (element_type) != INTEGER_TYPE) 829 return CPP_OTHER; 830 831 int bits_per_character = TYPE_PRECISION (element_type); 832 switch (bits_per_character) 833 { 834 case 8: 835 return CPP_STRING; /* It could have also been CPP_UTF8STRING. */ 836 case 16: 837 return CPP_STRING16; 838 case 32: 839 return CPP_STRING32; 840 } 841 842 return CPP_OTHER; 843 } 844 845 /* The global record of string concatentations, for use in 846 extracting locations within string literals. */ 847 848 GTY(()) string_concat_db *g_string_concat_db; 849 850 /* Implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */ 851 852 const char * 853 c_get_substring_location (const substring_loc &substr_loc, 854 location_t *out_loc) 855 { 856 enum cpp_ttype tok_type 857 = get_cpp_ttype_from_string_type (substr_loc.get_string_type ()); 858 if (tok_type == CPP_OTHER) 859 return "unrecognized string type"; 860 861 return get_source_location_for_substring (parse_in, g_string_concat_db, 862 substr_loc.get_fmt_string_loc (), 863 tok_type, 864 substr_loc.get_caret_idx (), 865 substr_loc.get_start_idx (), 866 substr_loc.get_end_idx (), 867 out_loc); 868 } 869 870 871 /* Return true iff T is a boolean promoted to int. */ 872 873 bool 874 bool_promoted_to_int_p (tree t) 875 { 876 return (CONVERT_EXPR_P (t) 877 && TREE_TYPE (t) == integer_type_node 878 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == BOOLEAN_TYPE); 879 } 880 881 /* vector_targets_convertible_p is used for vector pointer types. The 882 callers perform various checks that the qualifiers are satisfactory, 883 while OTOH vector_targets_convertible_p ignores the number of elements 884 in the vectors. That's fine with vector pointers as we can consider, 885 say, a vector of 8 elements as two consecutive vectors of 4 elements, 886 and that does not require and conversion of the pointer values. 887 In contrast, vector_types_convertible_p and 888 vector_types_compatible_elements_p are used for vector value types. */ 889 /* True if pointers to distinct types T1 and T2 can be converted to 890 each other without an explicit cast. Only returns true for opaque 891 vector types. */ 892 bool 893 vector_targets_convertible_p (const_tree t1, const_tree t2) 894 { 895 if (VECTOR_TYPE_P (t1) && VECTOR_TYPE_P (t2) 896 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2)) 897 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))) 898 return true; 899 900 return false; 901 } 902 903 /* vector_types_convertible_p is used for vector value types. 904 It could in principle call vector_targets_convertible_p as a subroutine, 905 but then the check for vector type would be duplicated with its callers, 906 and also the purpose of vector_targets_convertible_p would become 907 muddled. 908 Where vector_types_convertible_p returns true, a conversion might still be 909 needed to make the types match. 910 In contrast, vector_targets_convertible_p is used for vector pointer 911 values, and vector_types_compatible_elements_p is used specifically 912 in the context for binary operators, as a check if use is possible without 913 conversion. */ 914 /* True if vector types T1 and T2 can be converted to each other 915 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2 916 can only be converted with -flax-vector-conversions yet that is not 917 in effect, emit a note telling the user about that option if such 918 a note has not previously been emitted. */ 919 bool 920 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note) 921 { 922 static bool emitted_lax_note = false; 923 bool convertible_lax; 924 925 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2)) 926 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))) 927 return true; 928 929 convertible_lax = 930 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)) 931 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE 932 || known_eq (TYPE_VECTOR_SUBPARTS (t1), 933 TYPE_VECTOR_SUBPARTS (t2))) 934 && (INTEGRAL_TYPE_P (TREE_TYPE (t1)) 935 == INTEGRAL_TYPE_P (TREE_TYPE (t2)))); 936 937 if (!convertible_lax || flag_lax_vector_conversions) 938 return convertible_lax; 939 940 if (known_eq (TYPE_VECTOR_SUBPARTS (t1), TYPE_VECTOR_SUBPARTS (t2)) 941 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))) 942 return true; 943 944 if (emit_lax_note && !emitted_lax_note) 945 { 946 emitted_lax_note = true; 947 inform (input_location, "use -flax-vector-conversions to permit " 948 "conversions between vectors with differing " 949 "element types or numbers of subparts"); 950 } 951 952 return false; 953 } 954 955 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes 956 and have vector types, V0 has the same type as V1, and the number of 957 elements of V0, V1, MASK is the same. 958 959 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was 960 called with two arguments. In this case implementation passes the 961 first argument twice in order to share the same tree code. This fact 962 could enable the mask-values being twice the vector length. This is 963 an implementation accident and this semantics is not guaranteed to 964 the user. */ 965 tree 966 c_build_vec_perm_expr (location_t loc, tree v0, tree v1, tree mask, 967 bool complain) 968 { 969 tree ret; 970 bool wrap = true; 971 bool maybe_const = false; 972 bool two_arguments = false; 973 974 if (v1 == NULL_TREE) 975 { 976 two_arguments = true; 977 v1 = v0; 978 } 979 980 if (v0 == error_mark_node || v1 == error_mark_node 981 || mask == error_mark_node) 982 return error_mark_node; 983 984 if (!VECTOR_INTEGER_TYPE_P (TREE_TYPE (mask))) 985 { 986 if (complain) 987 error_at (loc, "__builtin_shuffle last argument must " 988 "be an integer vector"); 989 return error_mark_node; 990 } 991 992 if (!VECTOR_TYPE_P (TREE_TYPE (v0)) 993 || !VECTOR_TYPE_P (TREE_TYPE (v1))) 994 { 995 if (complain) 996 error_at (loc, "__builtin_shuffle arguments must be vectors"); 997 return error_mark_node; 998 } 999 1000 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1))) 1001 { 1002 if (complain) 1003 error_at (loc, "__builtin_shuffle argument vectors must be of " 1004 "the same type"); 1005 return error_mark_node; 1006 } 1007 1008 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0)), 1009 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask))) 1010 && maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1)), 1011 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask)))) 1012 { 1013 if (complain) 1014 error_at (loc, "__builtin_shuffle number of elements of the " 1015 "argument vector(s) and the mask vector should " 1016 "be the same"); 1017 return error_mark_node; 1018 } 1019 1020 if (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (v0)))) 1021 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (mask))))) 1022 { 1023 if (complain) 1024 error_at (loc, "__builtin_shuffle argument vector(s) inner type " 1025 "must have the same size as inner type of the mask"); 1026 return error_mark_node; 1027 } 1028 1029 if (!c_dialect_cxx ()) 1030 { 1031 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */ 1032 v0 = c_fully_fold (v0, false, &maybe_const); 1033 wrap &= maybe_const; 1034 1035 if (two_arguments) 1036 v1 = v0 = save_expr (v0); 1037 else 1038 { 1039 v1 = c_fully_fold (v1, false, &maybe_const); 1040 wrap &= maybe_const; 1041 } 1042 1043 mask = c_fully_fold (mask, false, &maybe_const); 1044 wrap &= maybe_const; 1045 } 1046 else if (two_arguments) 1047 v1 = v0 = save_expr (v0); 1048 1049 ret = build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (v0), v0, v1, mask); 1050 1051 if (!c_dialect_cxx () && !wrap) 1052 ret = c_wrap_maybe_const (ret, true); 1053 1054 return ret; 1055 } 1056 1057 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum 1058 to integral type. */ 1059 1060 tree 1061 c_common_get_narrower (tree op, int *unsignedp_ptr) 1062 { 1063 op = get_narrower (op, unsignedp_ptr); 1064 1065 if (TREE_CODE (TREE_TYPE (op)) == ENUMERAL_TYPE 1066 && ENUM_IS_SCOPED (TREE_TYPE (op))) 1067 { 1068 /* C++0x scoped enumerations don't implicitly convert to integral 1069 type; if we stripped an explicit conversion to a larger type we 1070 need to replace it so common_type will still work. */ 1071 tree type = c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op)), 1072 TYPE_UNSIGNED (TREE_TYPE (op))); 1073 op = fold_convert (type, op); 1074 } 1075 return op; 1076 } 1077 1078 /* This is a helper function of build_binary_op. 1079 1080 For certain operations if both args were extended from the same 1081 smaller type, do the arithmetic in that type and then extend. 1082 1083 BITWISE indicates a bitwise operation. 1084 For them, this optimization is safe only if 1085 both args are zero-extended or both are sign-extended. 1086 Otherwise, we might change the result. 1087 Eg, (short)-1 | (unsigned short)-1 is (int)-1 1088 but calculated in (unsigned short) it would be (unsigned short)-1. 1089 */ 1090 tree 1091 shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise) 1092 { 1093 int unsigned0, unsigned1; 1094 tree arg0, arg1; 1095 int uns; 1096 tree type; 1097 1098 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 1099 excessive narrowing when we call get_narrower below. For 1100 example, suppose that OP0 is of unsigned int extended 1101 from signed char and that RESULT_TYPE is long long int. 1102 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 1103 like 1104 1105 (long long int) (unsigned int) signed_char 1106 1107 which get_narrower would narrow down to 1108 1109 (unsigned int) signed char 1110 1111 If we do not cast OP0 first, get_narrower would return 1112 signed_char, which is inconsistent with the case of the 1113 explicit cast. */ 1114 op0 = convert (result_type, op0); 1115 op1 = convert (result_type, op1); 1116 1117 arg0 = c_common_get_narrower (op0, &unsigned0); 1118 arg1 = c_common_get_narrower (op1, &unsigned1); 1119 1120 /* UNS is 1 if the operation to be done is an unsigned one. */ 1121 uns = TYPE_UNSIGNED (result_type); 1122 1123 /* Handle the case that OP0 (or OP1) does not *contain* a conversion 1124 but it *requires* conversion to FINAL_TYPE. */ 1125 1126 if ((TYPE_PRECISION (TREE_TYPE (op0)) 1127 == TYPE_PRECISION (TREE_TYPE (arg0))) 1128 && TREE_TYPE (op0) != result_type) 1129 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 1130 if ((TYPE_PRECISION (TREE_TYPE (op1)) 1131 == TYPE_PRECISION (TREE_TYPE (arg1))) 1132 && TREE_TYPE (op1) != result_type) 1133 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 1134 1135 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 1136 1137 /* For bitwise operations, signedness of nominal type 1138 does not matter. Consider only how operands were extended. */ 1139 if (bitwise) 1140 uns = unsigned0; 1141 1142 /* Note that in all three cases below we refrain from optimizing 1143 an unsigned operation on sign-extended args. 1144 That would not be valid. */ 1145 1146 /* Both args variable: if both extended in same way 1147 from same width, do it in that width. 1148 Do it unsigned if args were zero-extended. */ 1149 if ((TYPE_PRECISION (TREE_TYPE (arg0)) 1150 < TYPE_PRECISION (result_type)) 1151 && (TYPE_PRECISION (TREE_TYPE (arg1)) 1152 == TYPE_PRECISION (TREE_TYPE (arg0))) 1153 && unsigned0 == unsigned1 1154 && (unsigned0 || !uns)) 1155 return c_common_signed_or_unsigned_type 1156 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 1157 1158 else if (TREE_CODE (arg0) == INTEGER_CST 1159 && (unsigned1 || !uns) 1160 && (TYPE_PRECISION (TREE_TYPE (arg1)) 1161 < TYPE_PRECISION (result_type)) 1162 && (type 1163 = c_common_signed_or_unsigned_type (unsigned1, 1164 TREE_TYPE (arg1))) 1165 && !POINTER_TYPE_P (type) 1166 && int_fits_type_p (arg0, type)) 1167 return type; 1168 1169 else if (TREE_CODE (arg1) == INTEGER_CST 1170 && (unsigned0 || !uns) 1171 && (TYPE_PRECISION (TREE_TYPE (arg0)) 1172 < TYPE_PRECISION (result_type)) 1173 && (type 1174 = c_common_signed_or_unsigned_type (unsigned0, 1175 TREE_TYPE (arg0))) 1176 && !POINTER_TYPE_P (type) 1177 && int_fits_type_p (arg1, type)) 1178 return type; 1179 1180 return result_type; 1181 } 1182 1183 /* Returns true iff any integer value of type FROM_TYPE can be represented as 1184 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */ 1185 1186 static bool 1187 int_safely_convertible_to_real_p (const_tree from_type, const_tree to_type) 1188 { 1189 tree type_low_bound = TYPE_MIN_VALUE (from_type); 1190 tree type_high_bound = TYPE_MAX_VALUE (from_type); 1191 REAL_VALUE_TYPE real_low_bound = 1192 real_value_from_int_cst (0, type_low_bound); 1193 REAL_VALUE_TYPE real_high_bound = 1194 real_value_from_int_cst (0, type_high_bound); 1195 1196 return exact_real_truncate (TYPE_MODE (to_type), &real_low_bound) 1197 && exact_real_truncate (TYPE_MODE (to_type), &real_high_bound); 1198 } 1199 1200 /* Checks if expression EXPR of complex/real/integer type cannot be converted 1201 to the complex/real/integer type TYPE. Function returns non-zero when: 1202 * EXPR is a constant which cannot be exactly converted to TYPE. 1203 * EXPR is not a constant and size of EXPR's type > than size of TYPE, 1204 for EXPR type and TYPE being both integers or both real, or both 1205 complex. 1206 * EXPR is not a constant of complex type and TYPE is a real or 1207 an integer. 1208 * EXPR is not a constant of real type and TYPE is an integer. 1209 * EXPR is not a constant of integer type which cannot be 1210 exactly converted to real type. 1211 1212 Function allows conversions between types of different signedness and 1213 can return SAFE_CONVERSION (zero) in that case. Function can produce 1214 signedness warnings if PRODUCE_WARNS is true. 1215 1216 RESULT, when non-null is the result of the conversion. When constant 1217 it is included in the text of diagnostics. 1218 1219 Function allows conversions from complex constants to non-complex types, 1220 provided that imaginary part is zero and real part can be safely converted 1221 to TYPE. */ 1222 1223 enum conversion_safety 1224 unsafe_conversion_p (location_t loc, tree type, tree expr, tree result, 1225 bool produce_warns) 1226 { 1227 enum conversion_safety give_warning = SAFE_CONVERSION; /* is 0 or false */ 1228 tree expr_type = TREE_TYPE (expr); 1229 1230 bool cstresult = (result 1231 && TREE_CODE_CLASS (TREE_CODE (result)) == tcc_constant); 1232 1233 loc = expansion_point_location_if_in_system_header (loc); 1234 1235 if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST) 1236 { 1237 /* If type is complex, we are interested in compatibility with 1238 underlying type. */ 1239 if (TREE_CODE (type) == COMPLEX_TYPE) 1240 type = TREE_TYPE (type); 1241 1242 /* Warn for real constant that is not an exact integer converted 1243 to integer type. */ 1244 if (TREE_CODE (expr_type) == REAL_TYPE 1245 && TREE_CODE (type) == INTEGER_TYPE) 1246 { 1247 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type))) 1248 give_warning = UNSAFE_REAL; 1249 } 1250 /* Warn for an integer constant that does not fit into integer type. */ 1251 else if (TREE_CODE (expr_type) == INTEGER_TYPE 1252 && TREE_CODE (type) == INTEGER_TYPE 1253 && !int_fits_type_p (expr, type)) 1254 { 1255 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type) 1256 && tree_int_cst_sgn (expr) < 0) 1257 { 1258 if (produce_warns) 1259 { 1260 if (cstresult) 1261 warning_at (loc, OPT_Wsign_conversion, 1262 "unsigned conversion from %qT to %qT " 1263 "changes value from %qE to %qE", 1264 expr_type, type, expr, result); 1265 else 1266 warning_at (loc, OPT_Wsign_conversion, 1267 "unsigned conversion from %qT to %qT " 1268 "changes the value of %qE", 1269 expr_type, type, expr); 1270 } 1271 } 1272 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type)) 1273 { 1274 if (cstresult) 1275 warning_at (loc, OPT_Wsign_conversion, 1276 "signed conversion from %qT to %qT changes " 1277 "value from %qE to %qE", 1278 expr_type, type, expr, result); 1279 else 1280 warning_at (loc, OPT_Wsign_conversion, 1281 "signed conversion from %qT to %qT changes " 1282 "the value of %qE", 1283 expr_type, type, expr); 1284 } 1285 else 1286 give_warning = UNSAFE_OTHER; 1287 } 1288 else if (TREE_CODE (type) == REAL_TYPE) 1289 { 1290 /* Warn for an integer constant that does not fit into real type. */ 1291 if (TREE_CODE (expr_type) == INTEGER_TYPE) 1292 { 1293 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr); 1294 if (!exact_real_truncate (TYPE_MODE (type), &a)) 1295 give_warning = UNSAFE_REAL; 1296 } 1297 /* Warn for a real constant that does not fit into a smaller 1298 real type. */ 1299 else if (TREE_CODE (expr_type) == REAL_TYPE 1300 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 1301 { 1302 REAL_VALUE_TYPE a = TREE_REAL_CST (expr); 1303 if (!exact_real_truncate (TYPE_MODE (type), &a)) 1304 give_warning = UNSAFE_REAL; 1305 } 1306 } 1307 } 1308 1309 else if (TREE_CODE (expr) == COMPLEX_CST) 1310 { 1311 tree imag_part = TREE_IMAGPART (expr); 1312 /* Conversion from complex constant with zero imaginary part, 1313 perform check for conversion of real part. */ 1314 if ((TREE_CODE (imag_part) == REAL_CST 1315 && real_zerop (imag_part)) 1316 || (TREE_CODE (imag_part) == INTEGER_CST 1317 && integer_zerop (imag_part))) 1318 /* Note: in this branch we use recursive call to unsafe_conversion_p 1319 with different type of EXPR, but it is still safe, because when EXPR 1320 is a constant, it's type is not used in text of generated warnings 1321 (otherwise they could sound misleading). */ 1322 return unsafe_conversion_p (loc, type, TREE_REALPART (expr), result, 1323 produce_warns); 1324 /* Conversion from complex constant with non-zero imaginary part. */ 1325 else 1326 { 1327 /* Conversion to complex type. 1328 Perform checks for both real and imaginary parts. */ 1329 if (TREE_CODE (type) == COMPLEX_TYPE) 1330 { 1331 /* Unfortunately, produce_warns must be false in two subsequent 1332 calls of unsafe_conversion_p, because otherwise we could 1333 produce strange "double" warnings, if both real and imaginary 1334 parts have conversion problems related to signedness. 1335 1336 For example: 1337 int32_t _Complex a = 0x80000000 + 0x80000000i; 1338 1339 Possible solution: add a separate function for checking 1340 constants and combine result of two calls appropriately. */ 1341 enum conversion_safety re_safety = 1342 unsafe_conversion_p (loc, type, TREE_REALPART (expr), 1343 result, false); 1344 enum conversion_safety im_safety = 1345 unsafe_conversion_p (loc, type, imag_part, result, false); 1346 1347 /* Merge the results into appropriate single warning. */ 1348 1349 /* Note: this case includes SAFE_CONVERSION, i.e. success. */ 1350 if (re_safety == im_safety) 1351 give_warning = re_safety; 1352 else if (!re_safety && im_safety) 1353 give_warning = im_safety; 1354 else if (re_safety && !im_safety) 1355 give_warning = re_safety; 1356 else 1357 give_warning = UNSAFE_OTHER; 1358 } 1359 /* Warn about conversion from complex to real or integer type. */ 1360 else 1361 give_warning = UNSAFE_IMAGINARY; 1362 } 1363 } 1364 1365 /* Checks for remaining case: EXPR is not constant. */ 1366 else 1367 { 1368 /* Warn for real types converted to integer types. */ 1369 if (TREE_CODE (expr_type) == REAL_TYPE 1370 && TREE_CODE (type) == INTEGER_TYPE) 1371 give_warning = UNSAFE_REAL; 1372 1373 else if (TREE_CODE (expr_type) == INTEGER_TYPE 1374 && TREE_CODE (type) == INTEGER_TYPE) 1375 { 1376 /* Don't warn about unsigned char y = 0xff, x = (int) y; */ 1377 expr = get_unwidened (expr, 0); 1378 expr_type = TREE_TYPE (expr); 1379 1380 /* Don't warn for short y; short x = ((int)y & 0xff); */ 1381 if (TREE_CODE (expr) == BIT_AND_EXPR 1382 || TREE_CODE (expr) == BIT_IOR_EXPR 1383 || TREE_CODE (expr) == BIT_XOR_EXPR) 1384 { 1385 /* If both args were extended from a shortest type, 1386 use that type if that is safe. */ 1387 expr_type = shorten_binary_op (expr_type, 1388 TREE_OPERAND (expr, 0), 1389 TREE_OPERAND (expr, 1), 1390 /* bitwise */1); 1391 1392 if (TREE_CODE (expr) == BIT_AND_EXPR) 1393 { 1394 tree op0 = TREE_OPERAND (expr, 0); 1395 tree op1 = TREE_OPERAND (expr, 1); 1396 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 1397 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 1398 1399 /* If one of the operands is a non-negative constant 1400 that fits in the target type, then the type of the 1401 other operand does not matter. */ 1402 if ((TREE_CODE (op0) == INTEGER_CST 1403 && int_fits_type_p (op0, c_common_signed_type (type)) 1404 && int_fits_type_p (op0, c_common_unsigned_type (type))) 1405 || (TREE_CODE (op1) == INTEGER_CST 1406 && int_fits_type_p (op1, c_common_signed_type (type)) 1407 && int_fits_type_p (op1, 1408 c_common_unsigned_type (type)))) 1409 return SAFE_CONVERSION; 1410 /* If constant is unsigned and fits in the target 1411 type, then the result will also fit. */ 1412 else if ((TREE_CODE (op0) == INTEGER_CST 1413 && unsigned0 1414 && int_fits_type_p (op0, type)) 1415 || (TREE_CODE (op1) == INTEGER_CST 1416 && unsigned1 1417 && int_fits_type_p (op1, type))) 1418 return SAFE_CONVERSION; 1419 } 1420 } 1421 /* Warn for integer types converted to smaller integer types. */ 1422 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 1423 give_warning = UNSAFE_OTHER; 1424 1425 /* When they are the same width but different signedness, 1426 then the value may change. */ 1427 else if (((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type) 1428 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type)) 1429 /* Even when converted to a bigger type, if the type is 1430 unsigned but expr is signed, then negative values 1431 will be changed. */ 1432 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type))) 1433 && produce_warns) 1434 warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT " 1435 "may change the sign of the result", 1436 type, expr_type); 1437 } 1438 1439 /* Warn for integer types converted to real types if and only if 1440 all the range of values of the integer type cannot be 1441 represented by the real type. */ 1442 else if (TREE_CODE (expr_type) == INTEGER_TYPE 1443 && TREE_CODE (type) == REAL_TYPE) 1444 { 1445 /* Don't warn about char y = 0xff; float x = (int) y; */ 1446 expr = get_unwidened (expr, 0); 1447 expr_type = TREE_TYPE (expr); 1448 1449 if (!int_safely_convertible_to_real_p (expr_type, type)) 1450 give_warning = UNSAFE_OTHER; 1451 } 1452 1453 /* Warn for real types converted to smaller real types. */ 1454 else if (TREE_CODE (expr_type) == REAL_TYPE 1455 && TREE_CODE (type) == REAL_TYPE 1456 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 1457 give_warning = UNSAFE_REAL; 1458 1459 /* Check conversion between two complex types. */ 1460 else if (TREE_CODE (expr_type) == COMPLEX_TYPE 1461 && TREE_CODE (type) == COMPLEX_TYPE) 1462 { 1463 /* Extract underlying types (i.e., type of real and imaginary 1464 parts) of expr_type and type. */ 1465 tree from_type = TREE_TYPE (expr_type); 1466 tree to_type = TREE_TYPE (type); 1467 1468 /* Warn for real types converted to integer types. */ 1469 if (TREE_CODE (from_type) == REAL_TYPE 1470 && TREE_CODE (to_type) == INTEGER_TYPE) 1471 give_warning = UNSAFE_REAL; 1472 1473 /* Warn for real types converted to smaller real types. */ 1474 else if (TREE_CODE (from_type) == REAL_TYPE 1475 && TREE_CODE (to_type) == REAL_TYPE 1476 && TYPE_PRECISION (to_type) < TYPE_PRECISION (from_type)) 1477 give_warning = UNSAFE_REAL; 1478 1479 /* Check conversion for complex integer types. Here implementation 1480 is simpler than for real-domain integers because it does not 1481 involve sophisticated cases, such as bitmasks, casts, etc. */ 1482 else if (TREE_CODE (from_type) == INTEGER_TYPE 1483 && TREE_CODE (to_type) == INTEGER_TYPE) 1484 { 1485 /* Warn for integer types converted to smaller integer types. */ 1486 if (TYPE_PRECISION (to_type) < TYPE_PRECISION (from_type)) 1487 give_warning = UNSAFE_OTHER; 1488 1489 /* Check for different signedness, see case for real-domain 1490 integers (above) for a more detailed comment. */ 1491 else if (((TYPE_PRECISION (to_type) == TYPE_PRECISION (from_type) 1492 && TYPE_UNSIGNED (to_type) != TYPE_UNSIGNED (from_type)) 1493 || (TYPE_UNSIGNED (to_type) && !TYPE_UNSIGNED (from_type))) 1494 && produce_warns) 1495 warning_at (loc, OPT_Wsign_conversion, 1496 "conversion to %qT from %qT " 1497 "may change the sign of the result", 1498 type, expr_type); 1499 } 1500 else if (TREE_CODE (from_type) == INTEGER_TYPE 1501 && TREE_CODE (to_type) == REAL_TYPE 1502 && !int_safely_convertible_to_real_p (from_type, to_type)) 1503 give_warning = UNSAFE_OTHER; 1504 } 1505 1506 /* Warn for complex types converted to real or integer types. */ 1507 else if (TREE_CODE (expr_type) == COMPLEX_TYPE 1508 && TREE_CODE (type) != COMPLEX_TYPE) 1509 give_warning = UNSAFE_IMAGINARY; 1510 } 1511 1512 return give_warning; 1513 } 1514 1515 1516 /* Convert EXPR to TYPE, warning about conversion problems with constants. 1517 Invoke this function on every expression that is converted implicitly, 1518 i.e. because of language rules and not because of an explicit cast. */ 1519 1520 tree 1521 convert_and_check (location_t loc, tree type, tree expr) 1522 { 1523 tree result; 1524 tree expr_for_warning; 1525 1526 /* Convert from a value with possible excess precision rather than 1527 via the semantic type, but do not warn about values not fitting 1528 exactly in the semantic type. */ 1529 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR) 1530 { 1531 tree orig_type = TREE_TYPE (expr); 1532 expr = TREE_OPERAND (expr, 0); 1533 expr_for_warning = convert (orig_type, expr); 1534 if (orig_type == type) 1535 return expr_for_warning; 1536 } 1537 else 1538 expr_for_warning = expr; 1539 1540 if (TREE_TYPE (expr) == type) 1541 return expr; 1542 1543 result = convert (type, expr); 1544 1545 if (c_inhibit_evaluation_warnings == 0 1546 && !TREE_OVERFLOW_P (expr) 1547 && result != error_mark_node) 1548 warnings_for_convert_and_check (loc, type, expr_for_warning, result); 1549 1550 return result; 1551 } 1552 1553 /* A node in a list that describes references to variables (EXPR), which are 1554 either read accesses if WRITER is zero, or write accesses, in which case 1555 WRITER is the parent of EXPR. */ 1556 struct tlist 1557 { 1558 struct tlist *next; 1559 tree expr, writer; 1560 }; 1561 1562 /* Used to implement a cache the results of a call to verify_tree. We only 1563 use this for SAVE_EXPRs. */ 1564 struct tlist_cache 1565 { 1566 struct tlist_cache *next; 1567 struct tlist *cache_before_sp; 1568 struct tlist *cache_after_sp; 1569 tree expr; 1570 }; 1571 1572 /* Obstack to use when allocating tlist structures, and corresponding 1573 firstobj. */ 1574 static struct obstack tlist_obstack; 1575 static char *tlist_firstobj = 0; 1576 1577 /* Keep track of the identifiers we've warned about, so we can avoid duplicate 1578 warnings. */ 1579 static struct tlist *warned_ids; 1580 /* SAVE_EXPRs need special treatment. We process them only once and then 1581 cache the results. */ 1582 static struct tlist_cache *save_expr_cache; 1583 1584 static void add_tlist (struct tlist **, struct tlist *, tree, int); 1585 static void merge_tlist (struct tlist **, struct tlist *, int); 1586 static void verify_tree (tree, struct tlist **, struct tlist **, tree); 1587 static bool warning_candidate_p (tree); 1588 static bool candidate_equal_p (const_tree, const_tree); 1589 static void warn_for_collisions (struct tlist *); 1590 static void warn_for_collisions_1 (tree, tree, struct tlist *, int); 1591 static struct tlist *new_tlist (struct tlist *, tree, tree); 1592 1593 /* Create a new struct tlist and fill in its fields. */ 1594 static struct tlist * 1595 new_tlist (struct tlist *next, tree t, tree writer) 1596 { 1597 struct tlist *l; 1598 l = XOBNEW (&tlist_obstack, struct tlist); 1599 l->next = next; 1600 l->expr = t; 1601 l->writer = writer; 1602 return l; 1603 } 1604 1605 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER 1606 is nonnull, we ignore any node we find which has a writer equal to it. */ 1607 1608 static void 1609 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy) 1610 { 1611 while (add) 1612 { 1613 struct tlist *next = add->next; 1614 if (!copy) 1615 add->next = *to; 1616 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer)) 1617 *to = copy ? new_tlist (*to, add->expr, add->writer) : add; 1618 add = next; 1619 } 1620 } 1621 1622 /* Merge the nodes of ADD into TO. This merging process is done so that for 1623 each variable that already exists in TO, no new node is added; however if 1624 there is a write access recorded in ADD, and an occurrence on TO is only 1625 a read access, then the occurrence in TO will be modified to record the 1626 write. */ 1627 1628 static void 1629 merge_tlist (struct tlist **to, struct tlist *add, int copy) 1630 { 1631 struct tlist **end = to; 1632 1633 while (*end) 1634 end = &(*end)->next; 1635 1636 while (add) 1637 { 1638 int found = 0; 1639 struct tlist *tmp2; 1640 struct tlist *next = add->next; 1641 1642 for (tmp2 = *to; tmp2; tmp2 = tmp2->next) 1643 if (candidate_equal_p (tmp2->expr, add->expr)) 1644 { 1645 found = 1; 1646 if (!tmp2->writer) 1647 tmp2->writer = add->writer; 1648 } 1649 if (!found) 1650 { 1651 *end = copy ? new_tlist (NULL, add->expr, add->writer) : add; 1652 end = &(*end)->next; 1653 *end = 0; 1654 } 1655 add = next; 1656 } 1657 } 1658 1659 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable 1660 references in list LIST conflict with it, excluding reads if ONLY writers 1661 is nonzero. */ 1662 1663 static void 1664 warn_for_collisions_1 (tree written, tree writer, struct tlist *list, 1665 int only_writes) 1666 { 1667 struct tlist *tmp; 1668 1669 /* Avoid duplicate warnings. */ 1670 for (tmp = warned_ids; tmp; tmp = tmp->next) 1671 if (candidate_equal_p (tmp->expr, written)) 1672 return; 1673 1674 while (list) 1675 { 1676 if (candidate_equal_p (list->expr, written) 1677 && !candidate_equal_p (list->writer, writer) 1678 && (!only_writes || list->writer)) 1679 { 1680 warned_ids = new_tlist (warned_ids, written, NULL_TREE); 1681 warning_at (EXPR_LOC_OR_LOC (writer, input_location), 1682 OPT_Wsequence_point, "operation on %qE may be undefined", 1683 list->expr); 1684 } 1685 list = list->next; 1686 } 1687 } 1688 1689 /* Given a list LIST of references to variables, find whether any of these 1690 can cause conflicts due to missing sequence points. */ 1691 1692 static void 1693 warn_for_collisions (struct tlist *list) 1694 { 1695 struct tlist *tmp; 1696 1697 for (tmp = list; tmp; tmp = tmp->next) 1698 { 1699 if (tmp->writer) 1700 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0); 1701 } 1702 } 1703 1704 /* Return nonzero if X is a tree that can be verified by the sequence point 1705 warnings. */ 1706 1707 static bool 1708 warning_candidate_p (tree x) 1709 { 1710 if (DECL_P (x) && DECL_ARTIFICIAL (x)) 1711 return false; 1712 1713 if (TREE_CODE (x) == BLOCK) 1714 return false; 1715 1716 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c 1717 (lvalue_p) crash on TRY/CATCH. */ 1718 if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x))) 1719 return false; 1720 1721 if (!lvalue_p (x)) 1722 return false; 1723 1724 /* No point to track non-const calls, they will never satisfy 1725 operand_equal_p. */ 1726 if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0) 1727 return false; 1728 1729 if (TREE_CODE (x) == STRING_CST) 1730 return false; 1731 1732 return true; 1733 } 1734 1735 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */ 1736 static bool 1737 candidate_equal_p (const_tree x, const_tree y) 1738 { 1739 return (x == y) || (x && y && operand_equal_p (x, y, 0)); 1740 } 1741 1742 /* Walk the tree X, and record accesses to variables. If X is written by the 1743 parent tree, WRITER is the parent. 1744 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this 1745 expression or its only operand forces a sequence point, then everything up 1746 to the sequence point is stored in PBEFORE_SP. Everything else gets stored 1747 in PNO_SP. 1748 Once we return, we will have emitted warnings if any subexpression before 1749 such a sequence point could be undefined. On a higher level, however, the 1750 sequence point may not be relevant, and we'll merge the two lists. 1751 1752 Example: (b++, a) + b; 1753 The call that processes the COMPOUND_EXPR will store the increment of B 1754 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that 1755 processes the PLUS_EXPR will need to merge the two lists so that 1756 eventually, all accesses end up on the same list (and we'll warn about the 1757 unordered subexpressions b++ and b. 1758 1759 A note on merging. If we modify the former example so that our expression 1760 becomes 1761 (b++, b) + a 1762 care must be taken not simply to add all three expressions into the final 1763 PNO_SP list. The function merge_tlist takes care of that by merging the 1764 before-SP list of the COMPOUND_EXPR into its after-SP list in a special 1765 way, so that no more than one access to B is recorded. */ 1766 1767 static void 1768 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp, 1769 tree writer) 1770 { 1771 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3; 1772 enum tree_code code; 1773 enum tree_code_class cl; 1774 1775 /* X may be NULL if it is the operand of an empty statement expression 1776 ({ }). */ 1777 if (x == NULL) 1778 return; 1779 1780 restart: 1781 code = TREE_CODE (x); 1782 cl = TREE_CODE_CLASS (code); 1783 1784 if (warning_candidate_p (x)) 1785 *pno_sp = new_tlist (*pno_sp, x, writer); 1786 1787 switch (code) 1788 { 1789 case CONSTRUCTOR: 1790 case SIZEOF_EXPR: 1791 return; 1792 1793 case COMPOUND_EXPR: 1794 case TRUTH_ANDIF_EXPR: 1795 case TRUTH_ORIF_EXPR: 1796 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0; 1797 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 1798 warn_for_collisions (tmp_nosp); 1799 merge_tlist (pbefore_sp, tmp_before, 0); 1800 merge_tlist (pbefore_sp, tmp_nosp, 0); 1801 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_list2, NULL_TREE); 1802 warn_for_collisions (tmp_list2); 1803 merge_tlist (pbefore_sp, tmp_list3, 0); 1804 merge_tlist (pno_sp, tmp_list2, 0); 1805 return; 1806 1807 case COND_EXPR: 1808 tmp_before = tmp_list2 = 0; 1809 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE); 1810 warn_for_collisions (tmp_list2); 1811 merge_tlist (pbefore_sp, tmp_before, 0); 1812 merge_tlist (pbefore_sp, tmp_list2, 0); 1813 1814 tmp_list3 = tmp_nosp = 0; 1815 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE); 1816 warn_for_collisions (tmp_nosp); 1817 merge_tlist (pbefore_sp, tmp_list3, 0); 1818 1819 tmp_list3 = tmp_list2 = 0; 1820 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE); 1821 warn_for_collisions (tmp_list2); 1822 merge_tlist (pbefore_sp, tmp_list3, 0); 1823 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the 1824 two first, to avoid warning for (a ? b++ : b++). */ 1825 merge_tlist (&tmp_nosp, tmp_list2, 0); 1826 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1827 return; 1828 1829 case PREDECREMENT_EXPR: 1830 case PREINCREMENT_EXPR: 1831 case POSTDECREMENT_EXPR: 1832 case POSTINCREMENT_EXPR: 1833 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x); 1834 return; 1835 1836 case MODIFY_EXPR: 1837 tmp_before = tmp_nosp = tmp_list3 = 0; 1838 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE); 1839 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x); 1840 /* Expressions inside the LHS are not ordered wrt. the sequence points 1841 in the RHS. Example: 1842 *a = (a++, 2) 1843 Despite the fact that the modification of "a" is in the before_sp 1844 list (tmp_before), it conflicts with the use of "a" in the LHS. 1845 We can handle this by adding the contents of tmp_list3 1846 to those of tmp_before, and redoing the collision warnings for that 1847 list. */ 1848 add_tlist (&tmp_before, tmp_list3, x, 1); 1849 warn_for_collisions (tmp_before); 1850 /* Exclude the LHS itself here; we first have to merge it into the 1851 tmp_nosp list. This is done to avoid warning for "a = a"; if we 1852 didn't exclude the LHS, we'd get it twice, once as a read and once 1853 as a write. */ 1854 add_tlist (pno_sp, tmp_list3, x, 0); 1855 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1); 1856 1857 merge_tlist (pbefore_sp, tmp_before, 0); 1858 if (warning_candidate_p (TREE_OPERAND (x, 0))) 1859 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0); 1860 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1); 1861 return; 1862 1863 case CALL_EXPR: 1864 /* We need to warn about conflicts among arguments and conflicts between 1865 args and the function address. Side effects of the function address, 1866 however, are not ordered by the sequence point of the call. */ 1867 { 1868 call_expr_arg_iterator iter; 1869 tree arg; 1870 tmp_before = tmp_nosp = 0; 1871 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE); 1872 FOR_EACH_CALL_EXPR_ARG (arg, iter, x) 1873 { 1874 tmp_list2 = tmp_list3 = 0; 1875 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE); 1876 merge_tlist (&tmp_list3, tmp_list2, 0); 1877 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0); 1878 } 1879 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0); 1880 warn_for_collisions (tmp_before); 1881 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0); 1882 return; 1883 } 1884 1885 case TREE_LIST: 1886 /* Scan all the list, e.g. indices of multi dimensional array. */ 1887 while (x) 1888 { 1889 tmp_before = tmp_nosp = 0; 1890 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE); 1891 merge_tlist (&tmp_nosp, tmp_before, 0); 1892 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1893 x = TREE_CHAIN (x); 1894 } 1895 return; 1896 1897 case SAVE_EXPR: 1898 { 1899 struct tlist_cache *t; 1900 for (t = save_expr_cache; t; t = t->next) 1901 if (candidate_equal_p (t->expr, x)) 1902 break; 1903 1904 if (!t) 1905 { 1906 t = XOBNEW (&tlist_obstack, struct tlist_cache); 1907 t->next = save_expr_cache; 1908 t->expr = x; 1909 save_expr_cache = t; 1910 1911 tmp_before = tmp_nosp = 0; 1912 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE); 1913 warn_for_collisions (tmp_nosp); 1914 1915 tmp_list3 = 0; 1916 merge_tlist (&tmp_list3, tmp_nosp, 0); 1917 t->cache_before_sp = tmp_before; 1918 t->cache_after_sp = tmp_list3; 1919 } 1920 merge_tlist (pbefore_sp, t->cache_before_sp, 1); 1921 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1); 1922 return; 1923 } 1924 1925 case ADDR_EXPR: 1926 x = TREE_OPERAND (x, 0); 1927 if (DECL_P (x)) 1928 return; 1929 writer = 0; 1930 goto restart; 1931 1932 default: 1933 /* For other expressions, simply recurse on their operands. 1934 Manual tail recursion for unary expressions. 1935 Other non-expressions need not be processed. */ 1936 if (cl == tcc_unary) 1937 { 1938 x = TREE_OPERAND (x, 0); 1939 writer = 0; 1940 goto restart; 1941 } 1942 else if (IS_EXPR_CODE_CLASS (cl)) 1943 { 1944 int lp; 1945 int max = TREE_OPERAND_LENGTH (x); 1946 for (lp = 0; lp < max; lp++) 1947 { 1948 tmp_before = tmp_nosp = 0; 1949 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0); 1950 merge_tlist (&tmp_nosp, tmp_before, 0); 1951 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0); 1952 } 1953 } 1954 return; 1955 } 1956 } 1957 1958 /* Try to warn for undefined behavior in EXPR due to missing sequence 1959 points. */ 1960 1961 DEBUG_FUNCTION void 1962 verify_sequence_points (tree expr) 1963 { 1964 struct tlist *before_sp = 0, *after_sp = 0; 1965 1966 warned_ids = 0; 1967 save_expr_cache = 0; 1968 if (tlist_firstobj == 0) 1969 { 1970 gcc_obstack_init (&tlist_obstack); 1971 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0); 1972 } 1973 1974 verify_tree (expr, &before_sp, &after_sp, 0); 1975 warn_for_collisions (after_sp); 1976 obstack_free (&tlist_obstack, tlist_firstobj); 1977 } 1978 1979 /* Validate the expression after `case' and apply default promotions. */ 1980 1981 static tree 1982 check_case_value (location_t loc, tree value) 1983 { 1984 if (value == NULL_TREE) 1985 return value; 1986 1987 if (TREE_CODE (value) == INTEGER_CST) 1988 /* Promote char or short to int. */ 1989 value = perform_integral_promotions (value); 1990 else if (value != error_mark_node) 1991 { 1992 error_at (loc, "case label does not reduce to an integer constant"); 1993 value = error_mark_node; 1994 } 1995 1996 constant_expression_warning (value); 1997 1998 return value; 1999 } 2000 2001 /* See if the case values LOW and HIGH are in the range of the original 2002 type (i.e. before the default conversion to int) of the switch testing 2003 expression. 2004 TYPE is the promoted type of the testing expression, and ORIG_TYPE is 2005 the type before promoting it. CASE_LOW_P is a pointer to the lower 2006 bound of the case label, and CASE_HIGH_P is the upper bound or NULL 2007 if the case is not a case range. 2008 The caller has to make sure that we are not called with NULL for 2009 CASE_LOW_P (i.e. the default case). OUTSIDE_RANGE_P says whether there 2010 was a case value that doesn't fit into the range of the ORIG_TYPE. 2011 Returns true if the case label is in range of ORIG_TYPE (saturated or 2012 untouched) or false if the label is out of range. */ 2013 2014 static bool 2015 check_case_bounds (location_t loc, tree type, tree orig_type, 2016 tree *case_low_p, tree *case_high_p, 2017 bool *outside_range_p) 2018 { 2019 tree min_value, max_value; 2020 tree case_low = *case_low_p; 2021 tree case_high = case_high_p ? *case_high_p : case_low; 2022 2023 /* If there was a problem with the original type, do nothing. */ 2024 if (orig_type == error_mark_node) 2025 return true; 2026 2027 min_value = TYPE_MIN_VALUE (orig_type); 2028 max_value = TYPE_MAX_VALUE (orig_type); 2029 2030 /* We'll really need integer constants here. */ 2031 case_low = fold (case_low); 2032 case_high = fold (case_high); 2033 2034 /* Case label is less than minimum for type. */ 2035 if (tree_int_cst_compare (case_low, min_value) < 0 2036 && tree_int_cst_compare (case_high, min_value) < 0) 2037 { 2038 warning_at (loc, 0, "case label value is less than minimum value " 2039 "for type"); 2040 *outside_range_p = true; 2041 return false; 2042 } 2043 2044 /* Case value is greater than maximum for type. */ 2045 if (tree_int_cst_compare (case_low, max_value) > 0 2046 && tree_int_cst_compare (case_high, max_value) > 0) 2047 { 2048 warning_at (loc, 0, "case label value exceeds maximum value for type"); 2049 *outside_range_p = true; 2050 return false; 2051 } 2052 2053 /* Saturate lower case label value to minimum. */ 2054 if (tree_int_cst_compare (case_high, min_value) >= 0 2055 && tree_int_cst_compare (case_low, min_value) < 0) 2056 { 2057 warning_at (loc, 0, "lower value in case label range" 2058 " less than minimum value for type"); 2059 *outside_range_p = true; 2060 case_low = min_value; 2061 } 2062 2063 /* Saturate upper case label value to maximum. */ 2064 if (tree_int_cst_compare (case_low, max_value) <= 0 2065 && tree_int_cst_compare (case_high, max_value) > 0) 2066 { 2067 warning_at (loc, 0, "upper value in case label range" 2068 " exceeds maximum value for type"); 2069 *outside_range_p = true; 2070 case_high = max_value; 2071 } 2072 2073 if (*case_low_p != case_low) 2074 *case_low_p = convert (type, case_low); 2075 if (case_high_p && *case_high_p != case_high) 2076 *case_high_p = convert (type, case_high); 2077 2078 return true; 2079 } 2080 2081 /* Return an integer type with BITS bits of precision, 2082 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 2083 2084 tree 2085 c_common_type_for_size (unsigned int bits, int unsignedp) 2086 { 2087 int i; 2088 2089 if (bits == TYPE_PRECISION (integer_type_node)) 2090 return unsignedp ? unsigned_type_node : integer_type_node; 2091 2092 if (bits == TYPE_PRECISION (signed_char_type_node)) 2093 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2094 2095 if (bits == TYPE_PRECISION (short_integer_type_node)) 2096 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2097 2098 if (bits == TYPE_PRECISION (long_integer_type_node)) 2099 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2100 2101 if (bits == TYPE_PRECISION (long_long_integer_type_node)) 2102 return (unsignedp ? long_long_unsigned_type_node 2103 : long_long_integer_type_node); 2104 2105 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2106 if (int_n_enabled_p[i] 2107 && bits == int_n_data[i].bitsize) 2108 return (unsignedp ? int_n_trees[i].unsigned_type 2109 : int_n_trees[i].signed_type); 2110 2111 if (bits == TYPE_PRECISION (widest_integer_literal_type_node)) 2112 return (unsignedp ? widest_unsigned_literal_type_node 2113 : widest_integer_literal_type_node); 2114 2115 if (bits <= TYPE_PRECISION (intQI_type_node)) 2116 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2117 2118 if (bits <= TYPE_PRECISION (intHI_type_node)) 2119 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2120 2121 if (bits <= TYPE_PRECISION (intSI_type_node)) 2122 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2123 2124 if (bits <= TYPE_PRECISION (intDI_type_node)) 2125 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2126 2127 return NULL_TREE; 2128 } 2129 2130 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits 2131 that is unsigned if UNSIGNEDP is nonzero, otherwise signed; 2132 and saturating if SATP is nonzero, otherwise not saturating. */ 2133 2134 tree 2135 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit, 2136 int unsignedp, int satp) 2137 { 2138 enum mode_class mclass; 2139 if (ibit == 0) 2140 mclass = unsignedp ? MODE_UFRACT : MODE_FRACT; 2141 else 2142 mclass = unsignedp ? MODE_UACCUM : MODE_ACCUM; 2143 2144 opt_scalar_mode opt_mode; 2145 scalar_mode mode; 2146 FOR_EACH_MODE_IN_CLASS (opt_mode, mclass) 2147 { 2148 mode = opt_mode.require (); 2149 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit) 2150 break; 2151 } 2152 2153 if (!opt_mode.exists (&mode) || !targetm.scalar_mode_supported_p (mode)) 2154 { 2155 sorry ("GCC cannot support operators with integer types and " 2156 "fixed-point types that have too many integral and " 2157 "fractional bits together"); 2158 return NULL_TREE; 2159 } 2160 2161 return c_common_type_for_mode (mode, satp); 2162 } 2163 2164 /* Used for communication between c_common_type_for_mode and 2165 c_register_builtin_type. */ 2166 tree registered_builtin_types; 2167 2168 /* Return a data type that has machine mode MODE. 2169 If the mode is an integer, 2170 then UNSIGNEDP selects between signed and unsigned types. 2171 If the mode is a fixed-point mode, 2172 then UNSIGNEDP selects between saturating and nonsaturating types. */ 2173 2174 tree 2175 c_common_type_for_mode (machine_mode mode, int unsignedp) 2176 { 2177 tree t; 2178 int i; 2179 2180 if (mode == TYPE_MODE (integer_type_node)) 2181 return unsignedp ? unsigned_type_node : integer_type_node; 2182 2183 if (mode == TYPE_MODE (signed_char_type_node)) 2184 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2185 2186 if (mode == TYPE_MODE (short_integer_type_node)) 2187 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2188 2189 if (mode == TYPE_MODE (long_integer_type_node)) 2190 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2191 2192 if (mode == TYPE_MODE (long_long_integer_type_node)) 2193 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 2194 2195 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2196 if (int_n_enabled_p[i] 2197 && mode == int_n_data[i].m) 2198 return (unsignedp ? int_n_trees[i].unsigned_type 2199 : int_n_trees[i].signed_type); 2200 2201 if (mode == QImode) 2202 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2203 2204 if (mode == HImode) 2205 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2206 2207 if (mode == SImode) 2208 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2209 2210 if (mode == DImode) 2211 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2212 2213 #if HOST_BITS_PER_WIDE_INT >= 64 2214 if (mode == TYPE_MODE (intTI_type_node)) 2215 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 2216 #endif 2217 2218 if (mode == TYPE_MODE (float_type_node)) 2219 return float_type_node; 2220 2221 if (mode == TYPE_MODE (double_type_node)) 2222 return double_type_node; 2223 2224 if (mode == TYPE_MODE (long_double_type_node)) 2225 return long_double_type_node; 2226 2227 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) 2228 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE 2229 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i))) 2230 return FLOATN_NX_TYPE_NODE (i); 2231 2232 if (mode == TYPE_MODE (void_type_node)) 2233 return void_type_node; 2234 2235 if (mode == TYPE_MODE (build_pointer_type (char_type_node)) 2236 || mode == TYPE_MODE (build_pointer_type (integer_type_node))) 2237 { 2238 unsigned int precision 2239 = GET_MODE_PRECISION (as_a <scalar_int_mode> (mode)); 2240 return (unsignedp 2241 ? make_unsigned_type (precision) 2242 : make_signed_type (precision)); 2243 } 2244 2245 if (COMPLEX_MODE_P (mode)) 2246 { 2247 machine_mode inner_mode; 2248 tree inner_type; 2249 2250 if (mode == TYPE_MODE (complex_float_type_node)) 2251 return complex_float_type_node; 2252 if (mode == TYPE_MODE (complex_double_type_node)) 2253 return complex_double_type_node; 2254 if (mode == TYPE_MODE (complex_long_double_type_node)) 2255 return complex_long_double_type_node; 2256 2257 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) 2258 if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE 2259 && mode == TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i))) 2260 return COMPLEX_FLOATN_NX_TYPE_NODE (i); 2261 2262 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp) 2263 return complex_integer_type_node; 2264 2265 inner_mode = GET_MODE_INNER (mode); 2266 inner_type = c_common_type_for_mode (inner_mode, unsignedp); 2267 if (inner_type != NULL_TREE) 2268 return build_complex_type (inner_type); 2269 } 2270 else if (GET_MODE_CLASS (mode) == MODE_VECTOR_BOOL 2271 && valid_vector_subparts_p (GET_MODE_NUNITS (mode))) 2272 { 2273 unsigned int elem_bits = vector_element_size (GET_MODE_BITSIZE (mode), 2274 GET_MODE_NUNITS (mode)); 2275 tree bool_type = build_nonstandard_boolean_type (elem_bits); 2276 return build_vector_type_for_mode (bool_type, mode); 2277 } 2278 else if (VECTOR_MODE_P (mode) 2279 && valid_vector_subparts_p (GET_MODE_NUNITS (mode))) 2280 { 2281 machine_mode inner_mode = GET_MODE_INNER (mode); 2282 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp); 2283 if (inner_type != NULL_TREE) 2284 return build_vector_type_for_mode (inner_type, mode); 2285 } 2286 2287 if (mode == TYPE_MODE (dfloat32_type_node)) 2288 return dfloat32_type_node; 2289 if (mode == TYPE_MODE (dfloat64_type_node)) 2290 return dfloat64_type_node; 2291 if (mode == TYPE_MODE (dfloat128_type_node)) 2292 return dfloat128_type_node; 2293 2294 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode)) 2295 { 2296 if (mode == TYPE_MODE (short_fract_type_node)) 2297 return unsignedp ? sat_short_fract_type_node : short_fract_type_node; 2298 if (mode == TYPE_MODE (fract_type_node)) 2299 return unsignedp ? sat_fract_type_node : fract_type_node; 2300 if (mode == TYPE_MODE (long_fract_type_node)) 2301 return unsignedp ? sat_long_fract_type_node : long_fract_type_node; 2302 if (mode == TYPE_MODE (long_long_fract_type_node)) 2303 return unsignedp ? sat_long_long_fract_type_node 2304 : long_long_fract_type_node; 2305 2306 if (mode == TYPE_MODE (unsigned_short_fract_type_node)) 2307 return unsignedp ? sat_unsigned_short_fract_type_node 2308 : unsigned_short_fract_type_node; 2309 if (mode == TYPE_MODE (unsigned_fract_type_node)) 2310 return unsignedp ? sat_unsigned_fract_type_node 2311 : unsigned_fract_type_node; 2312 if (mode == TYPE_MODE (unsigned_long_fract_type_node)) 2313 return unsignedp ? sat_unsigned_long_fract_type_node 2314 : unsigned_long_fract_type_node; 2315 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node)) 2316 return unsignedp ? sat_unsigned_long_long_fract_type_node 2317 : unsigned_long_long_fract_type_node; 2318 2319 if (mode == TYPE_MODE (short_accum_type_node)) 2320 return unsignedp ? sat_short_accum_type_node : short_accum_type_node; 2321 if (mode == TYPE_MODE (accum_type_node)) 2322 return unsignedp ? sat_accum_type_node : accum_type_node; 2323 if (mode == TYPE_MODE (long_accum_type_node)) 2324 return unsignedp ? sat_long_accum_type_node : long_accum_type_node; 2325 if (mode == TYPE_MODE (long_long_accum_type_node)) 2326 return unsignedp ? sat_long_long_accum_type_node 2327 : long_long_accum_type_node; 2328 2329 if (mode == TYPE_MODE (unsigned_short_accum_type_node)) 2330 return unsignedp ? sat_unsigned_short_accum_type_node 2331 : unsigned_short_accum_type_node; 2332 if (mode == TYPE_MODE (unsigned_accum_type_node)) 2333 return unsignedp ? sat_unsigned_accum_type_node 2334 : unsigned_accum_type_node; 2335 if (mode == TYPE_MODE (unsigned_long_accum_type_node)) 2336 return unsignedp ? sat_unsigned_long_accum_type_node 2337 : unsigned_long_accum_type_node; 2338 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node)) 2339 return unsignedp ? sat_unsigned_long_long_accum_type_node 2340 : unsigned_long_long_accum_type_node; 2341 2342 if (mode == QQmode) 2343 return unsignedp ? sat_qq_type_node : qq_type_node; 2344 if (mode == HQmode) 2345 return unsignedp ? sat_hq_type_node : hq_type_node; 2346 if (mode == SQmode) 2347 return unsignedp ? sat_sq_type_node : sq_type_node; 2348 if (mode == DQmode) 2349 return unsignedp ? sat_dq_type_node : dq_type_node; 2350 if (mode == TQmode) 2351 return unsignedp ? sat_tq_type_node : tq_type_node; 2352 2353 if (mode == UQQmode) 2354 return unsignedp ? sat_uqq_type_node : uqq_type_node; 2355 if (mode == UHQmode) 2356 return unsignedp ? sat_uhq_type_node : uhq_type_node; 2357 if (mode == USQmode) 2358 return unsignedp ? sat_usq_type_node : usq_type_node; 2359 if (mode == UDQmode) 2360 return unsignedp ? sat_udq_type_node : udq_type_node; 2361 if (mode == UTQmode) 2362 return unsignedp ? sat_utq_type_node : utq_type_node; 2363 2364 if (mode == HAmode) 2365 return unsignedp ? sat_ha_type_node : ha_type_node; 2366 if (mode == SAmode) 2367 return unsignedp ? sat_sa_type_node : sa_type_node; 2368 if (mode == DAmode) 2369 return unsignedp ? sat_da_type_node : da_type_node; 2370 if (mode == TAmode) 2371 return unsignedp ? sat_ta_type_node : ta_type_node; 2372 2373 if (mode == UHAmode) 2374 return unsignedp ? sat_uha_type_node : uha_type_node; 2375 if (mode == USAmode) 2376 return unsignedp ? sat_usa_type_node : usa_type_node; 2377 if (mode == UDAmode) 2378 return unsignedp ? sat_uda_type_node : uda_type_node; 2379 if (mode == UTAmode) 2380 return unsignedp ? sat_uta_type_node : uta_type_node; 2381 } 2382 2383 for (t = registered_builtin_types; t; t = TREE_CHAIN (t)) 2384 if (TYPE_MODE (TREE_VALUE (t)) == mode 2385 && !!unsignedp == !!TYPE_UNSIGNED (TREE_VALUE (t))) 2386 return TREE_VALUE (t); 2387 2388 return NULL_TREE; 2389 } 2390 2391 tree 2392 c_common_unsigned_type (tree type) 2393 { 2394 return c_common_signed_or_unsigned_type (1, type); 2395 } 2396 2397 /* Return a signed type the same as TYPE in other respects. */ 2398 2399 tree 2400 c_common_signed_type (tree type) 2401 { 2402 return c_common_signed_or_unsigned_type (0, type); 2403 } 2404 2405 /* Return a type the same as TYPE except unsigned or 2406 signed according to UNSIGNEDP. */ 2407 2408 tree 2409 c_common_signed_or_unsigned_type (int unsignedp, tree type) 2410 { 2411 tree type1; 2412 int i; 2413 2414 /* This block of code emulates the behavior of the old 2415 c_common_unsigned_type. In particular, it returns 2416 long_unsigned_type_node if passed a long, even when a int would 2417 have the same size. This is necessary for warnings to work 2418 correctly in archs where sizeof(int) == sizeof(long) */ 2419 2420 type1 = TYPE_MAIN_VARIANT (type); 2421 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node) 2422 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2423 if (type1 == integer_type_node || type1 == unsigned_type_node) 2424 return unsignedp ? unsigned_type_node : integer_type_node; 2425 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node) 2426 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2427 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node) 2428 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2429 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node) 2430 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 2431 2432 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2433 if (int_n_enabled_p[i] 2434 && (type1 == int_n_trees[i].unsigned_type 2435 || type1 == int_n_trees[i].signed_type)) 2436 return (unsignedp ? int_n_trees[i].unsigned_type 2437 : int_n_trees[i].signed_type); 2438 2439 #if HOST_BITS_PER_WIDE_INT >= 64 2440 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node) 2441 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 2442 #endif 2443 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node) 2444 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2445 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node) 2446 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2447 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node) 2448 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2449 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node) 2450 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2451 2452 #define C_COMMON_FIXED_TYPES(NAME) \ 2453 if (type1 == short_ ## NAME ## _type_node \ 2454 || type1 == unsigned_short_ ## NAME ## _type_node) \ 2455 return unsignedp ? unsigned_short_ ## NAME ## _type_node \ 2456 : short_ ## NAME ## _type_node; \ 2457 if (type1 == NAME ## _type_node \ 2458 || type1 == unsigned_ ## NAME ## _type_node) \ 2459 return unsignedp ? unsigned_ ## NAME ## _type_node \ 2460 : NAME ## _type_node; \ 2461 if (type1 == long_ ## NAME ## _type_node \ 2462 || type1 == unsigned_long_ ## NAME ## _type_node) \ 2463 return unsignedp ? unsigned_long_ ## NAME ## _type_node \ 2464 : long_ ## NAME ## _type_node; \ 2465 if (type1 == long_long_ ## NAME ## _type_node \ 2466 || type1 == unsigned_long_long_ ## NAME ## _type_node) \ 2467 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \ 2468 : long_long_ ## NAME ## _type_node; 2469 2470 #define C_COMMON_FIXED_MODE_TYPES(NAME) \ 2471 if (type1 == NAME ## _type_node \ 2472 || type1 == u ## NAME ## _type_node) \ 2473 return unsignedp ? u ## NAME ## _type_node \ 2474 : NAME ## _type_node; 2475 2476 #define C_COMMON_FIXED_TYPES_SAT(NAME) \ 2477 if (type1 == sat_ ## short_ ## NAME ## _type_node \ 2478 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \ 2479 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \ 2480 : sat_ ## short_ ## NAME ## _type_node; \ 2481 if (type1 == sat_ ## NAME ## _type_node \ 2482 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \ 2483 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \ 2484 : sat_ ## NAME ## _type_node; \ 2485 if (type1 == sat_ ## long_ ## NAME ## _type_node \ 2486 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \ 2487 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \ 2488 : sat_ ## long_ ## NAME ## _type_node; \ 2489 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \ 2490 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \ 2491 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \ 2492 : sat_ ## long_long_ ## NAME ## _type_node; 2493 2494 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \ 2495 if (type1 == sat_ ## NAME ## _type_node \ 2496 || type1 == sat_ ## u ## NAME ## _type_node) \ 2497 return unsignedp ? sat_ ## u ## NAME ## _type_node \ 2498 : sat_ ## NAME ## _type_node; 2499 2500 C_COMMON_FIXED_TYPES (fract); 2501 C_COMMON_FIXED_TYPES_SAT (fract); 2502 C_COMMON_FIXED_TYPES (accum); 2503 C_COMMON_FIXED_TYPES_SAT (accum); 2504 2505 C_COMMON_FIXED_MODE_TYPES (qq); 2506 C_COMMON_FIXED_MODE_TYPES (hq); 2507 C_COMMON_FIXED_MODE_TYPES (sq); 2508 C_COMMON_FIXED_MODE_TYPES (dq); 2509 C_COMMON_FIXED_MODE_TYPES (tq); 2510 C_COMMON_FIXED_MODE_TYPES_SAT (qq); 2511 C_COMMON_FIXED_MODE_TYPES_SAT (hq); 2512 C_COMMON_FIXED_MODE_TYPES_SAT (sq); 2513 C_COMMON_FIXED_MODE_TYPES_SAT (dq); 2514 C_COMMON_FIXED_MODE_TYPES_SAT (tq); 2515 C_COMMON_FIXED_MODE_TYPES (ha); 2516 C_COMMON_FIXED_MODE_TYPES (sa); 2517 C_COMMON_FIXED_MODE_TYPES (da); 2518 C_COMMON_FIXED_MODE_TYPES (ta); 2519 C_COMMON_FIXED_MODE_TYPES_SAT (ha); 2520 C_COMMON_FIXED_MODE_TYPES_SAT (sa); 2521 C_COMMON_FIXED_MODE_TYPES_SAT (da); 2522 C_COMMON_FIXED_MODE_TYPES_SAT (ta); 2523 2524 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not 2525 the precision; they have precision set to match their range, but 2526 may use a wider mode to match an ABI. If we change modes, we may 2527 wind up with bad conversions. For INTEGER_TYPEs in C, must check 2528 the precision as well, so as to yield correct results for 2529 bit-field types. C++ does not have these separate bit-field 2530 types, and producing a signed or unsigned variant of an 2531 ENUMERAL_TYPE may cause other problems as well. */ 2532 2533 if (!INTEGRAL_TYPE_P (type) 2534 || TYPE_UNSIGNED (type) == unsignedp) 2535 return type; 2536 2537 #define TYPE_OK(node) \ 2538 (TYPE_MODE (type) == TYPE_MODE (node) \ 2539 && TYPE_PRECISION (type) == TYPE_PRECISION (node)) 2540 if (TYPE_OK (signed_char_type_node)) 2541 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2542 if (TYPE_OK (integer_type_node)) 2543 return unsignedp ? unsigned_type_node : integer_type_node; 2544 if (TYPE_OK (short_integer_type_node)) 2545 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2546 if (TYPE_OK (long_integer_type_node)) 2547 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2548 if (TYPE_OK (long_long_integer_type_node)) 2549 return (unsignedp ? long_long_unsigned_type_node 2550 : long_long_integer_type_node); 2551 2552 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2553 if (int_n_enabled_p[i] 2554 && TYPE_MODE (type) == int_n_data[i].m 2555 && TYPE_PRECISION (type) == int_n_data[i].bitsize) 2556 return (unsignedp ? int_n_trees[i].unsigned_type 2557 : int_n_trees[i].signed_type); 2558 2559 #if HOST_BITS_PER_WIDE_INT >= 64 2560 if (TYPE_OK (intTI_type_node)) 2561 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 2562 #endif 2563 if (TYPE_OK (intDI_type_node)) 2564 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 2565 if (TYPE_OK (intSI_type_node)) 2566 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 2567 if (TYPE_OK (intHI_type_node)) 2568 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 2569 if (TYPE_OK (intQI_type_node)) 2570 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 2571 #undef TYPE_OK 2572 2573 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp); 2574 } 2575 2576 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */ 2577 2578 tree 2579 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp) 2580 { 2581 int i; 2582 2583 /* Extended integer types of the same width as a standard type have 2584 lesser rank, so those of the same width as int promote to int or 2585 unsigned int and are valid for printf formats expecting int or 2586 unsigned int. To avoid such special cases, avoid creating 2587 extended integer types for bit-fields if a standard integer type 2588 is available. */ 2589 if (width == TYPE_PRECISION (integer_type_node)) 2590 return unsignedp ? unsigned_type_node : integer_type_node; 2591 if (width == TYPE_PRECISION (signed_char_type_node)) 2592 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 2593 if (width == TYPE_PRECISION (short_integer_type_node)) 2594 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 2595 if (width == TYPE_PRECISION (long_integer_type_node)) 2596 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 2597 if (width == TYPE_PRECISION (long_long_integer_type_node)) 2598 return (unsignedp ? long_long_unsigned_type_node 2599 : long_long_integer_type_node); 2600 for (i = 0; i < NUM_INT_N_ENTS; i ++) 2601 if (int_n_enabled_p[i] 2602 && width == int_n_data[i].bitsize) 2603 return (unsignedp ? int_n_trees[i].unsigned_type 2604 : int_n_trees[i].signed_type); 2605 return build_nonstandard_integer_type (width, unsignedp); 2606 } 2607 2608 /* The C version of the register_builtin_type langhook. */ 2609 2610 void 2611 c_register_builtin_type (tree type, const char* name) 2612 { 2613 tree decl; 2614 2615 decl = build_decl (UNKNOWN_LOCATION, 2616 TYPE_DECL, get_identifier (name), type); 2617 DECL_ARTIFICIAL (decl) = 1; 2618 if (!TYPE_NAME (type)) 2619 TYPE_NAME (type) = decl; 2620 lang_hooks.decls.pushdecl (decl); 2621 2622 registered_builtin_types = tree_cons (0, type, registered_builtin_types); 2623 } 2624 2625 /* Print an error message for invalid operands to arith operation 2626 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. 2627 RICHLOC is a rich location for the message, containing either 2628 three separate locations for each of the operator and operands 2629 2630 lhs op rhs 2631 ~~~ ^~ ~~~ 2632 2633 (C FE), or one location ranging over all over them 2634 2635 lhs op rhs 2636 ~~~~^~~~~~ 2637 2638 (C++ FE). */ 2639 2640 void 2641 binary_op_error (rich_location *richloc, enum tree_code code, 2642 tree type0, tree type1) 2643 { 2644 const char *opname; 2645 2646 switch (code) 2647 { 2648 case PLUS_EXPR: 2649 opname = "+"; break; 2650 case MINUS_EXPR: 2651 opname = "-"; break; 2652 case MULT_EXPR: 2653 opname = "*"; break; 2654 case MAX_EXPR: 2655 opname = "max"; break; 2656 case MIN_EXPR: 2657 opname = "min"; break; 2658 case EQ_EXPR: 2659 opname = "=="; break; 2660 case NE_EXPR: 2661 opname = "!="; break; 2662 case LE_EXPR: 2663 opname = "<="; break; 2664 case GE_EXPR: 2665 opname = ">="; break; 2666 case LT_EXPR: 2667 opname = "<"; break; 2668 case GT_EXPR: 2669 opname = ">"; break; 2670 case LSHIFT_EXPR: 2671 opname = "<<"; break; 2672 case RSHIFT_EXPR: 2673 opname = ">>"; break; 2674 case TRUNC_MOD_EXPR: 2675 case FLOOR_MOD_EXPR: 2676 opname = "%"; break; 2677 case TRUNC_DIV_EXPR: 2678 case FLOOR_DIV_EXPR: 2679 opname = "/"; break; 2680 case BIT_AND_EXPR: 2681 opname = "&"; break; 2682 case BIT_IOR_EXPR: 2683 opname = "|"; break; 2684 case TRUTH_ANDIF_EXPR: 2685 opname = "&&"; break; 2686 case TRUTH_ORIF_EXPR: 2687 opname = "||"; break; 2688 case BIT_XOR_EXPR: 2689 opname = "^"; break; 2690 default: 2691 gcc_unreachable (); 2692 } 2693 error_at (richloc, 2694 "invalid operands to binary %s (have %qT and %qT)", 2695 opname, type0, type1); 2696 } 2697 2698 /* Given an expression as a tree, return its original type. Do this 2699 by stripping any conversion that preserves the sign and precision. */ 2700 static tree 2701 expr_original_type (tree expr) 2702 { 2703 STRIP_SIGN_NOPS (expr); 2704 return TREE_TYPE (expr); 2705 } 2706 2707 /* Subroutine of build_binary_op, used for comparison operations. 2708 See if the operands have both been converted from subword integer types 2709 and, if so, perhaps change them both back to their original type. 2710 This function is also responsible for converting the two operands 2711 to the proper common type for comparison. 2712 2713 The arguments of this function are all pointers to local variables 2714 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, 2715 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. 2716 2717 LOC is the location of the comparison. 2718 2719 If this function returns non-NULL_TREE, it means that the comparison has 2720 a constant value. What this function returns is an expression for 2721 that value. */ 2722 2723 tree 2724 shorten_compare (location_t loc, tree *op0_ptr, tree *op1_ptr, 2725 tree *restype_ptr, enum tree_code *rescode_ptr) 2726 { 2727 tree type; 2728 tree op0 = *op0_ptr; 2729 tree op1 = *op1_ptr; 2730 int unsignedp0, unsignedp1; 2731 int real1, real2; 2732 tree primop0, primop1; 2733 enum tree_code code = *rescode_ptr; 2734 2735 /* Throw away any conversions to wider types 2736 already present in the operands. */ 2737 2738 primop0 = c_common_get_narrower (op0, &unsignedp0); 2739 primop1 = c_common_get_narrower (op1, &unsignedp1); 2740 2741 /* If primopN is first sign-extended from primopN's precision to opN's 2742 precision, then zero-extended from opN's precision to 2743 *restype_ptr precision, shortenings might be invalid. */ 2744 if (TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (TREE_TYPE (op0)) 2745 && TYPE_PRECISION (TREE_TYPE (op0)) < TYPE_PRECISION (*restype_ptr) 2746 && !unsignedp0 2747 && TYPE_UNSIGNED (TREE_TYPE (op0))) 2748 primop0 = op0; 2749 if (TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (TREE_TYPE (op1)) 2750 && TYPE_PRECISION (TREE_TYPE (op1)) < TYPE_PRECISION (*restype_ptr) 2751 && !unsignedp1 2752 && TYPE_UNSIGNED (TREE_TYPE (op1))) 2753 primop1 = op1; 2754 2755 /* Handle the case that OP0 does not *contain* a conversion 2756 but it *requires* conversion to FINAL_TYPE. */ 2757 2758 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) 2759 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 2760 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) 2761 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 2762 2763 /* If one of the operands must be floated, we cannot optimize. */ 2764 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; 2765 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; 2766 2767 /* If first arg is constant, swap the args (changing operation 2768 so value is preserved), for canonicalization. Don't do this if 2769 the second arg is 0. */ 2770 2771 if (TREE_CONSTANT (primop0) 2772 && !integer_zerop (primop1) && !real_zerop (primop1) 2773 && !fixed_zerop (primop1)) 2774 { 2775 std::swap (primop0, primop1); 2776 std::swap (op0, op1); 2777 *op0_ptr = op0; 2778 *op1_ptr = op1; 2779 std::swap (unsignedp0, unsignedp1); 2780 std::swap (real1, real2); 2781 2782 switch (code) 2783 { 2784 case LT_EXPR: 2785 code = GT_EXPR; 2786 break; 2787 case GT_EXPR: 2788 code = LT_EXPR; 2789 break; 2790 case LE_EXPR: 2791 code = GE_EXPR; 2792 break; 2793 case GE_EXPR: 2794 code = LE_EXPR; 2795 break; 2796 default: 2797 break; 2798 } 2799 *rescode_ptr = code; 2800 } 2801 2802 /* If comparing an integer against a constant more bits wide, 2803 maybe we can deduce a value of 1 or 0 independent of the data. 2804 Or else truncate the constant now 2805 rather than extend the variable at run time. 2806 2807 This is only interesting if the constant is the wider arg. 2808 Also, it is not safe if the constant is unsigned and the 2809 variable arg is signed, since in this case the variable 2810 would be sign-extended and then regarded as unsigned. 2811 Our technique fails in this case because the lowest/highest 2812 possible unsigned results don't follow naturally from the 2813 lowest/highest possible values of the variable operand. 2814 For just EQ_EXPR and NE_EXPR there is another technique that 2815 could be used: see if the constant can be faithfully represented 2816 in the other operand's type, by truncating it and reextending it 2817 and see if that preserves the constant's value. */ 2818 2819 if (!real1 && !real2 2820 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE 2821 && TREE_CODE (primop1) == INTEGER_CST 2822 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) 2823 { 2824 int min_gt, max_gt, min_lt, max_lt; 2825 tree maxval, minval; 2826 /* 1 if comparison is nominally unsigned. */ 2827 int unsignedp = TYPE_UNSIGNED (*restype_ptr); 2828 tree val; 2829 2830 type = c_common_signed_or_unsigned_type (unsignedp0, 2831 TREE_TYPE (primop0)); 2832 2833 maxval = TYPE_MAX_VALUE (type); 2834 minval = TYPE_MIN_VALUE (type); 2835 2836 if (unsignedp && !unsignedp0) 2837 *restype_ptr = c_common_signed_type (*restype_ptr); 2838 2839 if (TREE_TYPE (primop1) != *restype_ptr) 2840 { 2841 /* Convert primop1 to target type, but do not introduce 2842 additional overflow. We know primop1 is an int_cst. */ 2843 primop1 = force_fit_type (*restype_ptr, 2844 wi::to_wide 2845 (primop1, 2846 TYPE_PRECISION (*restype_ptr)), 2847 0, TREE_OVERFLOW (primop1)); 2848 } 2849 if (type != *restype_ptr) 2850 { 2851 minval = convert (*restype_ptr, minval); 2852 maxval = convert (*restype_ptr, maxval); 2853 } 2854 2855 min_gt = tree_int_cst_lt (primop1, minval); 2856 max_gt = tree_int_cst_lt (primop1, maxval); 2857 min_lt = tree_int_cst_lt (minval, primop1); 2858 max_lt = tree_int_cst_lt (maxval, primop1); 2859 2860 val = 0; 2861 /* This used to be a switch, but Genix compiler can't handle that. */ 2862 if (code == NE_EXPR) 2863 { 2864 if (max_lt || min_gt) 2865 val = truthvalue_true_node; 2866 } 2867 else if (code == EQ_EXPR) 2868 { 2869 if (max_lt || min_gt) 2870 val = truthvalue_false_node; 2871 } 2872 else if (code == LT_EXPR) 2873 { 2874 if (max_lt) 2875 val = truthvalue_true_node; 2876 if (!min_lt) 2877 val = truthvalue_false_node; 2878 } 2879 else if (code == GT_EXPR) 2880 { 2881 if (min_gt) 2882 val = truthvalue_true_node; 2883 if (!max_gt) 2884 val = truthvalue_false_node; 2885 } 2886 else if (code == LE_EXPR) 2887 { 2888 if (!max_gt) 2889 val = truthvalue_true_node; 2890 if (min_gt) 2891 val = truthvalue_false_node; 2892 } 2893 else if (code == GE_EXPR) 2894 { 2895 if (!min_lt) 2896 val = truthvalue_true_node; 2897 if (max_lt) 2898 val = truthvalue_false_node; 2899 } 2900 2901 /* If primop0 was sign-extended and unsigned comparison specd, 2902 we did a signed comparison above using the signed type bounds. 2903 But the comparison we output must be unsigned. 2904 2905 Also, for inequalities, VAL is no good; but if the signed 2906 comparison had *any* fixed result, it follows that the 2907 unsigned comparison just tests the sign in reverse 2908 (positive values are LE, negative ones GE). 2909 So we can generate an unsigned comparison 2910 against an extreme value of the signed type. */ 2911 2912 if (unsignedp && !unsignedp0) 2913 { 2914 if (val != 0) 2915 switch (code) 2916 { 2917 case LT_EXPR: 2918 case GE_EXPR: 2919 primop1 = TYPE_MIN_VALUE (type); 2920 val = 0; 2921 break; 2922 2923 case LE_EXPR: 2924 case GT_EXPR: 2925 primop1 = TYPE_MAX_VALUE (type); 2926 val = 0; 2927 break; 2928 2929 default: 2930 break; 2931 } 2932 type = c_common_unsigned_type (type); 2933 } 2934 2935 if (TREE_CODE (primop0) != INTEGER_CST 2936 /* Don't warn if it's from a (non-system) macro. */ 2937 && !(from_macro_expansion_at 2938 (expansion_point_location_if_in_system_header 2939 (EXPR_LOCATION (primop0))))) 2940 { 2941 if (val == truthvalue_false_node) 2942 warning_at (loc, OPT_Wtype_limits, 2943 "comparison is always false due to limited range of data type"); 2944 if (val == truthvalue_true_node) 2945 warning_at (loc, OPT_Wtype_limits, 2946 "comparison is always true due to limited range of data type"); 2947 } 2948 2949 if (val != 0) 2950 { 2951 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 2952 if (TREE_SIDE_EFFECTS (primop0)) 2953 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); 2954 return val; 2955 } 2956 2957 /* Value is not predetermined, but do the comparison 2958 in the type of the operand that is not constant. 2959 TYPE is already properly set. */ 2960 } 2961 2962 /* If either arg is decimal float and the other is float, find the 2963 proper common type to use for comparison. */ 2964 else if (real1 && real2 2965 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0))) 2966 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))) 2967 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 2968 2969 /* If either arg is decimal float and the other is float, fail. */ 2970 else if (real1 && real2 2971 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0))) 2972 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1))))) 2973 return NULL_TREE; 2974 2975 else if (real1 && real2 2976 && (TYPE_PRECISION (TREE_TYPE (primop0)) 2977 == TYPE_PRECISION (TREE_TYPE (primop1)))) 2978 type = TREE_TYPE (primop0); 2979 2980 /* If args' natural types are both narrower than nominal type 2981 and both extend in the same manner, compare them 2982 in the type of the wider arg. 2983 Otherwise must actually extend both to the nominal 2984 common type lest different ways of extending 2985 alter the result. 2986 (eg, (short)-1 == (unsigned short)-1 should be 0.) */ 2987 2988 else if (unsignedp0 == unsignedp1 && real1 == real2 2989 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) 2990 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) 2991 { 2992 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 2993 type = c_common_signed_or_unsigned_type (unsignedp0 2994 || TYPE_UNSIGNED (*restype_ptr), 2995 type); 2996 /* Make sure shorter operand is extended the right way 2997 to match the longer operand. */ 2998 primop0 2999 = convert (c_common_signed_or_unsigned_type (unsignedp0, 3000 TREE_TYPE (primop0)), 3001 primop0); 3002 primop1 3003 = convert (c_common_signed_or_unsigned_type (unsignedp1, 3004 TREE_TYPE (primop1)), 3005 primop1); 3006 } 3007 else 3008 { 3009 /* Here we must do the comparison on the nominal type 3010 using the args exactly as we received them. */ 3011 type = *restype_ptr; 3012 primop0 = op0; 3013 primop1 = op1; 3014 3015 if (!real1 && !real2 && integer_zerop (primop1) 3016 && TYPE_UNSIGNED (*restype_ptr)) 3017 { 3018 tree value = NULL_TREE; 3019 /* All unsigned values are >= 0, so we warn. However, 3020 if OP0 is a constant that is >= 0, the signedness of 3021 the comparison isn't an issue, so suppress the 3022 warning. */ 3023 bool warn = 3024 warn_type_limits && !in_system_header_at (loc) 3025 && !(TREE_CODE (primop0) == INTEGER_CST 3026 && !TREE_OVERFLOW (convert (c_common_signed_type (type), 3027 primop0))) 3028 /* Do not warn for enumeration types. */ 3029 && (TREE_CODE (expr_original_type (primop0)) != ENUMERAL_TYPE); 3030 3031 switch (code) 3032 { 3033 case GE_EXPR: 3034 if (warn) 3035 warning_at (loc, OPT_Wtype_limits, 3036 "comparison of unsigned expression >= 0 is always true"); 3037 value = truthvalue_true_node; 3038 break; 3039 3040 case LT_EXPR: 3041 if (warn) 3042 warning_at (loc, OPT_Wtype_limits, 3043 "comparison of unsigned expression < 0 is always false"); 3044 value = truthvalue_false_node; 3045 break; 3046 3047 default: 3048 break; 3049 } 3050 3051 if (value != NULL_TREE) 3052 { 3053 /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 3054 if (TREE_SIDE_EFFECTS (primop0)) 3055 return build2 (COMPOUND_EXPR, TREE_TYPE (value), 3056 primop0, value); 3057 return value; 3058 } 3059 } 3060 } 3061 3062 *op0_ptr = convert (type, primop0); 3063 *op1_ptr = convert (type, primop1); 3064 3065 *restype_ptr = truthvalue_type_node; 3066 3067 return NULL_TREE; 3068 } 3069 3070 /* Return a tree for the sum or difference (RESULTCODE says which) 3071 of pointer PTROP and integer INTOP. */ 3072 3073 tree 3074 pointer_int_sum (location_t loc, enum tree_code resultcode, 3075 tree ptrop, tree intop, bool complain) 3076 { 3077 tree size_exp, ret; 3078 3079 /* The result is a pointer of the same type that is being added. */ 3080 tree result_type = TREE_TYPE (ptrop); 3081 3082 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) 3083 { 3084 if (complain && warn_pointer_arith) 3085 pedwarn (loc, OPT_Wpointer_arith, 3086 "pointer of type %<void *%> used in arithmetic"); 3087 else if (!complain) 3088 return error_mark_node; 3089 size_exp = integer_one_node; 3090 } 3091 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) 3092 { 3093 if (complain && warn_pointer_arith) 3094 pedwarn (loc, OPT_Wpointer_arith, 3095 "pointer to a function used in arithmetic"); 3096 else if (!complain) 3097 return error_mark_node; 3098 size_exp = integer_one_node; 3099 } 3100 else 3101 size_exp = size_in_bytes_loc (loc, TREE_TYPE (result_type)); 3102 3103 /* We are manipulating pointer values, so we don't need to warn 3104 about relying on undefined signed overflow. We disable the 3105 warning here because we use integer types so fold won't know that 3106 they are really pointers. */ 3107 fold_defer_overflow_warnings (); 3108 3109 /* If what we are about to multiply by the size of the elements 3110 contains a constant term, apply distributive law 3111 and multiply that constant term separately. 3112 This helps produce common subexpressions. */ 3113 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR) 3114 && !TREE_CONSTANT (intop) 3115 && TREE_CONSTANT (TREE_OPERAND (intop, 1)) 3116 && TREE_CONSTANT (size_exp) 3117 /* If the constant comes from pointer subtraction, 3118 skip this optimization--it would cause an error. */ 3119 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE 3120 /* If the constant is unsigned, and smaller than the pointer size, 3121 then we must skip this optimization. This is because it could cause 3122 an overflow error if the constant is negative but INTOP is not. */ 3123 && (!TYPE_UNSIGNED (TREE_TYPE (intop)) 3124 || (TYPE_PRECISION (TREE_TYPE (intop)) 3125 == TYPE_PRECISION (TREE_TYPE (ptrop))))) 3126 { 3127 enum tree_code subcode = resultcode; 3128 tree int_type = TREE_TYPE (intop); 3129 if (TREE_CODE (intop) == MINUS_EXPR) 3130 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR); 3131 /* Convert both subexpression types to the type of intop, 3132 because weird cases involving pointer arithmetic 3133 can result in a sum or difference with different type args. */ 3134 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)), 3135 subcode, ptrop, 3136 convert (int_type, TREE_OPERAND (intop, 1)), 3137 true); 3138 intop = convert (int_type, TREE_OPERAND (intop, 0)); 3139 } 3140 3141 /* Convert the integer argument to a type the same size as sizetype 3142 so the multiply won't overflow spuriously. */ 3143 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype) 3144 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype)) 3145 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype), 3146 TYPE_UNSIGNED (sizetype)), intop); 3147 3148 /* Replace the integer argument with a suitable product by the object size. 3149 Do this multiplication as signed, then convert to the appropriate type 3150 for the pointer operation and disregard an overflow that occurred only 3151 because of the sign-extension change in the latter conversion. */ 3152 { 3153 tree t = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (intop), intop, 3154 convert (TREE_TYPE (intop), size_exp)); 3155 intop = convert (sizetype, t); 3156 if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t)) 3157 intop = wide_int_to_tree (TREE_TYPE (intop), wi::to_wide (intop)); 3158 } 3159 3160 /* Create the sum or difference. */ 3161 if (resultcode == MINUS_EXPR) 3162 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop); 3163 3164 ret = fold_build_pointer_plus_loc (loc, ptrop, intop); 3165 3166 fold_undefer_and_ignore_overflow_warnings (); 3167 3168 return ret; 3169 } 3170 3171 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded 3172 and if NON_CONST is known not to be permitted in an evaluated part 3173 of a constant expression. */ 3174 3175 tree 3176 c_wrap_maybe_const (tree expr, bool non_const) 3177 { 3178 bool nowarning = TREE_NO_WARNING (expr); 3179 location_t loc = EXPR_LOCATION (expr); 3180 3181 /* This should never be called for C++. */ 3182 if (c_dialect_cxx ()) 3183 gcc_unreachable (); 3184 3185 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */ 3186 STRIP_TYPE_NOPS (expr); 3187 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr); 3188 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const; 3189 if (nowarning) 3190 TREE_NO_WARNING (expr) = 1; 3191 protected_set_expr_location (expr, loc); 3192 3193 return expr; 3194 } 3195 3196 /* Return whether EXPR is a declaration whose address can never be 3197 NULL. */ 3198 3199 bool 3200 decl_with_nonnull_addr_p (const_tree expr) 3201 { 3202 return (DECL_P (expr) 3203 && (TREE_CODE (expr) == PARM_DECL 3204 || TREE_CODE (expr) == LABEL_DECL 3205 || !DECL_WEAK (expr))); 3206 } 3207 3208 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR, 3209 or for an `if' or `while' statement or ?..: exp. It should already 3210 have been validated to be of suitable type; otherwise, a bad 3211 diagnostic may result. 3212 3213 The EXPR is located at LOCATION. 3214 3215 This preparation consists of taking the ordinary 3216 representation of an expression expr and producing a valid tree 3217 boolean expression describing whether expr is nonzero. We could 3218 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1), 3219 but we optimize comparisons, &&, ||, and !. 3220 3221 The resulting type should always be `truthvalue_type_node'. */ 3222 3223 tree 3224 c_common_truthvalue_conversion (location_t location, tree expr) 3225 { 3226 switch (TREE_CODE (expr)) 3227 { 3228 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR: 3229 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 3230 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR: 3231 case ORDERED_EXPR: case UNORDERED_EXPR: 3232 if (TREE_TYPE (expr) == truthvalue_type_node) 3233 return expr; 3234 expr = build2 (TREE_CODE (expr), truthvalue_type_node, 3235 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1)); 3236 goto ret; 3237 3238 case TRUTH_ANDIF_EXPR: 3239 case TRUTH_ORIF_EXPR: 3240 case TRUTH_AND_EXPR: 3241 case TRUTH_OR_EXPR: 3242 case TRUTH_XOR_EXPR: 3243 if (TREE_TYPE (expr) == truthvalue_type_node) 3244 return expr; 3245 expr = build2 (TREE_CODE (expr), truthvalue_type_node, 3246 c_common_truthvalue_conversion (location, 3247 TREE_OPERAND (expr, 0)), 3248 c_common_truthvalue_conversion (location, 3249 TREE_OPERAND (expr, 1))); 3250 goto ret; 3251 3252 case TRUTH_NOT_EXPR: 3253 if (TREE_TYPE (expr) == truthvalue_type_node) 3254 return expr; 3255 expr = build1 (TREE_CODE (expr), truthvalue_type_node, 3256 c_common_truthvalue_conversion (location, 3257 TREE_OPERAND (expr, 0))); 3258 goto ret; 3259 3260 case ERROR_MARK: 3261 return expr; 3262 3263 case INTEGER_CST: 3264 if (TREE_CODE (TREE_TYPE (expr)) == ENUMERAL_TYPE 3265 && !integer_zerop (expr) 3266 && !integer_onep (expr)) 3267 warning_at (location, OPT_Wint_in_bool_context, 3268 "enum constant in boolean context"); 3269 return integer_zerop (expr) ? truthvalue_false_node 3270 : truthvalue_true_node; 3271 3272 case REAL_CST: 3273 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0) 3274 ? truthvalue_true_node 3275 : truthvalue_false_node; 3276 3277 case FIXED_CST: 3278 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr), 3279 &FCONST0 (TYPE_MODE (TREE_TYPE (expr)))) 3280 ? truthvalue_true_node 3281 : truthvalue_false_node; 3282 3283 case FUNCTION_DECL: 3284 expr = build_unary_op (location, ADDR_EXPR, expr, false); 3285 /* Fall through. */ 3286 3287 case ADDR_EXPR: 3288 { 3289 tree inner = TREE_OPERAND (expr, 0); 3290 if (decl_with_nonnull_addr_p (inner)) 3291 { 3292 /* Common Ada/Pascal programmer's mistake. */ 3293 warning_at (location, 3294 OPT_Waddress, 3295 "the address of %qD will always evaluate as %<true%>", 3296 inner); 3297 return truthvalue_true_node; 3298 } 3299 break; 3300 } 3301 3302 case COMPLEX_EXPR: 3303 expr = build_binary_op (EXPR_LOCATION (expr), 3304 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) 3305 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 3306 c_common_truthvalue_conversion (location, 3307 TREE_OPERAND (expr, 0)), 3308 c_common_truthvalue_conversion (location, 3309 TREE_OPERAND (expr, 1)), 3310 false); 3311 goto ret; 3312 3313 case NEGATE_EXPR: 3314 case ABS_EXPR: 3315 case FLOAT_EXPR: 3316 case EXCESS_PRECISION_EXPR: 3317 /* These don't change whether an object is nonzero or zero. */ 3318 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0)); 3319 3320 case LROTATE_EXPR: 3321 case RROTATE_EXPR: 3322 /* These don't change whether an object is zero or nonzero, but 3323 we can't ignore them if their second arg has side-effects. */ 3324 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 3325 { 3326 expr = build2 (COMPOUND_EXPR, truthvalue_type_node, 3327 TREE_OPERAND (expr, 1), 3328 c_common_truthvalue_conversion 3329 (location, TREE_OPERAND (expr, 0))); 3330 goto ret; 3331 } 3332 else 3333 return c_common_truthvalue_conversion (location, 3334 TREE_OPERAND (expr, 0)); 3335 3336 case MULT_EXPR: 3337 warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context, 3338 "%<*%> in boolean context, suggest %<&&%> instead"); 3339 break; 3340 3341 case LSHIFT_EXPR: 3342 /* We will only warn on signed shifts here, because the majority of 3343 false positive warnings happen in code where unsigned arithmetic 3344 was used in anticipation of a possible overflow. 3345 Furthermore, if we see an unsigned type here we know that the 3346 result of the shift is not subject to integer promotion rules. */ 3347 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE 3348 && !TYPE_UNSIGNED (TREE_TYPE (expr))) 3349 warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context, 3350 "%<<<%> in boolean context, did you mean %<<%> ?"); 3351 break; 3352 3353 case COND_EXPR: 3354 if (warn_int_in_bool_context 3355 && !from_macro_definition_at (EXPR_LOCATION (expr))) 3356 { 3357 tree val1 = fold_for_warn (TREE_OPERAND (expr, 1)); 3358 tree val2 = fold_for_warn (TREE_OPERAND (expr, 2)); 3359 if (TREE_CODE (val1) == INTEGER_CST 3360 && TREE_CODE (val2) == INTEGER_CST 3361 && !integer_zerop (val1) 3362 && !integer_zerop (val2) 3363 && (!integer_onep (val1) 3364 || !integer_onep (val2))) 3365 warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context, 3366 "?: using integer constants in boolean context, " 3367 "the expression will always evaluate to %<true%>"); 3368 else if ((TREE_CODE (val1) == INTEGER_CST 3369 && !integer_zerop (val1) 3370 && !integer_onep (val1)) 3371 || (TREE_CODE (val2) == INTEGER_CST 3372 && !integer_zerop (val2) 3373 && !integer_onep (val2))) 3374 warning_at (EXPR_LOCATION (expr), OPT_Wint_in_bool_context, 3375 "?: using integer constants in boolean context"); 3376 } 3377 /* Distribute the conversion into the arms of a COND_EXPR. */ 3378 if (c_dialect_cxx ()) 3379 /* Avoid premature folding. */ 3380 break; 3381 else 3382 { 3383 int w = warn_int_in_bool_context; 3384 warn_int_in_bool_context = 0; 3385 /* Folding will happen later for C. */ 3386 expr = build3 (COND_EXPR, truthvalue_type_node, 3387 TREE_OPERAND (expr, 0), 3388 c_common_truthvalue_conversion (location, 3389 TREE_OPERAND (expr, 1)), 3390 c_common_truthvalue_conversion (location, 3391 TREE_OPERAND (expr, 2))); 3392 warn_int_in_bool_context = w; 3393 goto ret; 3394 } 3395 3396 CASE_CONVERT: 3397 { 3398 tree totype = TREE_TYPE (expr); 3399 tree fromtype = TREE_TYPE (TREE_OPERAND (expr, 0)); 3400 3401 if (POINTER_TYPE_P (totype) 3402 && !c_inhibit_evaluation_warnings 3403 && TREE_CODE (fromtype) == REFERENCE_TYPE) 3404 { 3405 tree inner = expr; 3406 STRIP_NOPS (inner); 3407 3408 if (DECL_P (inner)) 3409 warning_at (location, 3410 OPT_Waddress, 3411 "the compiler can assume that the address of " 3412 "%qD will always evaluate to %<true%>", 3413 inner); 3414 } 3415 3416 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, 3417 since that affects how `default_conversion' will behave. */ 3418 if (TREE_CODE (totype) == REFERENCE_TYPE 3419 || TREE_CODE (fromtype) == REFERENCE_TYPE) 3420 break; 3421 /* Don't strip a conversion from C++0x scoped enum, since they 3422 don't implicitly convert to other types. */ 3423 if (TREE_CODE (fromtype) == ENUMERAL_TYPE 3424 && ENUM_IS_SCOPED (fromtype)) 3425 break; 3426 /* If this isn't narrowing the argument, we can ignore it. */ 3427 if (TYPE_PRECISION (totype) >= TYPE_PRECISION (fromtype)) 3428 return c_common_truthvalue_conversion (location, 3429 TREE_OPERAND (expr, 0)); 3430 } 3431 break; 3432 3433 case MODIFY_EXPR: 3434 if (!TREE_NO_WARNING (expr) 3435 && warn_parentheses) 3436 { 3437 warning_at (location, OPT_Wparentheses, 3438 "suggest parentheses around assignment used as " 3439 "truth value"); 3440 TREE_NO_WARNING (expr) = 1; 3441 } 3442 break; 3443 3444 default: 3445 break; 3446 } 3447 3448 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE) 3449 { 3450 tree t = save_expr (expr); 3451 expr = (build_binary_op 3452 (EXPR_LOCATION (expr), 3453 (TREE_SIDE_EFFECTS (expr) 3454 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 3455 c_common_truthvalue_conversion 3456 (location, 3457 build_unary_op (location, REALPART_EXPR, t, false)), 3458 c_common_truthvalue_conversion 3459 (location, 3460 build_unary_op (location, IMAGPART_EXPR, t, false)), 3461 false)); 3462 goto ret; 3463 } 3464 3465 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE) 3466 { 3467 tree fixed_zero_node = build_fixed (TREE_TYPE (expr), 3468 FCONST0 (TYPE_MODE 3469 (TREE_TYPE (expr)))); 3470 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, true); 3471 } 3472 else 3473 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, true); 3474 3475 ret: 3476 protected_set_expr_location (expr, location); 3477 return expr; 3478 } 3479 3480 static void def_builtin_1 (enum built_in_function fncode, 3481 const char *name, 3482 enum built_in_class fnclass, 3483 tree fntype, tree libtype, 3484 bool both_p, bool fallback_p, bool nonansi_p, 3485 tree fnattrs, bool implicit_p); 3486 3487 3488 /* Apply the TYPE_QUALS to the new DECL. */ 3489 3490 void 3491 c_apply_type_quals_to_decl (int type_quals, tree decl) 3492 { 3493 tree type = TREE_TYPE (decl); 3494 3495 if (type == error_mark_node) 3496 return; 3497 3498 if ((type_quals & TYPE_QUAL_CONST) 3499 || (type && TREE_CODE (type) == REFERENCE_TYPE)) 3500 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr 3501 constructor can produce constant init, so rely on cp_finish_decl to 3502 clear TREE_READONLY if the variable has non-constant init. */ 3503 TREE_READONLY (decl) = 1; 3504 if (type_quals & TYPE_QUAL_VOLATILE) 3505 { 3506 TREE_SIDE_EFFECTS (decl) = 1; 3507 TREE_THIS_VOLATILE (decl) = 1; 3508 } 3509 if (type_quals & TYPE_QUAL_RESTRICT) 3510 { 3511 while (type && TREE_CODE (type) == ARRAY_TYPE) 3512 /* Allow 'restrict' on arrays of pointers. 3513 FIXME currently we just ignore it. */ 3514 type = TREE_TYPE (type); 3515 if (!type 3516 || !POINTER_TYPE_P (type) 3517 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))) 3518 error ("invalid use of %<restrict%>"); 3519 } 3520 } 3521 3522 /* Return the typed-based alias set for T, which may be an expression 3523 or a type. Return -1 if we don't do anything special. */ 3524 3525 alias_set_type 3526 c_common_get_alias_set (tree t) 3527 { 3528 /* For VLAs, use the alias set of the element type rather than the 3529 default of alias set 0 for types compared structurally. */ 3530 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t)) 3531 { 3532 if (TREE_CODE (t) == ARRAY_TYPE) 3533 return get_alias_set (TREE_TYPE (t)); 3534 return -1; 3535 } 3536 3537 /* That's all the expressions we handle specially. */ 3538 if (!TYPE_P (t)) 3539 return -1; 3540 3541 /* The C standard guarantees that any object may be accessed via an 3542 lvalue that has character type. */ 3543 if (t == char_type_node 3544 || t == signed_char_type_node 3545 || t == unsigned_char_type_node) 3546 return 0; 3547 3548 /* The C standard specifically allows aliasing between signed and 3549 unsigned variants of the same type. We treat the signed 3550 variant as canonical. */ 3551 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t)) 3552 { 3553 tree t1 = c_common_signed_type (t); 3554 3555 /* t1 == t can happen for boolean nodes which are always unsigned. */ 3556 if (t1 != t) 3557 return get_alias_set (t1); 3558 } 3559 3560 return -1; 3561 } 3562 3563 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where 3564 the IS_SIZEOF parameter indicates which operator is being applied. 3565 The COMPLAIN flag controls whether we should diagnose possibly 3566 ill-formed constructs or not. LOC is the location of the SIZEOF or 3567 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for 3568 a type in any context should be returned, rather than the normal 3569 alignment for that type. */ 3570 3571 tree 3572 c_sizeof_or_alignof_type (location_t loc, 3573 tree type, bool is_sizeof, bool min_alignof, 3574 int complain) 3575 { 3576 const char *op_name; 3577 tree value = NULL; 3578 enum tree_code type_code = TREE_CODE (type); 3579 3580 op_name = is_sizeof ? "sizeof" : "__alignof__"; 3581 3582 if (type_code == FUNCTION_TYPE) 3583 { 3584 if (is_sizeof) 3585 { 3586 if (complain && warn_pointer_arith) 3587 pedwarn (loc, OPT_Wpointer_arith, 3588 "invalid application of %<sizeof%> to a function type"); 3589 else if (!complain) 3590 return error_mark_node; 3591 value = size_one_node; 3592 } 3593 else 3594 { 3595 if (complain) 3596 { 3597 if (c_dialect_cxx ()) 3598 pedwarn (loc, OPT_Wpedantic, "ISO C++ does not permit " 3599 "%<alignof%> applied to a function type"); 3600 else 3601 pedwarn (loc, OPT_Wpedantic, "ISO C does not permit " 3602 "%<_Alignof%> applied to a function type"); 3603 } 3604 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); 3605 } 3606 } 3607 else if (type_code == VOID_TYPE || type_code == ERROR_MARK) 3608 { 3609 if (type_code == VOID_TYPE 3610 && complain && warn_pointer_arith) 3611 pedwarn (loc, OPT_Wpointer_arith, 3612 "invalid application of %qs to a void type", op_name); 3613 else if (!complain) 3614 return error_mark_node; 3615 value = size_one_node; 3616 } 3617 else if (!COMPLETE_TYPE_P (type) 3618 && (!c_dialect_cxx () || is_sizeof || type_code != ARRAY_TYPE)) 3619 { 3620 if (complain) 3621 error_at (loc, "invalid application of %qs to incomplete type %qT", 3622 op_name, type); 3623 return error_mark_node; 3624 } 3625 else if (c_dialect_cxx () && type_code == ARRAY_TYPE 3626 && !COMPLETE_TYPE_P (TREE_TYPE (type))) 3627 { 3628 if (complain) 3629 error_at (loc, "invalid application of %qs to array type %qT of " 3630 "incomplete element type", op_name, type); 3631 return error_mark_node; 3632 } 3633 else 3634 { 3635 if (is_sizeof) 3636 /* Convert in case a char is more than one unit. */ 3637 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 3638 size_int (TYPE_PRECISION (char_type_node) 3639 / BITS_PER_UNIT)); 3640 else if (min_alignof) 3641 value = size_int (min_align_of_type (type)); 3642 else 3643 value = size_int (TYPE_ALIGN_UNIT (type)); 3644 } 3645 3646 /* VALUE will have the middle-end integer type sizetype. 3647 However, we should really return a value of type `size_t', 3648 which is just a typedef for an ordinary integer type. */ 3649 value = fold_convert_loc (loc, size_type_node, value); 3650 3651 return value; 3652 } 3653 3654 /* Implement the __alignof keyword: Return the minimum required 3655 alignment of EXPR, measured in bytes. For VAR_DECLs, 3656 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set 3657 from an "aligned" __attribute__ specification). LOC is the 3658 location of the ALIGNOF operator. */ 3659 3660 tree 3661 c_alignof_expr (location_t loc, tree expr) 3662 { 3663 tree t; 3664 3665 if (VAR_OR_FUNCTION_DECL_P (expr)) 3666 t = size_int (DECL_ALIGN_UNIT (expr)); 3667 3668 else if (TREE_CODE (expr) == COMPONENT_REF 3669 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1))) 3670 { 3671 error_at (loc, "%<__alignof%> applied to a bit-field"); 3672 t = size_one_node; 3673 } 3674 else if (TREE_CODE (expr) == COMPONENT_REF 3675 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL) 3676 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1))); 3677 3678 else if (INDIRECT_REF_P (expr)) 3679 { 3680 tree t = TREE_OPERAND (expr, 0); 3681 tree best = t; 3682 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 3683 3684 while (CONVERT_EXPR_P (t) 3685 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) 3686 { 3687 int thisalign; 3688 3689 t = TREE_OPERAND (t, 0); 3690 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); 3691 if (thisalign > bestalign) 3692 best = t, bestalign = thisalign; 3693 } 3694 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best))); 3695 } 3696 else 3697 return c_alignof (loc, TREE_TYPE (expr)); 3698 3699 return fold_convert_loc (loc, size_type_node, t); 3700 } 3701 3702 /* Handle C and C++ default attributes. */ 3703 3704 enum built_in_attribute 3705 { 3706 #define DEF_ATTR_NULL_TREE(ENUM) ENUM, 3707 #define DEF_ATTR_INT(ENUM, VALUE) ENUM, 3708 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM, 3709 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM, 3710 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM, 3711 #include "builtin-attrs.def" 3712 #undef DEF_ATTR_NULL_TREE 3713 #undef DEF_ATTR_INT 3714 #undef DEF_ATTR_STRING 3715 #undef DEF_ATTR_IDENT 3716 #undef DEF_ATTR_TREE_LIST 3717 ATTR_LAST 3718 }; 3719 3720 static GTY(()) tree built_in_attributes[(int) ATTR_LAST]; 3721 3722 static void c_init_attributes (void); 3723 3724 enum c_builtin_type 3725 { 3726 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME, 3727 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME, 3728 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME, 3729 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME, 3730 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 3731 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 3732 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME, 3733 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3734 ARG6) NAME, 3735 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3736 ARG6, ARG7) NAME, 3737 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3738 ARG6, ARG7, ARG8) NAME, 3739 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3740 ARG6, ARG7, ARG8, ARG9) NAME, 3741 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3742 ARG6, ARG7, ARG8, ARG9, ARG10) NAME, 3743 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3744 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME, 3745 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME, 3746 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME, 3747 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME, 3748 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME, 3749 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME, 3750 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 3751 NAME, 3752 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3753 ARG6) NAME, 3754 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3755 ARG6, ARG7) NAME, 3756 #define DEF_POINTER_TYPE(NAME, TYPE) NAME, 3757 #include "builtin-types.def" 3758 #undef DEF_PRIMITIVE_TYPE 3759 #undef DEF_FUNCTION_TYPE_0 3760 #undef DEF_FUNCTION_TYPE_1 3761 #undef DEF_FUNCTION_TYPE_2 3762 #undef DEF_FUNCTION_TYPE_3 3763 #undef DEF_FUNCTION_TYPE_4 3764 #undef DEF_FUNCTION_TYPE_5 3765 #undef DEF_FUNCTION_TYPE_6 3766 #undef DEF_FUNCTION_TYPE_7 3767 #undef DEF_FUNCTION_TYPE_8 3768 #undef DEF_FUNCTION_TYPE_9 3769 #undef DEF_FUNCTION_TYPE_10 3770 #undef DEF_FUNCTION_TYPE_11 3771 #undef DEF_FUNCTION_TYPE_VAR_0 3772 #undef DEF_FUNCTION_TYPE_VAR_1 3773 #undef DEF_FUNCTION_TYPE_VAR_2 3774 #undef DEF_FUNCTION_TYPE_VAR_3 3775 #undef DEF_FUNCTION_TYPE_VAR_4 3776 #undef DEF_FUNCTION_TYPE_VAR_5 3777 #undef DEF_FUNCTION_TYPE_VAR_6 3778 #undef DEF_FUNCTION_TYPE_VAR_7 3779 #undef DEF_POINTER_TYPE 3780 BT_LAST 3781 }; 3782 3783 typedef enum c_builtin_type builtin_type; 3784 3785 /* A temporary array for c_common_nodes_and_builtins. Used in 3786 communication with def_fn_type. */ 3787 static tree builtin_types[(int) BT_LAST + 1]; 3788 3789 /* A helper function for c_common_nodes_and_builtins. Build function type 3790 for DEF with return type RET and N arguments. If VAR is true, then the 3791 function should be variadic after those N arguments. 3792 3793 Takes special care not to ICE if any of the types involved are 3794 error_mark_node, which indicates that said type is not in fact available 3795 (see builtin_type_for_size). In which case the function type as a whole 3796 should be error_mark_node. */ 3797 3798 static void 3799 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...) 3800 { 3801 tree t; 3802 tree *args = XALLOCAVEC (tree, n); 3803 va_list list; 3804 int i; 3805 3806 va_start (list, n); 3807 for (i = 0; i < n; ++i) 3808 { 3809 builtin_type a = (builtin_type) va_arg (list, int); 3810 t = builtin_types[a]; 3811 if (t == error_mark_node) 3812 goto egress; 3813 args[i] = t; 3814 } 3815 3816 t = builtin_types[ret]; 3817 if (t == error_mark_node) 3818 goto egress; 3819 if (var) 3820 t = build_varargs_function_type_array (t, n, args); 3821 else 3822 t = build_function_type_array (t, n, args); 3823 3824 egress: 3825 builtin_types[def] = t; 3826 va_end (list); 3827 } 3828 3829 /* Build builtin functions common to both C and C++ language 3830 frontends. */ 3831 3832 static void 3833 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node) 3834 { 3835 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \ 3836 builtin_types[ENUM] = VALUE; 3837 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \ 3838 def_fn_type (ENUM, RETURN, 0, 0); 3839 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \ 3840 def_fn_type (ENUM, RETURN, 0, 1, ARG1); 3841 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \ 3842 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2); 3843 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 3844 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3); 3845 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 3846 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4); 3847 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 3848 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 3849 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3850 ARG6) \ 3851 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 3852 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3853 ARG6, ARG7) \ 3854 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7); 3855 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3856 ARG6, ARG7, ARG8) \ 3857 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \ 3858 ARG7, ARG8); 3859 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3860 ARG6, ARG7, ARG8, ARG9) \ 3861 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \ 3862 ARG7, ARG8, ARG9); 3863 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3864 ARG6, ARG7, ARG8, ARG9, ARG10) \ 3865 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \ 3866 ARG7, ARG8, ARG9, ARG10); 3867 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3868 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \ 3869 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \ 3870 ARG7, ARG8, ARG9, ARG10, ARG11); 3871 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \ 3872 def_fn_type (ENUM, RETURN, 1, 0); 3873 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \ 3874 def_fn_type (ENUM, RETURN, 1, 1, ARG1); 3875 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \ 3876 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2); 3877 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \ 3878 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3); 3879 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \ 3880 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4); 3881 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \ 3882 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5); 3883 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3884 ARG6) \ 3885 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6); 3886 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \ 3887 ARG6, ARG7) \ 3888 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7); 3889 #define DEF_POINTER_TYPE(ENUM, TYPE) \ 3890 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]); 3891 3892 #include "builtin-types.def" 3893 3894 #undef DEF_PRIMITIVE_TYPE 3895 #undef DEF_FUNCTION_TYPE_0 3896 #undef DEF_FUNCTION_TYPE_1 3897 #undef DEF_FUNCTION_TYPE_2 3898 #undef DEF_FUNCTION_TYPE_3 3899 #undef DEF_FUNCTION_TYPE_4 3900 #undef DEF_FUNCTION_TYPE_5 3901 #undef DEF_FUNCTION_TYPE_6 3902 #undef DEF_FUNCTION_TYPE_7 3903 #undef DEF_FUNCTION_TYPE_8 3904 #undef DEF_FUNCTION_TYPE_9 3905 #undef DEF_FUNCTION_TYPE_10 3906 #undef DEF_FUNCTION_TYPE_11 3907 #undef DEF_FUNCTION_TYPE_VAR_0 3908 #undef DEF_FUNCTION_TYPE_VAR_1 3909 #undef DEF_FUNCTION_TYPE_VAR_2 3910 #undef DEF_FUNCTION_TYPE_VAR_3 3911 #undef DEF_FUNCTION_TYPE_VAR_4 3912 #undef DEF_FUNCTION_TYPE_VAR_5 3913 #undef DEF_FUNCTION_TYPE_VAR_6 3914 #undef DEF_FUNCTION_TYPE_VAR_7 3915 #undef DEF_POINTER_TYPE 3916 builtin_types[(int) BT_LAST] = NULL_TREE; 3917 3918 c_init_attributes (); 3919 3920 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \ 3921 NONANSI_P, ATTRS, IMPLICIT, COND) \ 3922 if (NAME && COND) \ 3923 def_builtin_1 (ENUM, NAME, CLASS, \ 3924 builtin_types[(int) TYPE], \ 3925 builtin_types[(int) LIBTYPE], \ 3926 BOTH_P, FALLBACK_P, NONANSI_P, \ 3927 built_in_attributes[(int) ATTRS], IMPLICIT); 3928 #include "builtins.def" 3929 3930 targetm.init_builtins (); 3931 3932 build_common_builtin_nodes (); 3933 } 3934 3935 /* Like get_identifier, but avoid warnings about null arguments when 3936 the argument may be NULL for targets where GCC lacks stdint.h type 3937 information. */ 3938 3939 static inline tree 3940 c_get_ident (const char *id) 3941 { 3942 return get_identifier (id); 3943 } 3944 3945 /* Build tree nodes and builtin functions common to both C and C++ language 3946 frontends. */ 3947 3948 void 3949 c_common_nodes_and_builtins (void) 3950 { 3951 int char16_type_size; 3952 int char32_type_size; 3953 int wchar_type_size; 3954 tree array_domain_type; 3955 tree va_list_ref_type_node; 3956 tree va_list_arg_type_node; 3957 int i; 3958 3959 build_common_tree_nodes (flag_signed_char); 3960 3961 /* Define `int' and `char' first so that dbx will output them first. */ 3962 record_builtin_type (RID_INT, NULL, integer_type_node); 3963 record_builtin_type (RID_CHAR, "char", char_type_node); 3964 3965 /* `signed' is the same as `int'. FIXME: the declarations of "signed", 3966 "unsigned long", "long long unsigned" and "unsigned short" were in C++ 3967 but not C. Are the conditionals here needed? */ 3968 if (c_dialect_cxx ()) 3969 record_builtin_type (RID_SIGNED, NULL, integer_type_node); 3970 record_builtin_type (RID_LONG, "long int", long_integer_type_node); 3971 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node); 3972 record_builtin_type (RID_MAX, "long unsigned int", 3973 long_unsigned_type_node); 3974 3975 for (i = 0; i < NUM_INT_N_ENTS; i ++) 3976 { 3977 char name[25]; 3978 3979 sprintf (name, "__int%d", int_n_data[i].bitsize); 3980 record_builtin_type ((enum rid)(RID_FIRST_INT_N + i), name, 3981 int_n_trees[i].signed_type); 3982 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize); 3983 record_builtin_type (RID_MAX, name, int_n_trees[i].unsigned_type); 3984 } 3985 3986 if (c_dialect_cxx ()) 3987 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node); 3988 record_builtin_type (RID_MAX, "long long int", 3989 long_long_integer_type_node); 3990 record_builtin_type (RID_MAX, "long long unsigned int", 3991 long_long_unsigned_type_node); 3992 if (c_dialect_cxx ()) 3993 record_builtin_type (RID_MAX, "long long unsigned", 3994 long_long_unsigned_type_node); 3995 record_builtin_type (RID_SHORT, "short int", short_integer_type_node); 3996 record_builtin_type (RID_MAX, "short unsigned int", 3997 short_unsigned_type_node); 3998 if (c_dialect_cxx ()) 3999 record_builtin_type (RID_MAX, "unsigned short", 4000 short_unsigned_type_node); 4001 4002 /* Define both `signed char' and `unsigned char'. */ 4003 record_builtin_type (RID_MAX, "signed char", signed_char_type_node); 4004 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node); 4005 4006 /* These are types that c_common_type_for_size and 4007 c_common_type_for_mode use. */ 4008 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4009 TYPE_DECL, NULL_TREE, 4010 intQI_type_node)); 4011 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4012 TYPE_DECL, NULL_TREE, 4013 intHI_type_node)); 4014 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4015 TYPE_DECL, NULL_TREE, 4016 intSI_type_node)); 4017 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4018 TYPE_DECL, NULL_TREE, 4019 intDI_type_node)); 4020 #if HOST_BITS_PER_WIDE_INT >= 64 4021 /* Note that this is different than the __int128 type that's part of 4022 the generic __intN support. */ 4023 if (targetm.scalar_mode_supported_p (TImode)) 4024 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4025 TYPE_DECL, 4026 get_identifier ("__int128_t"), 4027 intTI_type_node)); 4028 #endif 4029 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4030 TYPE_DECL, NULL_TREE, 4031 unsigned_intQI_type_node)); 4032 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4033 TYPE_DECL, NULL_TREE, 4034 unsigned_intHI_type_node)); 4035 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4036 TYPE_DECL, NULL_TREE, 4037 unsigned_intSI_type_node)); 4038 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4039 TYPE_DECL, NULL_TREE, 4040 unsigned_intDI_type_node)); 4041 #if HOST_BITS_PER_WIDE_INT >= 64 4042 if (targetm.scalar_mode_supported_p (TImode)) 4043 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4044 TYPE_DECL, 4045 get_identifier ("__uint128_t"), 4046 unsigned_intTI_type_node)); 4047 #endif 4048 4049 /* Create the widest literal types. */ 4050 if (targetm.scalar_mode_supported_p (TImode)) 4051 { 4052 widest_integer_literal_type_node = intTI_type_node; 4053 widest_unsigned_literal_type_node = unsigned_intTI_type_node; 4054 } 4055 else 4056 { 4057 widest_integer_literal_type_node = intDI_type_node; 4058 widest_unsigned_literal_type_node = unsigned_intDI_type_node; 4059 } 4060 4061 signed_size_type_node = c_common_signed_type (size_type_node); 4062 4063 pid_type_node = 4064 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE))); 4065 4066 record_builtin_type (RID_FLOAT, NULL, float_type_node); 4067 record_builtin_type (RID_DOUBLE, NULL, double_type_node); 4068 record_builtin_type (RID_MAX, "long double", long_double_type_node); 4069 4070 if (!c_dialect_cxx ()) 4071 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) 4072 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE) 4073 record_builtin_type ((enum rid) (RID_FLOATN_NX_FIRST + i), NULL, 4074 FLOATN_NX_TYPE_NODE (i)); 4075 4076 /* Only supported decimal floating point extension if the target 4077 actually supports underlying modes. */ 4078 if (targetm.scalar_mode_supported_p (SDmode) 4079 && targetm.scalar_mode_supported_p (DDmode) 4080 && targetm.scalar_mode_supported_p (TDmode)) 4081 { 4082 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node); 4083 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node); 4084 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node); 4085 } 4086 4087 if (targetm.fixed_point_supported_p ()) 4088 { 4089 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node); 4090 record_builtin_type (RID_FRACT, NULL, fract_type_node); 4091 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node); 4092 record_builtin_type (RID_MAX, "long long _Fract", 4093 long_long_fract_type_node); 4094 record_builtin_type (RID_MAX, "unsigned short _Fract", 4095 unsigned_short_fract_type_node); 4096 record_builtin_type (RID_MAX, "unsigned _Fract", 4097 unsigned_fract_type_node); 4098 record_builtin_type (RID_MAX, "unsigned long _Fract", 4099 unsigned_long_fract_type_node); 4100 record_builtin_type (RID_MAX, "unsigned long long _Fract", 4101 unsigned_long_long_fract_type_node); 4102 record_builtin_type (RID_MAX, "_Sat short _Fract", 4103 sat_short_fract_type_node); 4104 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node); 4105 record_builtin_type (RID_MAX, "_Sat long _Fract", 4106 sat_long_fract_type_node); 4107 record_builtin_type (RID_MAX, "_Sat long long _Fract", 4108 sat_long_long_fract_type_node); 4109 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract", 4110 sat_unsigned_short_fract_type_node); 4111 record_builtin_type (RID_MAX, "_Sat unsigned _Fract", 4112 sat_unsigned_fract_type_node); 4113 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract", 4114 sat_unsigned_long_fract_type_node); 4115 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract", 4116 sat_unsigned_long_long_fract_type_node); 4117 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node); 4118 record_builtin_type (RID_ACCUM, NULL, accum_type_node); 4119 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node); 4120 record_builtin_type (RID_MAX, "long long _Accum", 4121 long_long_accum_type_node); 4122 record_builtin_type (RID_MAX, "unsigned short _Accum", 4123 unsigned_short_accum_type_node); 4124 record_builtin_type (RID_MAX, "unsigned _Accum", 4125 unsigned_accum_type_node); 4126 record_builtin_type (RID_MAX, "unsigned long _Accum", 4127 unsigned_long_accum_type_node); 4128 record_builtin_type (RID_MAX, "unsigned long long _Accum", 4129 unsigned_long_long_accum_type_node); 4130 record_builtin_type (RID_MAX, "_Sat short _Accum", 4131 sat_short_accum_type_node); 4132 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node); 4133 record_builtin_type (RID_MAX, "_Sat long _Accum", 4134 sat_long_accum_type_node); 4135 record_builtin_type (RID_MAX, "_Sat long long _Accum", 4136 sat_long_long_accum_type_node); 4137 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum", 4138 sat_unsigned_short_accum_type_node); 4139 record_builtin_type (RID_MAX, "_Sat unsigned _Accum", 4140 sat_unsigned_accum_type_node); 4141 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum", 4142 sat_unsigned_long_accum_type_node); 4143 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum", 4144 sat_unsigned_long_long_accum_type_node); 4145 4146 } 4147 4148 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4149 TYPE_DECL, 4150 get_identifier ("complex int"), 4151 complex_integer_type_node)); 4152 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4153 TYPE_DECL, 4154 get_identifier ("complex float"), 4155 complex_float_type_node)); 4156 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION, 4157 TYPE_DECL, 4158 get_identifier ("complex double"), 4159 complex_double_type_node)); 4160 lang_hooks.decls.pushdecl 4161 (build_decl (UNKNOWN_LOCATION, 4162 TYPE_DECL, get_identifier ("complex long double"), 4163 complex_long_double_type_node)); 4164 4165 if (!c_dialect_cxx ()) 4166 for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) 4167 if (COMPLEX_FLOATN_NX_TYPE_NODE (i) != NULL_TREE) 4168 { 4169 char buf[30]; 4170 sprintf (buf, "complex _Float%d%s", floatn_nx_types[i].n, 4171 floatn_nx_types[i].extended ? "x" : ""); 4172 lang_hooks.decls.pushdecl 4173 (build_decl (UNKNOWN_LOCATION, 4174 TYPE_DECL, 4175 get_identifier (buf), 4176 COMPLEX_FLOATN_NX_TYPE_NODE (i))); 4177 } 4178 4179 if (c_dialect_cxx ()) 4180 { 4181 /* For C++, make fileptr_type_node a distinct void * type until 4182 FILE type is defined. Likewise for const struct tm*. */ 4183 for (unsigned i = 0; 4184 i < sizeof (builtin_structptr_types) 4185 / sizeof (builtin_structptr_type); 4186 ++i) 4187 builtin_structptr_types[i].node = 4188 build_variant_type_copy (builtin_structptr_types[i].base); 4189 4190 } 4191 4192 record_builtin_type (RID_VOID, NULL, void_type_node); 4193 4194 /* Set the TYPE_NAME for any variants that were built before 4195 record_builtin_type gave names to the built-in types. */ 4196 { 4197 tree void_name = TYPE_NAME (void_type_node); 4198 TYPE_NAME (void_type_node) = NULL_TREE; 4199 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST)) 4200 = void_name; 4201 TYPE_NAME (void_type_node) = void_name; 4202 } 4203 4204 void_list_node = build_void_list_node (); 4205 4206 /* Make a type to be the domain of a few array types 4207 whose domains don't really matter. 4208 200 is small enough that it always fits in size_t 4209 and large enough that it can hold most function names for the 4210 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */ 4211 array_domain_type = build_index_type (size_int (200)); 4212 4213 /* Make a type for arrays of characters. 4214 With luck nothing will ever really depend on the length of this 4215 array type. */ 4216 char_array_type_node 4217 = build_array_type (char_type_node, array_domain_type); 4218 4219 string_type_node = build_pointer_type (char_type_node); 4220 const_string_type_node 4221 = build_pointer_type (build_qualified_type 4222 (char_type_node, TYPE_QUAL_CONST)); 4223 4224 /* This is special for C++ so functions can be overloaded. */ 4225 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE); 4226 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node)); 4227 wchar_type_size = TYPE_PRECISION (wchar_type_node); 4228 underlying_wchar_type_node = wchar_type_node; 4229 if (c_dialect_cxx ()) 4230 { 4231 if (TYPE_UNSIGNED (wchar_type_node)) 4232 wchar_type_node = make_unsigned_type (wchar_type_size); 4233 else 4234 wchar_type_node = make_signed_type (wchar_type_size); 4235 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node); 4236 } 4237 4238 /* This is for wide string constants. */ 4239 wchar_array_type_node 4240 = build_array_type (wchar_type_node, array_domain_type); 4241 4242 /* Define 'char16_t'. */ 4243 char16_type_node = get_identifier (CHAR16_TYPE); 4244 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node)); 4245 char16_type_size = TYPE_PRECISION (char16_type_node); 4246 if (c_dialect_cxx ()) 4247 { 4248 char16_type_node = make_unsigned_type (char16_type_size); 4249 4250 if (cxx_dialect >= cxx11) 4251 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node); 4252 } 4253 4254 /* This is for UTF-16 string constants. */ 4255 char16_array_type_node 4256 = build_array_type (char16_type_node, array_domain_type); 4257 4258 /* Define 'char32_t'. */ 4259 char32_type_node = get_identifier (CHAR32_TYPE); 4260 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node)); 4261 char32_type_size = TYPE_PRECISION (char32_type_node); 4262 if (c_dialect_cxx ()) 4263 { 4264 char32_type_node = make_unsigned_type (char32_type_size); 4265 4266 if (cxx_dialect >= cxx11) 4267 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node); 4268 } 4269 4270 /* This is for UTF-32 string constants. */ 4271 char32_array_type_node 4272 = build_array_type (char32_type_node, array_domain_type); 4273 4274 wint_type_node = 4275 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE))); 4276 4277 intmax_type_node = 4278 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE))); 4279 uintmax_type_node = 4280 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE))); 4281 4282 if (SIG_ATOMIC_TYPE) 4283 sig_atomic_type_node = 4284 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE))); 4285 if (INT8_TYPE) 4286 int8_type_node = 4287 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE))); 4288 if (INT16_TYPE) 4289 int16_type_node = 4290 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE))); 4291 if (INT32_TYPE) 4292 int32_type_node = 4293 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE))); 4294 if (INT64_TYPE) 4295 int64_type_node = 4296 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE))); 4297 if (UINT8_TYPE) 4298 uint8_type_node = 4299 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE))); 4300 if (UINT16_TYPE) 4301 c_uint16_type_node = uint16_type_node = 4302 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE))); 4303 if (UINT32_TYPE) 4304 c_uint32_type_node = uint32_type_node = 4305 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE))); 4306 if (UINT64_TYPE) 4307 c_uint64_type_node = uint64_type_node = 4308 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE))); 4309 if (INT_LEAST8_TYPE) 4310 int_least8_type_node = 4311 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE))); 4312 if (INT_LEAST16_TYPE) 4313 int_least16_type_node = 4314 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE))); 4315 if (INT_LEAST32_TYPE) 4316 int_least32_type_node = 4317 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE))); 4318 if (INT_LEAST64_TYPE) 4319 int_least64_type_node = 4320 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE))); 4321 if (UINT_LEAST8_TYPE) 4322 uint_least8_type_node = 4323 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE))); 4324 if (UINT_LEAST16_TYPE) 4325 uint_least16_type_node = 4326 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE))); 4327 if (UINT_LEAST32_TYPE) 4328 uint_least32_type_node = 4329 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE))); 4330 if (UINT_LEAST64_TYPE) 4331 uint_least64_type_node = 4332 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE))); 4333 if (INT_FAST8_TYPE) 4334 int_fast8_type_node = 4335 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE))); 4336 if (INT_FAST16_TYPE) 4337 int_fast16_type_node = 4338 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE))); 4339 if (INT_FAST32_TYPE) 4340 int_fast32_type_node = 4341 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE))); 4342 if (INT_FAST64_TYPE) 4343 int_fast64_type_node = 4344 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE))); 4345 if (UINT_FAST8_TYPE) 4346 uint_fast8_type_node = 4347 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE))); 4348 if (UINT_FAST16_TYPE) 4349 uint_fast16_type_node = 4350 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE))); 4351 if (UINT_FAST32_TYPE) 4352 uint_fast32_type_node = 4353 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE))); 4354 if (UINT_FAST64_TYPE) 4355 uint_fast64_type_node = 4356 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE))); 4357 if (INTPTR_TYPE) 4358 intptr_type_node = 4359 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE))); 4360 if (UINTPTR_TYPE) 4361 uintptr_type_node = 4362 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE))); 4363 4364 default_function_type 4365 = build_varargs_function_type_list (integer_type_node, NULL_TREE); 4366 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node); 4367 4368 lang_hooks.decls.pushdecl 4369 (build_decl (UNKNOWN_LOCATION, 4370 TYPE_DECL, get_identifier ("__builtin_va_list"), 4371 va_list_type_node)); 4372 if (targetm.enum_va_list_p) 4373 { 4374 int l; 4375 const char *pname; 4376 tree ptype; 4377 4378 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l) 4379 { 4380 lang_hooks.decls.pushdecl 4381 (build_decl (UNKNOWN_LOCATION, 4382 TYPE_DECL, get_identifier (pname), 4383 ptype)); 4384 4385 } 4386 } 4387 4388 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE) 4389 { 4390 va_list_arg_type_node = va_list_ref_type_node = 4391 build_pointer_type (TREE_TYPE (va_list_type_node)); 4392 } 4393 else 4394 { 4395 va_list_arg_type_node = va_list_type_node; 4396 va_list_ref_type_node = build_reference_type (va_list_type_node); 4397 } 4398 4399 if (!flag_preprocess_only) 4400 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node); 4401 4402 main_identifier_node = get_identifier ("main"); 4403 4404 /* Create the built-in __null node. It is important that this is 4405 not shared. */ 4406 null_node = make_int_cst (1, 1); 4407 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); 4408 4409 /* Since builtin_types isn't gc'ed, don't export these nodes. */ 4410 memset (builtin_types, 0, sizeof (builtin_types)); 4411 } 4412 4413 /* The number of named compound-literals generated thus far. */ 4414 static GTY(()) int compound_literal_number; 4415 4416 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */ 4417 4418 void 4419 set_compound_literal_name (tree decl) 4420 { 4421 char *name; 4422 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal", 4423 compound_literal_number); 4424 compound_literal_number++; 4425 DECL_NAME (decl) = get_identifier (name); 4426 } 4427 4428 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type 4429 TYPE and operand OP. */ 4430 4431 static tree 4432 build_va_arg_1 (location_t loc, tree type, tree op) 4433 { 4434 tree expr = build1 (VA_ARG_EXPR, type, op); 4435 SET_EXPR_LOCATION (expr, loc); 4436 return expr; 4437 } 4438 4439 /* Return a VA_ARG_EXPR corresponding to a source-level expression 4440 va_arg (EXPR, TYPE) at source location LOC. */ 4441 4442 tree 4443 build_va_arg (location_t loc, tree expr, tree type) 4444 { 4445 tree va_type = TREE_TYPE (expr); 4446 tree canon_va_type = (va_type == error_mark_node 4447 ? error_mark_node 4448 : targetm.canonical_va_list_type (va_type)); 4449 4450 if (va_type == error_mark_node 4451 || canon_va_type == NULL_TREE) 4452 { 4453 if (canon_va_type == NULL_TREE) 4454 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>"); 4455 4456 /* Let's handle things neutrallly, if expr: 4457 - has undeclared type, or 4458 - is not an va_list type. */ 4459 return build_va_arg_1 (loc, type, error_mark_node); 4460 } 4461 4462 if (TREE_CODE (canon_va_type) != ARRAY_TYPE) 4463 { 4464 /* Case 1: Not an array type. */ 4465 4466 /* Take the address, to get '&ap'. Note that &ap is not a va_list 4467 type. */ 4468 mark_addressable (expr); 4469 expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (expr)), expr); 4470 4471 return build_va_arg_1 (loc, type, expr); 4472 } 4473 4474 /* Case 2: Array type. 4475 4476 Background: 4477 4478 For contrast, let's start with the simple case (case 1). If 4479 canon_va_type is not an array type, but say a char *, then when 4480 passing-by-value a va_list, the type of the va_list param decl is 4481 the same as for another va_list decl (all ap's are char *): 4482 4483 f2_1 (char * ap) 4484 D.1815 = VA_ARG (&ap, 0B, 1); 4485 return D.1815; 4486 4487 f2 (int i) 4488 char * ap.0; 4489 char * ap; 4490 __builtin_va_start (&ap, 0); 4491 ap.0 = ap; 4492 res = f2_1 (ap.0); 4493 __builtin_va_end (&ap); 4494 D.1812 = res; 4495 return D.1812; 4496 4497 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a 4498 va_list the type of the va_list param decl (case 2b, struct * ap) is not 4499 the same as for another va_list decl (case 2a, struct ap[1]). 4500 4501 f2_1 (struct * ap) 4502 D.1844 = VA_ARG (ap, 0B, 0); 4503 return D.1844; 4504 4505 f2 (int i) 4506 struct ap[1]; 4507 __builtin_va_start (&ap, 0); 4508 res = f2_1 (&ap); 4509 __builtin_va_end (&ap); 4510 D.1841 = res; 4511 return D.1841; 4512 4513 Case 2b is different because: 4514 - on the callee side, the parm decl has declared type va_list, but 4515 grokdeclarator changes the type of the parm decl to a pointer to the 4516 array elem type. 4517 - on the caller side, the pass-by-value uses &ap. 4518 4519 We unify these two cases (case 2a: va_list is array type, 4520 case 2b: va_list is pointer to array elem type), by adding '&' for the 4521 array type case, such that we have a pointer to array elem in both 4522 cases. */ 4523 4524 if (TREE_CODE (va_type) == ARRAY_TYPE) 4525 { 4526 /* Case 2a: va_list is array type. */ 4527 4528 /* Take the address, to get '&ap'. Make sure it's a pointer to array 4529 elem type. */ 4530 mark_addressable (expr); 4531 expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (canon_va_type)), 4532 expr); 4533 4534 /* Verify that &ap is still recognized as having va_list type. */ 4535 tree canon_expr_type 4536 = targetm.canonical_va_list_type (TREE_TYPE (expr)); 4537 gcc_assert (canon_expr_type != NULL_TREE); 4538 } 4539 else 4540 { 4541 /* Case 2b: va_list is pointer to array elem type. */ 4542 gcc_assert (POINTER_TYPE_P (va_type)); 4543 4544 /* Comparison as in std_canonical_va_list_type. */ 4545 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (va_type)) 4546 == TYPE_MAIN_VARIANT (TREE_TYPE (canon_va_type))); 4547 4548 /* Don't take the address. We've already got '&ap'. */ 4549 ; 4550 } 4551 4552 return build_va_arg_1 (loc, type, expr); 4553 } 4554 4555 4556 /* Linked list of disabled built-in functions. */ 4557 4558 struct disabled_builtin 4559 { 4560 const char *name; 4561 struct disabled_builtin *next; 4562 }; 4563 static disabled_builtin *disabled_builtins = NULL; 4564 4565 static bool builtin_function_disabled_p (const char *); 4566 4567 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME 4568 begins with "__builtin_", give an error. */ 4569 4570 void 4571 disable_builtin_function (const char *name) 4572 { 4573 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0) 4574 error ("cannot disable built-in function %qs", name); 4575 else 4576 { 4577 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin); 4578 new_disabled_builtin->name = name; 4579 new_disabled_builtin->next = disabled_builtins; 4580 disabled_builtins = new_disabled_builtin; 4581 } 4582 } 4583 4584 4585 /* Return true if the built-in function NAME has been disabled, false 4586 otherwise. */ 4587 4588 static bool 4589 builtin_function_disabled_p (const char *name) 4590 { 4591 disabled_builtin *p; 4592 for (p = disabled_builtins; p != NULL; p = p->next) 4593 { 4594 if (strcmp (name, p->name) == 0) 4595 return true; 4596 } 4597 return false; 4598 } 4599 4600 4601 /* Worker for DEF_BUILTIN. 4602 Possibly define a builtin function with one or two names. 4603 Does not declare a non-__builtin_ function if flag_no_builtin, or if 4604 nonansi_p and flag_no_nonansi_builtin. */ 4605 4606 static void 4607 def_builtin_1 (enum built_in_function fncode, 4608 const char *name, 4609 enum built_in_class fnclass, 4610 tree fntype, tree libtype, 4611 bool both_p, bool fallback_p, bool nonansi_p, 4612 tree fnattrs, bool implicit_p) 4613 { 4614 tree decl; 4615 const char *libname; 4616 4617 if (fntype == error_mark_node) 4618 return; 4619 4620 gcc_assert ((!both_p && !fallback_p) 4621 || !strncmp (name, "__builtin_", 4622 strlen ("__builtin_"))); 4623 4624 libname = name + strlen ("__builtin_"); 4625 decl = add_builtin_function (name, fntype, fncode, fnclass, 4626 (fallback_p ? libname : NULL), 4627 fnattrs); 4628 4629 set_builtin_decl (fncode, decl, implicit_p); 4630 4631 if (both_p 4632 && !flag_no_builtin && !builtin_function_disabled_p (libname) 4633 && !(nonansi_p && flag_no_nonansi_builtin)) 4634 add_builtin_function (libname, libtype, fncode, fnclass, 4635 NULL, fnattrs); 4636 } 4637 4638 /* Nonzero if the type T promotes to int. This is (nearly) the 4639 integral promotions defined in ISO C99 6.3.1.1/2. */ 4640 4641 bool 4642 c_promoting_integer_type_p (const_tree t) 4643 { 4644 switch (TREE_CODE (t)) 4645 { 4646 case INTEGER_TYPE: 4647 return (TYPE_MAIN_VARIANT (t) == char_type_node 4648 || TYPE_MAIN_VARIANT (t) == signed_char_type_node 4649 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node 4650 || TYPE_MAIN_VARIANT (t) == short_integer_type_node 4651 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node 4652 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node)); 4653 4654 case ENUMERAL_TYPE: 4655 /* ??? Technically all enumerations not larger than an int 4656 promote to an int. But this is used along code paths 4657 that only want to notice a size change. */ 4658 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node); 4659 4660 case BOOLEAN_TYPE: 4661 return true; 4662 4663 default: 4664 return false; 4665 } 4666 } 4667 4668 /* Return 1 if PARMS specifies a fixed number of parameters 4669 and none of their types is affected by default promotions. */ 4670 4671 bool 4672 self_promoting_args_p (const_tree parms) 4673 { 4674 const_tree t; 4675 for (t = parms; t; t = TREE_CHAIN (t)) 4676 { 4677 tree type = TREE_VALUE (t); 4678 4679 if (type == error_mark_node) 4680 continue; 4681 4682 if (TREE_CHAIN (t) == NULL_TREE && type != void_type_node) 4683 return false; 4684 4685 if (type == NULL_TREE) 4686 return false; 4687 4688 if (TYPE_MAIN_VARIANT (type) == float_type_node) 4689 return false; 4690 4691 if (c_promoting_integer_type_p (type)) 4692 return false; 4693 } 4694 return true; 4695 } 4696 4697 /* Recursively remove any '*' or '&' operator from TYPE. */ 4698 tree 4699 strip_pointer_operator (tree t) 4700 { 4701 while (POINTER_TYPE_P (t)) 4702 t = TREE_TYPE (t); 4703 return t; 4704 } 4705 4706 /* Recursively remove pointer or array type from TYPE. */ 4707 tree 4708 strip_pointer_or_array_types (tree t) 4709 { 4710 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t)) 4711 t = TREE_TYPE (t); 4712 return t; 4713 } 4714 4715 /* Used to compare case labels. K1 and K2 are actually tree nodes 4716 representing case labels, or NULL_TREE for a `default' label. 4717 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after 4718 K2, and 0 if K1 and K2 are equal. */ 4719 4720 int 4721 case_compare (splay_tree_key k1, splay_tree_key k2) 4722 { 4723 /* Consider a NULL key (such as arises with a `default' label) to be 4724 smaller than anything else. */ 4725 if (!k1) 4726 return k2 ? -1 : 0; 4727 else if (!k2) 4728 return k1 ? 1 : 0; 4729 4730 return tree_int_cst_compare ((tree) k1, (tree) k2); 4731 } 4732 4733 /* Process a case label, located at LOC, for the range LOW_VALUE 4734 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE 4735 then this case label is actually a `default' label. If only 4736 HIGH_VALUE is NULL_TREE, then case label was declared using the 4737 usual C/C++ syntax, rather than the GNU case range extension. 4738 CASES is a tree containing all the case ranges processed so far; 4739 COND is the condition for the switch-statement itself. 4740 OUTSIDE_RANGE_P says whether there was a case value that doesn't 4741 fit into the range of the ORIG_TYPE. Returns the CASE_LABEL_EXPR 4742 created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */ 4743 4744 tree 4745 c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type, 4746 tree low_value, tree high_value, bool *outside_range_p) 4747 { 4748 tree type; 4749 tree label; 4750 tree case_label; 4751 splay_tree_node node; 4752 4753 /* Create the LABEL_DECL itself. */ 4754 label = create_artificial_label (loc); 4755 4756 /* If there was an error processing the switch condition, bail now 4757 before we get more confused. */ 4758 if (!cond || cond == error_mark_node) 4759 goto error_out; 4760 4761 if ((low_value && TREE_TYPE (low_value) 4762 && POINTER_TYPE_P (TREE_TYPE (low_value))) 4763 || (high_value && TREE_TYPE (high_value) 4764 && POINTER_TYPE_P (TREE_TYPE (high_value)))) 4765 { 4766 error_at (loc, "pointers are not permitted as case values"); 4767 goto error_out; 4768 } 4769 4770 /* Case ranges are a GNU extension. */ 4771 if (high_value) 4772 pedwarn (loc, OPT_Wpedantic, 4773 "range expressions in switch statements are non-standard"); 4774 4775 type = TREE_TYPE (cond); 4776 if (low_value) 4777 { 4778 low_value = check_case_value (loc, low_value); 4779 low_value = convert_and_check (loc, type, low_value); 4780 if (low_value == error_mark_node) 4781 goto error_out; 4782 } 4783 if (high_value) 4784 { 4785 high_value = check_case_value (loc, high_value); 4786 high_value = convert_and_check (loc, type, high_value); 4787 if (high_value == error_mark_node) 4788 goto error_out; 4789 } 4790 4791 if (low_value && high_value) 4792 { 4793 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't 4794 really a case range, even though it was written that way. 4795 Remove the HIGH_VALUE to simplify later processing. */ 4796 if (tree_int_cst_equal (low_value, high_value)) 4797 high_value = NULL_TREE; 4798 else if (!tree_int_cst_lt (low_value, high_value)) 4799 warning_at (loc, 0, "empty range specified"); 4800 } 4801 4802 /* See if the case is in range of the type of the original testing 4803 expression. If both low_value and high_value are out of range, 4804 don't insert the case label and return NULL_TREE. */ 4805 if (low_value 4806 && !check_case_bounds (loc, type, orig_type, 4807 &low_value, high_value ? &high_value : NULL, 4808 outside_range_p)) 4809 return NULL_TREE; 4810 4811 /* Look up the LOW_VALUE in the table of case labels we already 4812 have. */ 4813 node = splay_tree_lookup (cases, (splay_tree_key) low_value); 4814 /* If there was not an exact match, check for overlapping ranges. 4815 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE; 4816 that's a `default' label and the only overlap is an exact match. */ 4817 if (!node && (low_value || high_value)) 4818 { 4819 splay_tree_node low_bound; 4820 splay_tree_node high_bound; 4821 4822 /* Even though there wasn't an exact match, there might be an 4823 overlap between this case range and another case range. 4824 Since we've (inductively) not allowed any overlapping case 4825 ranges, we simply need to find the greatest low case label 4826 that is smaller that LOW_VALUE, and the smallest low case 4827 label that is greater than LOW_VALUE. If there is an overlap 4828 it will occur in one of these two ranges. */ 4829 low_bound = splay_tree_predecessor (cases, 4830 (splay_tree_key) low_value); 4831 high_bound = splay_tree_successor (cases, 4832 (splay_tree_key) low_value); 4833 4834 /* Check to see if the LOW_BOUND overlaps. It is smaller than 4835 the LOW_VALUE, so there is no need to check unless the 4836 LOW_BOUND is in fact itself a case range. */ 4837 if (low_bound 4838 && CASE_HIGH ((tree) low_bound->value) 4839 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value), 4840 low_value) >= 0) 4841 node = low_bound; 4842 /* Check to see if the HIGH_BOUND overlaps. The low end of that 4843 range is bigger than the low end of the current range, so we 4844 are only interested if the current range is a real range, and 4845 not an ordinary case label. */ 4846 else if (high_bound 4847 && high_value 4848 && (tree_int_cst_compare ((tree) high_bound->key, 4849 high_value) 4850 <= 0)) 4851 node = high_bound; 4852 } 4853 /* If there was an overlap, issue an error. */ 4854 if (node) 4855 { 4856 tree duplicate = CASE_LABEL ((tree) node->value); 4857 4858 if (high_value) 4859 { 4860 error_at (loc, "duplicate (or overlapping) case value"); 4861 inform (DECL_SOURCE_LOCATION (duplicate), 4862 "this is the first entry overlapping that value"); 4863 } 4864 else if (low_value) 4865 { 4866 error_at (loc, "duplicate case value") ; 4867 inform (DECL_SOURCE_LOCATION (duplicate), "previously used here"); 4868 } 4869 else 4870 { 4871 error_at (loc, "multiple default labels in one switch"); 4872 inform (DECL_SOURCE_LOCATION (duplicate), 4873 "this is the first default label"); 4874 } 4875 goto error_out; 4876 } 4877 4878 /* Add a CASE_LABEL to the statement-tree. */ 4879 case_label = add_stmt (build_case_label (low_value, high_value, label)); 4880 /* Register this case label in the splay tree. */ 4881 splay_tree_insert (cases, 4882 (splay_tree_key) low_value, 4883 (splay_tree_value) case_label); 4884 4885 return case_label; 4886 4887 error_out: 4888 /* Add a label so that the back-end doesn't think that the beginning of 4889 the switch is unreachable. Note that we do not add a case label, as 4890 that just leads to duplicates and thence to failure later on. */ 4891 if (!cases->root) 4892 { 4893 tree t = create_artificial_label (loc); 4894 add_stmt (build_stmt (loc, LABEL_EXPR, t)); 4895 } 4896 return error_mark_node; 4897 } 4898 4899 /* Subroutine of c_switch_covers_all_cases_p, called via 4900 splay_tree_foreach. Return 1 if it doesn't cover all the cases. 4901 ARGS[0] is initially NULL and after the first iteration is the 4902 so far highest case label. ARGS[1] is the minimum of SWITCH_COND's 4903 type. */ 4904 4905 static int 4906 c_switch_covers_all_cases_p_1 (splay_tree_node node, void *data) 4907 { 4908 tree label = (tree) node->value; 4909 tree *args = (tree *) data; 4910 4911 /* If there is a default case, we shouldn't have called this. */ 4912 gcc_assert (CASE_LOW (label)); 4913 4914 if (args[0] == NULL_TREE) 4915 { 4916 if (wi::to_widest (args[1]) < wi::to_widest (CASE_LOW (label))) 4917 return 1; 4918 } 4919 else if (wi::add (wi::to_widest (args[0]), 1) 4920 != wi::to_widest (CASE_LOW (label))) 4921 return 1; 4922 if (CASE_HIGH (label)) 4923 args[0] = CASE_HIGH (label); 4924 else 4925 args[0] = CASE_LOW (label); 4926 return 0; 4927 } 4928 4929 /* Return true if switch with CASES and switch condition with type 4930 covers all possible values in the case labels. */ 4931 4932 bool 4933 c_switch_covers_all_cases_p (splay_tree cases, tree type) 4934 { 4935 /* If there is default:, this is always the case. */ 4936 splay_tree_node default_node 4937 = splay_tree_lookup (cases, (splay_tree_key) NULL); 4938 if (default_node) 4939 return true; 4940 4941 if (!INTEGRAL_TYPE_P (type)) 4942 return false; 4943 4944 tree args[2] = { NULL_TREE, TYPE_MIN_VALUE (type) }; 4945 if (splay_tree_foreach (cases, c_switch_covers_all_cases_p_1, args)) 4946 return false; 4947 4948 /* If there are no cases at all, or if the highest case label 4949 is smaller than TYPE_MAX_VALUE, return false. */ 4950 if (args[0] == NULL_TREE 4951 || wi::to_widest (args[0]) < wi::to_widest (TYPE_MAX_VALUE (type))) 4952 return false; 4953 4954 return true; 4955 } 4956 4957 /* Finish an expression taking the address of LABEL (an 4958 IDENTIFIER_NODE). Returns an expression for the address. 4959 4960 LOC is the location for the expression returned. */ 4961 4962 tree 4963 finish_label_address_expr (tree label, location_t loc) 4964 { 4965 tree result; 4966 4967 pedwarn (input_location, OPT_Wpedantic, "taking the address of a label is non-standard"); 4968 4969 if (label == error_mark_node) 4970 return error_mark_node; 4971 4972 label = lookup_label (label); 4973 if (label == NULL_TREE) 4974 result = null_pointer_node; 4975 else 4976 { 4977 TREE_USED (label) = 1; 4978 result = build1 (ADDR_EXPR, ptr_type_node, label); 4979 /* The current function is not necessarily uninlinable. 4980 Computed gotos are incompatible with inlining, but the value 4981 here could be used only in a diagnostic, for example. */ 4982 protected_set_expr_location (result, loc); 4983 } 4984 4985 return result; 4986 } 4987 4988 4989 /* Given a boolean expression ARG, return a tree representing an increment 4990 or decrement (as indicated by CODE) of ARG. The front end must check for 4991 invalid cases (e.g., decrement in C++). */ 4992 tree 4993 boolean_increment (enum tree_code code, tree arg) 4994 { 4995 tree val; 4996 tree true_res = build_int_cst (TREE_TYPE (arg), 1); 4997 4998 arg = stabilize_reference (arg); 4999 switch (code) 5000 { 5001 case PREINCREMENT_EXPR: 5002 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 5003 break; 5004 case POSTINCREMENT_EXPR: 5005 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res); 5006 arg = save_expr (arg); 5007 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 5008 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 5009 break; 5010 case PREDECREMENT_EXPR: 5011 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 5012 invert_truthvalue_loc (input_location, arg)); 5013 break; 5014 case POSTDECREMENT_EXPR: 5015 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, 5016 invert_truthvalue_loc (input_location, arg)); 5017 arg = save_expr (arg); 5018 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); 5019 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); 5020 break; 5021 default: 5022 gcc_unreachable (); 5023 } 5024 TREE_SIDE_EFFECTS (val) = 1; 5025 return val; 5026 } 5027 5028 /* Built-in macros for stddef.h and stdint.h, that require macros 5029 defined in this file. */ 5030 void 5031 c_stddef_cpp_builtins(void) 5032 { 5033 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0); 5034 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0); 5035 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0); 5036 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0); 5037 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0); 5038 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0); 5039 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0); 5040 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0); 5041 if (SIG_ATOMIC_TYPE) 5042 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0); 5043 if (INT8_TYPE) 5044 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0); 5045 if (INT16_TYPE) 5046 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0); 5047 if (INT32_TYPE) 5048 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0); 5049 if (INT64_TYPE) 5050 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0); 5051 if (UINT8_TYPE) 5052 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0); 5053 if (UINT16_TYPE) 5054 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0); 5055 if (UINT32_TYPE) 5056 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0); 5057 if (UINT64_TYPE) 5058 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0); 5059 if (INT_LEAST8_TYPE) 5060 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0); 5061 if (INT_LEAST16_TYPE) 5062 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0); 5063 if (INT_LEAST32_TYPE) 5064 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0); 5065 if (INT_LEAST64_TYPE) 5066 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0); 5067 if (UINT_LEAST8_TYPE) 5068 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0); 5069 if (UINT_LEAST16_TYPE) 5070 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0); 5071 if (UINT_LEAST32_TYPE) 5072 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0); 5073 if (UINT_LEAST64_TYPE) 5074 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0); 5075 if (INT_FAST8_TYPE) 5076 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0); 5077 if (INT_FAST16_TYPE) 5078 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0); 5079 if (INT_FAST32_TYPE) 5080 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0); 5081 if (INT_FAST64_TYPE) 5082 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0); 5083 if (UINT_FAST8_TYPE) 5084 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0); 5085 if (UINT_FAST16_TYPE) 5086 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0); 5087 if (UINT_FAST32_TYPE) 5088 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0); 5089 if (UINT_FAST64_TYPE) 5090 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0); 5091 if (INTPTR_TYPE) 5092 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0); 5093 if (UINTPTR_TYPE) 5094 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0); 5095 } 5096 5097 static void 5098 c_init_attributes (void) 5099 { 5100 /* Fill in the built_in_attributes array. */ 5101 #define DEF_ATTR_NULL_TREE(ENUM) \ 5102 built_in_attributes[(int) ENUM] = NULL_TREE; 5103 #define DEF_ATTR_INT(ENUM, VALUE) \ 5104 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE); 5105 #define DEF_ATTR_STRING(ENUM, VALUE) \ 5106 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE); 5107 #define DEF_ATTR_IDENT(ENUM, STRING) \ 5108 built_in_attributes[(int) ENUM] = get_identifier (STRING); 5109 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \ 5110 built_in_attributes[(int) ENUM] \ 5111 = tree_cons (built_in_attributes[(int) PURPOSE], \ 5112 built_in_attributes[(int) VALUE], \ 5113 built_in_attributes[(int) CHAIN]); 5114 #include "builtin-attrs.def" 5115 #undef DEF_ATTR_NULL_TREE 5116 #undef DEF_ATTR_INT 5117 #undef DEF_ATTR_IDENT 5118 #undef DEF_ATTR_TREE_LIST 5119 } 5120 5121 /* Check whether ALIGN is a valid user-specified alignment. If so, 5122 return its base-2 log; if not, output an error and return -1. If 5123 ALLOW_ZERO then 0 is valid and should result in a return of -1 with 5124 no error. */ 5125 int 5126 check_user_alignment (const_tree align, bool allow_zero) 5127 { 5128 int i; 5129 5130 if (error_operand_p (align)) 5131 return -1; 5132 if (TREE_CODE (align) != INTEGER_CST 5133 || !INTEGRAL_TYPE_P (TREE_TYPE (align))) 5134 { 5135 error ("requested alignment is not an integer constant"); 5136 return -1; 5137 } 5138 else if (allow_zero && integer_zerop (align)) 5139 return -1; 5140 else if (tree_int_cst_sgn (align) == -1 5141 || (i = tree_log2 (align)) == -1) 5142 { 5143 error ("requested alignment is not a positive power of 2"); 5144 return -1; 5145 } 5146 else if (i >= HOST_BITS_PER_INT - LOG2_BITS_PER_UNIT) 5147 { 5148 error ("requested alignment is too large"); 5149 return -1; 5150 } 5151 return i; 5152 } 5153 5154 /* Determine the ELF symbol visibility for DECL, which is either a 5155 variable or a function. It is an error to use this function if a 5156 definition of DECL is not available in this translation unit. 5157 Returns true if the final visibility has been determined by this 5158 function; false if the caller is free to make additional 5159 modifications. */ 5160 5161 bool 5162 c_determine_visibility (tree decl) 5163 { 5164 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 5165 5166 /* If the user explicitly specified the visibility with an 5167 attribute, honor that. DECL_VISIBILITY will have been set during 5168 the processing of the attribute. We check for an explicit 5169 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED, 5170 to distinguish the use of an attribute from the use of a "#pragma 5171 GCC visibility push(...)"; in the latter case we still want other 5172 considerations to be able to overrule the #pragma. */ 5173 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)) 5174 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES 5175 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)) 5176 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))))) 5177 return true; 5178 5179 /* Set default visibility to whatever the user supplied with 5180 visibility_specified depending on #pragma GCC visibility. */ 5181 if (!DECL_VISIBILITY_SPECIFIED (decl)) 5182 { 5183 if (visibility_options.inpragma 5184 || DECL_VISIBILITY (decl) != default_visibility) 5185 { 5186 DECL_VISIBILITY (decl) = default_visibility; 5187 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma; 5188 /* If visibility changed and DECL already has DECL_RTL, ensure 5189 symbol flags are updated. */ 5190 if (((VAR_P (decl) && TREE_STATIC (decl)) 5191 || TREE_CODE (decl) == FUNCTION_DECL) 5192 && DECL_RTL_SET_P (decl)) 5193 make_decl_rtl (decl); 5194 } 5195 } 5196 return false; 5197 } 5198 5199 /* Data to communicate through check_function_arguments_recurse between 5200 check_function_nonnull and check_nonnull_arg. */ 5201 5202 struct nonnull_arg_ctx 5203 { 5204 location_t loc; 5205 bool warned_p; 5206 }; 5207 5208 /* Check the argument list of a function call for null in argument slots 5209 that are marked as requiring a non-null pointer argument. The NARGS 5210 arguments are passed in the array ARGARRAY. Return true if we have 5211 warned. */ 5212 5213 static bool 5214 check_function_nonnull (location_t loc, tree attrs, int nargs, tree *argarray) 5215 { 5216 tree a; 5217 int i; 5218 5219 attrs = lookup_attribute ("nonnull", attrs); 5220 if (attrs == NULL_TREE) 5221 return false; 5222 5223 a = attrs; 5224 /* See if any of the nonnull attributes has no arguments. If so, 5225 then every pointer argument is checked (in which case the check 5226 for pointer type is done in check_nonnull_arg). */ 5227 if (TREE_VALUE (a) != NULL_TREE) 5228 do 5229 a = lookup_attribute ("nonnull", TREE_CHAIN (a)); 5230 while (a != NULL_TREE && TREE_VALUE (a) != NULL_TREE); 5231 5232 struct nonnull_arg_ctx ctx = { loc, false }; 5233 if (a != NULL_TREE) 5234 for (i = 0; i < nargs; i++) 5235 check_function_arguments_recurse (check_nonnull_arg, &ctx, argarray[i], 5236 i + 1); 5237 else 5238 { 5239 /* Walk the argument list. If we encounter an argument number we 5240 should check for non-null, do it. */ 5241 for (i = 0; i < nargs; i++) 5242 { 5243 for (a = attrs; ; a = TREE_CHAIN (a)) 5244 { 5245 a = lookup_attribute ("nonnull", a); 5246 if (a == NULL_TREE || nonnull_check_p (TREE_VALUE (a), i + 1)) 5247 break; 5248 } 5249 5250 if (a != NULL_TREE) 5251 check_function_arguments_recurse (check_nonnull_arg, &ctx, 5252 argarray[i], i + 1); 5253 } 5254 } 5255 return ctx.warned_p; 5256 } 5257 5258 /* Check that the Nth argument of a function call (counting backwards 5259 from the end) is a (pointer)0. The NARGS arguments are passed in the 5260 array ARGARRAY. */ 5261 5262 static void 5263 check_function_sentinel (const_tree fntype, int nargs, tree *argarray) 5264 { 5265 tree attr = lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype)); 5266 5267 if (attr) 5268 { 5269 int len = 0; 5270 int pos = 0; 5271 tree sentinel; 5272 function_args_iterator iter; 5273 tree t; 5274 5275 /* Skip over the named arguments. */ 5276 FOREACH_FUNCTION_ARGS (fntype, t, iter) 5277 { 5278 if (len == nargs) 5279 break; 5280 len++; 5281 } 5282 5283 if (TREE_VALUE (attr)) 5284 { 5285 tree p = TREE_VALUE (TREE_VALUE (attr)); 5286 pos = TREE_INT_CST_LOW (p); 5287 } 5288 5289 /* The sentinel must be one of the varargs, i.e. 5290 in position >= the number of fixed arguments. */ 5291 if ((nargs - 1 - pos) < len) 5292 { 5293 warning (OPT_Wformat_, 5294 "not enough variable arguments to fit a sentinel"); 5295 return; 5296 } 5297 5298 /* Validate the sentinel. */ 5299 sentinel = argarray[nargs - 1 - pos]; 5300 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel)) 5301 || !integer_zerop (sentinel)) 5302 /* Although __null (in C++) is only an integer we allow it 5303 nevertheless, as we are guaranteed that it's exactly 5304 as wide as a pointer, and we don't want to force 5305 users to cast the NULL they have written there. 5306 We warn with -Wstrict-null-sentinel, though. */ 5307 && (warn_strict_null_sentinel || null_node != sentinel)) 5308 warning (OPT_Wformat_, "missing sentinel in function call"); 5309 } 5310 } 5311 5312 /* Check that the same argument isn't passed to two or more 5313 restrict-qualified formal and issue a -Wrestrict warning 5314 if it is. Return true if a warning has been issued. */ 5315 5316 static bool 5317 check_function_restrict (const_tree fndecl, const_tree fntype, 5318 int nargs, tree *argarray) 5319 { 5320 int i; 5321 tree parms = TYPE_ARG_TYPES (fntype); 5322 5323 if (fndecl 5324 && TREE_CODE (fndecl) == FUNCTION_DECL) 5325 { 5326 /* Avoid diagnosing calls built-ins with a zero size/bound 5327 here. They are checked in more detail elsewhere. */ 5328 if (DECL_BUILT_IN (fndecl) 5329 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL 5330 && nargs == 3 5331 && TREE_CODE (argarray[2]) == INTEGER_CST 5332 && integer_zerop (argarray[2])) 5333 return false; 5334 5335 if (DECL_ARGUMENTS (fndecl)) 5336 parms = DECL_ARGUMENTS (fndecl); 5337 } 5338 5339 for (i = 0; i < nargs; i++) 5340 TREE_VISITED (argarray[i]) = 0; 5341 5342 bool warned = false; 5343 5344 for (i = 0; i < nargs && parms && parms != void_list_node; i++) 5345 { 5346 tree type; 5347 if (TREE_CODE (parms) == PARM_DECL) 5348 { 5349 type = TREE_TYPE (parms); 5350 parms = DECL_CHAIN (parms); 5351 } 5352 else 5353 { 5354 type = TREE_VALUE (parms); 5355 parms = TREE_CHAIN (parms); 5356 } 5357 if (POINTER_TYPE_P (type) 5358 && TYPE_RESTRICT (type) 5359 && !TYPE_READONLY (TREE_TYPE (type))) 5360 warned |= warn_for_restrict (i, argarray, nargs); 5361 } 5362 5363 for (i = 0; i < nargs; i++) 5364 TREE_VISITED (argarray[i]) = 0; 5365 5366 return warned; 5367 } 5368 5369 /* Helper for check_function_nonnull; given a list of operands which 5370 must be non-null in ARGS, determine if operand PARAM_NUM should be 5371 checked. */ 5372 5373 static bool 5374 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num) 5375 { 5376 unsigned HOST_WIDE_INT arg_num = 0; 5377 5378 for (; args; args = TREE_CHAIN (args)) 5379 { 5380 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num); 5381 5382 gcc_assert (found); 5383 5384 if (arg_num == param_num) 5385 return true; 5386 } 5387 return false; 5388 } 5389 5390 /* Check that the function argument PARAM (which is operand number 5391 PARAM_NUM) is non-null. This is called by check_function_nonnull 5392 via check_function_arguments_recurse. */ 5393 5394 static void 5395 check_nonnull_arg (void *ctx, tree param, unsigned HOST_WIDE_INT param_num) 5396 { 5397 struct nonnull_arg_ctx *pctx = (struct nonnull_arg_ctx *) ctx; 5398 5399 /* Just skip checking the argument if it's not a pointer. This can 5400 happen if the "nonnull" attribute was given without an operand 5401 list (which means to check every pointer argument). */ 5402 5403 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE) 5404 return; 5405 5406 /* Diagnose the simple cases of null arguments. */ 5407 if (integer_zerop (fold_for_warn (param))) 5408 { 5409 warning_at (pctx->loc, OPT_Wnonnull, "null argument where non-null " 5410 "required (argument %lu)", (unsigned long) param_num); 5411 pctx->warned_p = true; 5412 } 5413 } 5414 5415 /* Helper for nonnull attribute handling; fetch the operand number 5416 from the attribute argument list. */ 5417 5418 bool 5419 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp) 5420 { 5421 /* Verify the arg number is a small constant. */ 5422 if (tree_fits_uhwi_p (arg_num_expr)) 5423 { 5424 *valp = tree_to_uhwi (arg_num_expr); 5425 return true; 5426 } 5427 else 5428 return false; 5429 } 5430 5431 /* Arguments being collected for optimization. */ 5432 typedef const char *const_char_p; /* For DEF_VEC_P. */ 5433 static GTY(()) vec<const_char_p, va_gc> *optimize_args; 5434 5435 5436 /* Inner function to convert a TREE_LIST to argv string to parse the optimize 5437 options in ARGS. ATTR_P is true if this is for attribute(optimize), and 5438 false for #pragma GCC optimize. */ 5439 5440 bool 5441 parse_optimize_options (tree args, bool attr_p) 5442 { 5443 bool ret = true; 5444 unsigned opt_argc; 5445 unsigned i; 5446 const char **opt_argv; 5447 struct cl_decoded_option *decoded_options; 5448 unsigned int decoded_options_count; 5449 tree ap; 5450 5451 /* Build up argv vector. Just in case the string is stored away, use garbage 5452 collected strings. */ 5453 vec_safe_truncate (optimize_args, 0); 5454 vec_safe_push (optimize_args, (const char *) NULL); 5455 5456 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap)) 5457 { 5458 tree value = TREE_VALUE (ap); 5459 5460 if (TREE_CODE (value) == INTEGER_CST) 5461 { 5462 char buffer[20]; 5463 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value)); 5464 vec_safe_push (optimize_args, ggc_strdup (buffer)); 5465 } 5466 5467 else if (TREE_CODE (value) == STRING_CST) 5468 { 5469 /* Split string into multiple substrings. */ 5470 size_t len = TREE_STRING_LENGTH (value); 5471 char *p = ASTRDUP (TREE_STRING_POINTER (value)); 5472 char *end = p + len; 5473 char *comma; 5474 char *next_p = p; 5475 5476 while (next_p != NULL) 5477 { 5478 size_t len2; 5479 char *q, *r; 5480 5481 p = next_p; 5482 comma = strchr (p, ','); 5483 if (comma) 5484 { 5485 len2 = comma - p; 5486 *comma = '\0'; 5487 next_p = comma+1; 5488 } 5489 else 5490 { 5491 len2 = end - p; 5492 next_p = NULL; 5493 } 5494 5495 r = q = (char *) ggc_alloc_atomic (len2 + 3); 5496 5497 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx 5498 options. */ 5499 if (*p == '-' && p[1] != 'O' && p[1] != 'f') 5500 { 5501 ret = false; 5502 if (attr_p) 5503 warning (OPT_Wattributes, 5504 "bad option %qs to attribute %<optimize%>", p); 5505 else 5506 warning (OPT_Wpragmas, 5507 "bad option %qs to pragma %<optimize%>", p); 5508 continue; 5509 } 5510 5511 if (*p != '-') 5512 { 5513 *r++ = '-'; 5514 5515 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by 5516 itself is -Os, and any other switch begins with a -f. */ 5517 if ((*p >= '0' && *p <= '9') 5518 || (p[0] == 's' && p[1] == '\0')) 5519 *r++ = 'O'; 5520 else if (*p != 'O') 5521 *r++ = 'f'; 5522 } 5523 5524 memcpy (r, p, len2); 5525 r[len2] = '\0'; 5526 vec_safe_push (optimize_args, (const char *) q); 5527 } 5528 5529 } 5530 } 5531 5532 opt_argc = optimize_args->length (); 5533 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1)); 5534 5535 for (i = 1; i < opt_argc; i++) 5536 opt_argv[i] = (*optimize_args)[i]; 5537 5538 /* Now parse the options. */ 5539 decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv, 5540 &decoded_options, 5541 &decoded_options_count); 5542 /* Drop non-Optimization options. */ 5543 unsigned j = 1; 5544 for (i = 1; i < decoded_options_count; ++i) 5545 { 5546 if (! (cl_options[decoded_options[i].opt_index].flags & CL_OPTIMIZATION)) 5547 { 5548 ret = false; 5549 if (attr_p) 5550 warning (OPT_Wattributes, 5551 "bad option %qs to attribute %<optimize%>", 5552 decoded_options[i].orig_option_with_args_text); 5553 else 5554 warning (OPT_Wpragmas, 5555 "bad option %qs to pragma %<optimize%>", 5556 decoded_options[i].orig_option_with_args_text); 5557 continue; 5558 } 5559 if (i != j) 5560 decoded_options[j] = decoded_options[i]; 5561 j++; 5562 } 5563 decoded_options_count = j; 5564 /* And apply them. */ 5565 decode_options (&global_options, &global_options_set, 5566 decoded_options, decoded_options_count, 5567 input_location, global_dc, NULL); 5568 5569 targetm.override_options_after_change(); 5570 5571 optimize_args->truncate (0); 5572 return ret; 5573 } 5574 5575 /* Check whether ATTR is a valid attribute fallthrough. */ 5576 5577 bool 5578 attribute_fallthrough_p (tree attr) 5579 { 5580 if (attr == error_mark_node) 5581 return false; 5582 tree t = lookup_attribute ("fallthrough", attr); 5583 if (t == NULL_TREE) 5584 return false; 5585 /* This attribute shall appear at most once in each attribute-list. */ 5586 if (lookup_attribute ("fallthrough", TREE_CHAIN (t))) 5587 warning (OPT_Wattributes, "%<fallthrough%> attribute specified multiple " 5588 "times"); 5589 /* No attribute-argument-clause shall be present. */ 5590 else if (TREE_VALUE (t) != NULL_TREE) 5591 warning (OPT_Wattributes, "%<fallthrough%> attribute specified with " 5592 "a parameter"); 5593 /* Warn if other attributes are found. */ 5594 for (t = attr; t != NULL_TREE; t = TREE_CHAIN (t)) 5595 { 5596 tree name = get_attribute_name (t); 5597 if (!is_attribute_p ("fallthrough", name)) 5598 warning (OPT_Wattributes, "%qE attribute ignored", name); 5599 } 5600 return true; 5601 } 5602 5603 5604 /* Check for valid arguments being passed to a function with FNTYPE. 5605 There are NARGS arguments in the array ARGARRAY. LOC should be used 5606 for diagnostics. Return true if either -Wnonnull or -Wrestrict has 5607 been issued. */ 5608 5609 bool 5610 check_function_arguments (location_t loc, const_tree fndecl, const_tree fntype, 5611 int nargs, tree *argarray, vec<location_t> *arglocs) 5612 { 5613 bool warned_p = false; 5614 5615 /* Check for null being passed in a pointer argument that must be 5616 non-null. We also need to do this if format checking is enabled. */ 5617 5618 if (warn_nonnull) 5619 warned_p = check_function_nonnull (loc, TYPE_ATTRIBUTES (fntype), 5620 nargs, argarray); 5621 5622 /* Check for errors in format strings. */ 5623 5624 if (warn_format || warn_suggest_attribute_format) 5625 check_function_format (TYPE_ATTRIBUTES (fntype), nargs, argarray, arglocs); 5626 5627 if (warn_format) 5628 check_function_sentinel (fntype, nargs, argarray); 5629 5630 if (warn_restrict) 5631 warned_p |= check_function_restrict (fndecl, fntype, nargs, argarray); 5632 return warned_p; 5633 } 5634 5635 /* Generic argument checking recursion routine. PARAM is the argument to 5636 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked 5637 once the argument is resolved. CTX is context for the callback. */ 5638 void 5639 check_function_arguments_recurse (void (*callback) 5640 (void *, tree, unsigned HOST_WIDE_INT), 5641 void *ctx, tree param, 5642 unsigned HOST_WIDE_INT param_num) 5643 { 5644 if (CONVERT_EXPR_P (param) 5645 && (TYPE_PRECISION (TREE_TYPE (param)) 5646 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0))))) 5647 { 5648 /* Strip coercion. */ 5649 check_function_arguments_recurse (callback, ctx, 5650 TREE_OPERAND (param, 0), param_num); 5651 return; 5652 } 5653 5654 if (TREE_CODE (param) == CALL_EXPR) 5655 { 5656 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param))); 5657 tree attrs; 5658 bool found_format_arg = false; 5659 5660 /* See if this is a call to a known internationalization function 5661 that modifies a format arg. Such a function may have multiple 5662 format_arg attributes (for example, ngettext). */ 5663 5664 for (attrs = TYPE_ATTRIBUTES (type); 5665 attrs; 5666 attrs = TREE_CHAIN (attrs)) 5667 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs))) 5668 { 5669 tree inner_arg; 5670 tree format_num_expr; 5671 int format_num; 5672 int i; 5673 call_expr_arg_iterator iter; 5674 5675 /* Extract the argument number, which was previously checked 5676 to be valid. */ 5677 format_num_expr = TREE_VALUE (TREE_VALUE (attrs)); 5678 5679 format_num = tree_to_uhwi (format_num_expr); 5680 5681 for (inner_arg = first_call_expr_arg (param, &iter), i = 1; 5682 inner_arg != NULL_TREE; 5683 inner_arg = next_call_expr_arg (&iter), i++) 5684 if (i == format_num) 5685 { 5686 check_function_arguments_recurse (callback, ctx, 5687 inner_arg, param_num); 5688 found_format_arg = true; 5689 break; 5690 } 5691 } 5692 5693 /* If we found a format_arg attribute and did a recursive check, 5694 we are done with checking this argument. Otherwise, we continue 5695 and this will be considered a non-literal. */ 5696 if (found_format_arg) 5697 return; 5698 } 5699 5700 if (TREE_CODE (param) == COND_EXPR) 5701 { 5702 /* Simplify to avoid warning for an impossible case. */ 5703 param = fold_for_warn (param); 5704 if (TREE_CODE (param) == COND_EXPR) 5705 { 5706 /* Check both halves of the conditional expression. */ 5707 check_function_arguments_recurse (callback, ctx, 5708 TREE_OPERAND (param, 1), 5709 param_num); 5710 check_function_arguments_recurse (callback, ctx, 5711 TREE_OPERAND (param, 2), 5712 param_num); 5713 return; 5714 } 5715 } 5716 5717 (*callback) (ctx, param, param_num); 5718 } 5719 5720 /* Checks for a builtin function FNDECL that the number of arguments 5721 NARGS against the required number REQUIRED and issues an error if 5722 there is a mismatch. Returns true if the number of arguments is 5723 correct, otherwise false. LOC is the location of FNDECL. */ 5724 5725 static bool 5726 builtin_function_validate_nargs (location_t loc, tree fndecl, int nargs, 5727 int required) 5728 { 5729 if (nargs < required) 5730 { 5731 error_at (loc, "too few arguments to function %qE", fndecl); 5732 return false; 5733 } 5734 else if (nargs > required) 5735 { 5736 error_at (loc, "too many arguments to function %qE", fndecl); 5737 return false; 5738 } 5739 return true; 5740 } 5741 5742 /* Helper macro for check_builtin_function_arguments. */ 5743 #define ARG_LOCATION(N) \ 5744 (arg_loc.is_empty () \ 5745 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \ 5746 : expansion_point_location (arg_loc[(N)])) 5747 5748 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL. 5749 Returns false if there was an error, otherwise true. LOC is the 5750 location of the function; ARG_LOC is a vector of locations of the 5751 arguments. */ 5752 5753 bool 5754 check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc, 5755 tree fndecl, int nargs, tree *args) 5756 { 5757 if (!DECL_BUILT_IN (fndecl) 5758 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL) 5759 return true; 5760 5761 switch (DECL_FUNCTION_CODE (fndecl)) 5762 { 5763 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX: 5764 if (!tree_fits_uhwi_p (args[2])) 5765 { 5766 error_at (ARG_LOCATION (2), 5767 "third argument to function %qE must be a constant integer", 5768 fndecl); 5769 return false; 5770 } 5771 /* fall through */ 5772 5773 case BUILT_IN_ALLOCA_WITH_ALIGN: 5774 { 5775 /* Get the requested alignment (in bits) if it's a constant 5776 integer expression. */ 5777 unsigned HOST_WIDE_INT align 5778 = tree_fits_uhwi_p (args[1]) ? tree_to_uhwi (args[1]) : 0; 5779 5780 /* Determine if the requested alignment is a power of 2. */ 5781 if ((align & (align - 1))) 5782 align = 0; 5783 5784 /* The maximum alignment in bits corresponding to the same 5785 maximum in bytes enforced in check_user_alignment(). */ 5786 unsigned maxalign = (UINT_MAX >> 1) + 1; 5787 5788 /* Reject invalid alignments. */ 5789 if (align < BITS_PER_UNIT || maxalign < align) 5790 { 5791 error_at (ARG_LOCATION (1), 5792 "second argument to function %qE must be a constant " 5793 "integer power of 2 between %qi and %qu bits", 5794 fndecl, BITS_PER_UNIT, maxalign); 5795 return false; 5796 } 5797 return true; 5798 } 5799 5800 case BUILT_IN_CONSTANT_P: 5801 return builtin_function_validate_nargs (loc, fndecl, nargs, 1); 5802 5803 case BUILT_IN_ISFINITE: 5804 case BUILT_IN_ISINF: 5805 case BUILT_IN_ISINF_SIGN: 5806 case BUILT_IN_ISNAN: 5807 case BUILT_IN_ISNORMAL: 5808 case BUILT_IN_SIGNBIT: 5809 if (builtin_function_validate_nargs (loc, fndecl, nargs, 1)) 5810 { 5811 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE) 5812 { 5813 error_at (ARG_LOCATION (0), "non-floating-point argument in " 5814 "call to function %qE", fndecl); 5815 return false; 5816 } 5817 return true; 5818 } 5819 return false; 5820 5821 case BUILT_IN_ISGREATER: 5822 case BUILT_IN_ISGREATEREQUAL: 5823 case BUILT_IN_ISLESS: 5824 case BUILT_IN_ISLESSEQUAL: 5825 case BUILT_IN_ISLESSGREATER: 5826 case BUILT_IN_ISUNORDERED: 5827 if (builtin_function_validate_nargs (loc, fndecl, nargs, 2)) 5828 { 5829 enum tree_code code0, code1; 5830 code0 = TREE_CODE (TREE_TYPE (args[0])); 5831 code1 = TREE_CODE (TREE_TYPE (args[1])); 5832 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE) 5833 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE) 5834 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE))) 5835 { 5836 error_at (loc, "non-floating-point arguments in call to " 5837 "function %qE", fndecl); 5838 return false; 5839 } 5840 return true; 5841 } 5842 return false; 5843 5844 case BUILT_IN_FPCLASSIFY: 5845 if (builtin_function_validate_nargs (loc, fndecl, nargs, 6)) 5846 { 5847 for (unsigned int i = 0; i < 5; i++) 5848 if (TREE_CODE (args[i]) != INTEGER_CST) 5849 { 5850 error_at (ARG_LOCATION (i), "non-const integer argument %u in " 5851 "call to function %qE", i + 1, fndecl); 5852 return false; 5853 } 5854 5855 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE) 5856 { 5857 error_at (ARG_LOCATION (5), "non-floating-point argument in " 5858 "call to function %qE", fndecl); 5859 return false; 5860 } 5861 return true; 5862 } 5863 return false; 5864 5865 case BUILT_IN_ASSUME_ALIGNED: 5866 if (builtin_function_validate_nargs (loc, fndecl, nargs, 2 + (nargs > 2))) 5867 { 5868 if (nargs >= 3 && TREE_CODE (TREE_TYPE (args[2])) != INTEGER_TYPE) 5869 { 5870 error_at (ARG_LOCATION (2), "non-integer argument 3 in call to " 5871 "function %qE", fndecl); 5872 return false; 5873 } 5874 return true; 5875 } 5876 return false; 5877 5878 case BUILT_IN_ADD_OVERFLOW: 5879 case BUILT_IN_SUB_OVERFLOW: 5880 case BUILT_IN_MUL_OVERFLOW: 5881 if (builtin_function_validate_nargs (loc, fndecl, nargs, 3)) 5882 { 5883 unsigned i; 5884 for (i = 0; i < 2; i++) 5885 if (!INTEGRAL_TYPE_P (TREE_TYPE (args[i]))) 5886 { 5887 error_at (ARG_LOCATION (i), "argument %u in call to function " 5888 "%qE does not have integral type", i + 1, fndecl); 5889 return false; 5890 } 5891 if (TREE_CODE (TREE_TYPE (args[2])) != POINTER_TYPE 5892 || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (args[2])))) 5893 { 5894 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE " 5895 "does not have pointer to integral type", fndecl); 5896 return false; 5897 } 5898 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args[2]))) == ENUMERAL_TYPE) 5899 { 5900 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE " 5901 "has pointer to enumerated type", fndecl); 5902 return false; 5903 } 5904 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args[2]))) == BOOLEAN_TYPE) 5905 { 5906 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE " 5907 "has pointer to boolean type", fndecl); 5908 return false; 5909 } 5910 return true; 5911 } 5912 return false; 5913 5914 case BUILT_IN_ADD_OVERFLOW_P: 5915 case BUILT_IN_SUB_OVERFLOW_P: 5916 case BUILT_IN_MUL_OVERFLOW_P: 5917 if (builtin_function_validate_nargs (loc, fndecl, nargs, 3)) 5918 { 5919 unsigned i; 5920 for (i = 0; i < 3; i++) 5921 if (!INTEGRAL_TYPE_P (TREE_TYPE (args[i]))) 5922 { 5923 error_at (ARG_LOCATION (i), "argument %u in call to function " 5924 "%qE does not have integral type", i + 1, fndecl); 5925 return false; 5926 } 5927 if (TREE_CODE (TREE_TYPE (args[2])) == ENUMERAL_TYPE) 5928 { 5929 error_at (ARG_LOCATION (2), "argument 3 in call to function " 5930 "%qE has enumerated type", fndecl); 5931 return false; 5932 } 5933 else if (TREE_CODE (TREE_TYPE (args[2])) == BOOLEAN_TYPE) 5934 { 5935 error_at (ARG_LOCATION (2), "argument 3 in call to function " 5936 "%qE has boolean type", fndecl); 5937 return false; 5938 } 5939 return true; 5940 } 5941 return false; 5942 5943 default: 5944 return true; 5945 } 5946 } 5947 5948 /* Subroutine of c_parse_error. 5949 Return the result of concatenating LHS and RHS. RHS is really 5950 a string literal, its first character is indicated by RHS_START and 5951 RHS_SIZE is its length (including the terminating NUL character). 5952 5953 The caller is responsible for deleting the returned pointer. */ 5954 5955 static char * 5956 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size) 5957 { 5958 const size_t lhs_size = strlen (lhs); 5959 char *result = XNEWVEC (char, lhs_size + rhs_size); 5960 memcpy (result, lhs, lhs_size); 5961 memcpy (result + lhs_size, rhs_start, rhs_size); 5962 return result; 5963 } 5964 5965 /* Issue the error given by GMSGID at RICHLOC, indicating that it occurred 5966 before TOKEN, which had the associated VALUE. */ 5967 5968 void 5969 c_parse_error (const char *gmsgid, enum cpp_ttype token_type, 5970 tree value, unsigned char token_flags, 5971 rich_location *richloc) 5972 { 5973 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2)) 5974 5975 char *message = NULL; 5976 5977 if (token_type == CPP_EOF) 5978 message = catenate_messages (gmsgid, " at end of input"); 5979 else if (token_type == CPP_CHAR 5980 || token_type == CPP_WCHAR 5981 || token_type == CPP_CHAR16 5982 || token_type == CPP_CHAR32 5983 || token_type == CPP_UTF8CHAR) 5984 { 5985 unsigned int val = TREE_INT_CST_LOW (value); 5986 const char *prefix; 5987 5988 switch (token_type) 5989 { 5990 default: 5991 prefix = ""; 5992 break; 5993 case CPP_WCHAR: 5994 prefix = "L"; 5995 break; 5996 case CPP_CHAR16: 5997 prefix = "u"; 5998 break; 5999 case CPP_CHAR32: 6000 prefix = "U"; 6001 break; 6002 case CPP_UTF8CHAR: 6003 prefix = "u8"; 6004 break; 6005 } 6006 6007 if (val <= UCHAR_MAX && ISGRAPH (val)) 6008 message = catenate_messages (gmsgid, " before %s'%c'"); 6009 else 6010 message = catenate_messages (gmsgid, " before %s'\\x%x'"); 6011 6012 error_at (richloc, message, prefix, val); 6013 free (message); 6014 message = NULL; 6015 } 6016 else if (token_type == CPP_CHAR_USERDEF 6017 || token_type == CPP_WCHAR_USERDEF 6018 || token_type == CPP_CHAR16_USERDEF 6019 || token_type == CPP_CHAR32_USERDEF 6020 || token_type == CPP_UTF8CHAR_USERDEF) 6021 message = catenate_messages (gmsgid, 6022 " before user-defined character literal"); 6023 else if (token_type == CPP_STRING_USERDEF 6024 || token_type == CPP_WSTRING_USERDEF 6025 || token_type == CPP_STRING16_USERDEF 6026 || token_type == CPP_STRING32_USERDEF 6027 || token_type == CPP_UTF8STRING_USERDEF) 6028 message = catenate_messages (gmsgid, " before user-defined string literal"); 6029 else if (token_type == CPP_STRING 6030 || token_type == CPP_WSTRING 6031 || token_type == CPP_STRING16 6032 || token_type == CPP_STRING32 6033 || token_type == CPP_UTF8STRING) 6034 message = catenate_messages (gmsgid, " before string constant"); 6035 else if (token_type == CPP_NUMBER) 6036 message = catenate_messages (gmsgid, " before numeric constant"); 6037 else if (token_type == CPP_NAME) 6038 { 6039 message = catenate_messages (gmsgid, " before %qE"); 6040 error_at (richloc, message, value); 6041 free (message); 6042 message = NULL; 6043 } 6044 else if (token_type == CPP_PRAGMA) 6045 message = catenate_messages (gmsgid, " before %<#pragma%>"); 6046 else if (token_type == CPP_PRAGMA_EOL) 6047 message = catenate_messages (gmsgid, " before end of line"); 6048 else if (token_type == CPP_DECLTYPE) 6049 message = catenate_messages (gmsgid, " before %<decltype%>"); 6050 else if (token_type < N_TTYPES) 6051 { 6052 message = catenate_messages (gmsgid, " before %qs token"); 6053 error_at (richloc, message, cpp_type2name (token_type, token_flags)); 6054 free (message); 6055 message = NULL; 6056 } 6057 else 6058 error_at (richloc, gmsgid); 6059 6060 if (message) 6061 { 6062 error_at (richloc, message); 6063 free (message); 6064 } 6065 #undef catenate_messages 6066 } 6067 6068 /* Return the gcc option code associated with the reason for a cpp 6069 message, or 0 if none. */ 6070 6071 static int 6072 c_option_controlling_cpp_error (int reason) 6073 { 6074 const struct cpp_reason_option_codes_t *entry; 6075 6076 for (entry = cpp_reason_option_codes; entry->reason != CPP_W_NONE; entry++) 6077 { 6078 if (entry->reason == reason) 6079 return entry->option_code; 6080 } 6081 return 0; 6082 } 6083 6084 /* Callback from cpp_error for PFILE to print diagnostics from the 6085 preprocessor. The diagnostic is of type LEVEL, with REASON set 6086 to the reason code if LEVEL is represents a warning, at location 6087 RICHLOC unless this is after lexing and the compiler's location 6088 should be used instead; MSG is the translated message and AP 6089 the arguments. Returns true if a diagnostic was emitted, false 6090 otherwise. */ 6091 6092 bool 6093 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason, 6094 rich_location *richloc, 6095 const char *msg, va_list *ap) 6096 { 6097 diagnostic_info diagnostic; 6098 diagnostic_t dlevel; 6099 bool save_warn_system_headers = global_dc->dc_warn_system_headers; 6100 bool ret; 6101 6102 switch (level) 6103 { 6104 case CPP_DL_WARNING_SYSHDR: 6105 if (flag_no_output) 6106 return false; 6107 global_dc->dc_warn_system_headers = 1; 6108 /* Fall through. */ 6109 case CPP_DL_WARNING: 6110 if (flag_no_output) 6111 return false; 6112 dlevel = DK_WARNING; 6113 break; 6114 case CPP_DL_PEDWARN: 6115 if (flag_no_output && !flag_pedantic_errors) 6116 return false; 6117 dlevel = DK_PEDWARN; 6118 break; 6119 case CPP_DL_ERROR: 6120 dlevel = DK_ERROR; 6121 break; 6122 case CPP_DL_ICE: 6123 dlevel = DK_ICE; 6124 break; 6125 case CPP_DL_NOTE: 6126 dlevel = DK_NOTE; 6127 break; 6128 case CPP_DL_FATAL: 6129 dlevel = DK_FATAL; 6130 break; 6131 default: 6132 gcc_unreachable (); 6133 } 6134 if (done_lexing) 6135 richloc->set_range (line_table, 0, input_location, true); 6136 diagnostic_set_info_translated (&diagnostic, msg, ap, 6137 richloc, dlevel); 6138 diagnostic_override_option_index (&diagnostic, 6139 c_option_controlling_cpp_error (reason)); 6140 ret = diagnostic_report_diagnostic (global_dc, &diagnostic); 6141 if (level == CPP_DL_WARNING_SYSHDR) 6142 global_dc->dc_warn_system_headers = save_warn_system_headers; 6143 return ret; 6144 } 6145 6146 /* Convert a character from the host to the target execution character 6147 set. cpplib handles this, mostly. */ 6148 6149 HOST_WIDE_INT 6150 c_common_to_target_charset (HOST_WIDE_INT c) 6151 { 6152 /* Character constants in GCC proper are sign-extended under -fsigned-char, 6153 zero-extended under -fno-signed-char. cpplib insists that characters 6154 and character constants are always unsigned. Hence we must convert 6155 back and forth. */ 6156 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1); 6157 6158 uc = cpp_host_to_exec_charset (parse_in, uc); 6159 6160 if (flag_signed_char) 6161 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE) 6162 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE); 6163 else 6164 return uc; 6165 } 6166 6167 /* Fold an offsetof-like expression. EXPR is a nested sequence of component 6168 references with an INDIRECT_REF of a constant at the bottom; much like the 6169 traditional rendering of offsetof as a macro. TYPE is the desired type of 6170 the whole expression. Return the folded result. */ 6171 6172 tree 6173 fold_offsetof (tree expr, tree type, enum tree_code ctx) 6174 { 6175 tree base, off, t; 6176 tree_code code = TREE_CODE (expr); 6177 switch (code) 6178 { 6179 case ERROR_MARK: 6180 return expr; 6181 6182 case VAR_DECL: 6183 error ("cannot apply %<offsetof%> to static data member %qD", expr); 6184 return error_mark_node; 6185 6186 case CALL_EXPR: 6187 case TARGET_EXPR: 6188 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded"); 6189 return error_mark_node; 6190 6191 case NOP_EXPR: 6192 case INDIRECT_REF: 6193 if (!TREE_CONSTANT (TREE_OPERAND (expr, 0))) 6194 { 6195 error ("cannot apply %<offsetof%> to a non constant address"); 6196 return error_mark_node; 6197 } 6198 return convert (type, TREE_OPERAND (expr, 0)); 6199 6200 case COMPONENT_REF: 6201 base = fold_offsetof (TREE_OPERAND (expr, 0), type, code); 6202 if (base == error_mark_node) 6203 return base; 6204 6205 t = TREE_OPERAND (expr, 1); 6206 if (DECL_C_BIT_FIELD (t)) 6207 { 6208 error ("attempt to take address of bit-field structure " 6209 "member %qD", t); 6210 return error_mark_node; 6211 } 6212 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t), 6213 size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t)) 6214 / BITS_PER_UNIT)); 6215 break; 6216 6217 case ARRAY_REF: 6218 base = fold_offsetof (TREE_OPERAND (expr, 0), type, code); 6219 if (base == error_mark_node) 6220 return base; 6221 6222 t = TREE_OPERAND (expr, 1); 6223 6224 /* Check if the offset goes beyond the upper bound of the array. */ 6225 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) >= 0) 6226 { 6227 tree upbound = array_ref_up_bound (expr); 6228 if (upbound != NULL_TREE 6229 && TREE_CODE (upbound) == INTEGER_CST 6230 && !tree_int_cst_equal (upbound, 6231 TYPE_MAX_VALUE (TREE_TYPE (upbound)))) 6232 { 6233 if (ctx != ARRAY_REF && ctx != COMPONENT_REF) 6234 upbound = size_binop (PLUS_EXPR, upbound, 6235 build_int_cst (TREE_TYPE (upbound), 1)); 6236 if (tree_int_cst_lt (upbound, t)) 6237 { 6238 tree v; 6239 6240 for (v = TREE_OPERAND (expr, 0); 6241 TREE_CODE (v) == COMPONENT_REF; 6242 v = TREE_OPERAND (v, 0)) 6243 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0))) 6244 == RECORD_TYPE) 6245 { 6246 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1)); 6247 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain)) 6248 if (TREE_CODE (fld_chain) == FIELD_DECL) 6249 break; 6250 6251 if (fld_chain) 6252 break; 6253 } 6254 /* Don't warn if the array might be considered a poor 6255 man's flexible array member with a very permissive 6256 definition thereof. */ 6257 if (TREE_CODE (v) == ARRAY_REF 6258 || TREE_CODE (v) == COMPONENT_REF) 6259 warning (OPT_Warray_bounds, 6260 "index %E denotes an offset " 6261 "greater than size of %qT", 6262 t, TREE_TYPE (TREE_OPERAND (expr, 0))); 6263 } 6264 } 6265 } 6266 6267 t = convert (sizetype, t); 6268 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t); 6269 break; 6270 6271 case COMPOUND_EXPR: 6272 /* Handle static members of volatile structs. */ 6273 t = TREE_OPERAND (expr, 1); 6274 gcc_checking_assert (VAR_P (get_base_address (t))); 6275 return fold_offsetof (t, type); 6276 6277 default: 6278 gcc_unreachable (); 6279 } 6280 6281 if (!POINTER_TYPE_P (type)) 6282 return size_binop (PLUS_EXPR, base, convert (type, off)); 6283 return fold_build_pointer_plus (base, off); 6284 } 6285 6286 /* *PTYPE is an incomplete array. Complete it with a domain based on 6287 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT 6288 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 6289 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */ 6290 6291 int 6292 complete_array_type (tree *ptype, tree initial_value, bool do_default) 6293 { 6294 tree maxindex, type, main_type, elt, unqual_elt; 6295 int failure = 0, quals; 6296 bool overflow_p = false; 6297 6298 maxindex = size_zero_node; 6299 if (initial_value) 6300 { 6301 if (TREE_CODE (initial_value) == STRING_CST) 6302 { 6303 int eltsize 6304 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value))); 6305 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1); 6306 } 6307 else if (TREE_CODE (initial_value) == CONSTRUCTOR) 6308 { 6309 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value); 6310 6311 if (vec_safe_is_empty (v)) 6312 { 6313 if (pedantic) 6314 failure = 3; 6315 maxindex = ssize_int (-1); 6316 } 6317 else 6318 { 6319 tree curindex; 6320 unsigned HOST_WIDE_INT cnt; 6321 constructor_elt *ce; 6322 bool fold_p = false; 6323 6324 if ((*v)[0].index) 6325 maxindex = (*v)[0].index, fold_p = true; 6326 6327 curindex = maxindex; 6328 6329 for (cnt = 1; vec_safe_iterate (v, cnt, &ce); cnt++) 6330 { 6331 bool curfold_p = false; 6332 if (ce->index) 6333 curindex = ce->index, curfold_p = true; 6334 else 6335 { 6336 if (fold_p) 6337 { 6338 /* Since we treat size types now as ordinary 6339 unsigned types, we need an explicit overflow 6340 check. */ 6341 tree orig = curindex; 6342 curindex = fold_convert (sizetype, curindex); 6343 overflow_p |= tree_int_cst_lt (curindex, orig); 6344 } 6345 curindex = size_binop (PLUS_EXPR, curindex, 6346 size_one_node); 6347 } 6348 if (tree_int_cst_lt (maxindex, curindex)) 6349 maxindex = curindex, fold_p = curfold_p; 6350 } 6351 if (fold_p) 6352 { 6353 tree orig = maxindex; 6354 maxindex = fold_convert (sizetype, maxindex); 6355 overflow_p |= tree_int_cst_lt (maxindex, orig); 6356 } 6357 } 6358 } 6359 else 6360 { 6361 /* Make an error message unless that happened already. */ 6362 if (initial_value != error_mark_node) 6363 failure = 1; 6364 } 6365 } 6366 else 6367 { 6368 failure = 2; 6369 if (!do_default) 6370 return failure; 6371 } 6372 6373 type = *ptype; 6374 elt = TREE_TYPE (type); 6375 quals = TYPE_QUALS (strip_array_types (elt)); 6376 if (quals == 0) 6377 unqual_elt = elt; 6378 else 6379 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals)); 6380 6381 /* Using build_distinct_type_copy and modifying things afterward instead 6382 of using build_array_type to create a new type preserves all of the 6383 TYPE_LANG_FLAG_? bits that the front end may have set. */ 6384 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 6385 TREE_TYPE (main_type) = unqual_elt; 6386 TYPE_DOMAIN (main_type) 6387 = build_range_type (TREE_TYPE (maxindex), 6388 build_int_cst (TREE_TYPE (maxindex), 0), maxindex); 6389 TYPE_TYPELESS_STORAGE (main_type) = TYPE_TYPELESS_STORAGE (type); 6390 layout_type (main_type); 6391 6392 /* Make sure we have the canonical MAIN_TYPE. */ 6393 hashval_t hashcode = type_hash_canon_hash (main_type); 6394 main_type = type_hash_canon (hashcode, main_type); 6395 6396 /* Fix the canonical type. */ 6397 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type)) 6398 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type))) 6399 SET_TYPE_STRUCTURAL_EQUALITY (main_type); 6400 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type) 6401 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type)) 6402 != TYPE_DOMAIN (main_type))) 6403 TYPE_CANONICAL (main_type) 6404 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)), 6405 TYPE_CANONICAL (TYPE_DOMAIN (main_type)), 6406 TYPE_TYPELESS_STORAGE (main_type)); 6407 else 6408 TYPE_CANONICAL (main_type) = main_type; 6409 6410 if (quals == 0) 6411 type = main_type; 6412 else 6413 type = c_build_qualified_type (main_type, quals); 6414 6415 if (COMPLETE_TYPE_P (type) 6416 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST 6417 && (overflow_p || TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))) 6418 { 6419 error ("size of array is too large"); 6420 /* If we proceed with the array type as it is, we'll eventually 6421 crash in tree_to_[su]hwi(). */ 6422 type = error_mark_node; 6423 } 6424 6425 *ptype = type; 6426 return failure; 6427 } 6428 6429 /* Like c_mark_addressable but don't check register qualifier. */ 6430 void 6431 c_common_mark_addressable_vec (tree t) 6432 { 6433 if (TREE_CODE (t) == C_MAYBE_CONST_EXPR) 6434 t = C_MAYBE_CONST_EXPR_EXPR (t); 6435 while (handled_component_p (t)) 6436 t = TREE_OPERAND (t, 0); 6437 if (!VAR_P (t) 6438 && TREE_CODE (t) != PARM_DECL 6439 && TREE_CODE (t) != COMPOUND_LITERAL_EXPR) 6440 return; 6441 if (!VAR_P (t) || !DECL_HARD_REGISTER (t)) 6442 TREE_ADDRESSABLE (t) = 1; 6443 if (TREE_CODE (t) == COMPOUND_LITERAL_EXPR) 6444 TREE_ADDRESSABLE (COMPOUND_LITERAL_EXPR_DECL (t)) = 1; 6445 } 6446 6447 6448 6449 /* Used to help initialize the builtin-types.def table. When a type of 6450 the correct size doesn't exist, use error_mark_node instead of NULL. 6451 The later results in segfaults even when a decl using the type doesn't 6452 get invoked. */ 6453 6454 tree 6455 builtin_type_for_size (int size, bool unsignedp) 6456 { 6457 tree type = c_common_type_for_size (size, unsignedp); 6458 return type ? type : error_mark_node; 6459 } 6460 6461 /* A helper function for resolve_overloaded_builtin in resolving the 6462 overloaded __sync_ builtins. Returns a positive power of 2 if the 6463 first operand of PARAMS is a pointer to a supported data type. 6464 Returns 0 if an error is encountered. 6465 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_ 6466 built-ins. */ 6467 6468 static int 6469 sync_resolve_size (tree function, vec<tree, va_gc> *params, bool fetch) 6470 { 6471 /* Type of the argument. */ 6472 tree argtype; 6473 /* Type the argument points to. */ 6474 tree type; 6475 int size; 6476 6477 if (vec_safe_is_empty (params)) 6478 { 6479 error ("too few arguments to function %qE", function); 6480 return 0; 6481 } 6482 6483 argtype = type = TREE_TYPE ((*params)[0]); 6484 if (TREE_CODE (type) == ARRAY_TYPE && c_dialect_cxx ()) 6485 { 6486 /* Force array-to-pointer decay for C++. */ 6487 (*params)[0] = default_conversion ((*params)[0]); 6488 type = TREE_TYPE ((*params)[0]); 6489 } 6490 if (TREE_CODE (type) != POINTER_TYPE) 6491 goto incompatible; 6492 6493 type = TREE_TYPE (type); 6494 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type)) 6495 goto incompatible; 6496 6497 if (!COMPLETE_TYPE_P (type)) 6498 goto incompatible; 6499 6500 if (fetch && TREE_CODE (type) == BOOLEAN_TYPE) 6501 goto incompatible; 6502 6503 size = tree_to_uhwi (TYPE_SIZE_UNIT (type)); 6504 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16) 6505 return size; 6506 6507 incompatible: 6508 /* Issue the diagnostic only if the argument is valid, otherwise 6509 it would be redundant at best and could be misleading. */ 6510 if (argtype != error_mark_node) 6511 error ("operand type %qT is incompatible with argument %d of %qE", 6512 argtype, 1, function); 6513 return 0; 6514 } 6515 6516 /* A helper function for resolve_overloaded_builtin. Adds casts to 6517 PARAMS to make arguments match up with those of FUNCTION. Drops 6518 the variadic arguments at the end. Returns false if some error 6519 was encountered; true on success. */ 6520 6521 static bool 6522 sync_resolve_params (location_t loc, tree orig_function, tree function, 6523 vec<tree, va_gc> *params, bool orig_format) 6524 { 6525 function_args_iterator iter; 6526 tree ptype; 6527 unsigned int parmnum; 6528 6529 function_args_iter_init (&iter, TREE_TYPE (function)); 6530 /* We've declared the implementation functions to use "volatile void *" 6531 as the pointer parameter, so we shouldn't get any complaints from the 6532 call to check_function_arguments what ever type the user used. */ 6533 function_args_iter_next (&iter); 6534 ptype = TREE_TYPE (TREE_TYPE ((*params)[0])); 6535 ptype = TYPE_MAIN_VARIANT (ptype); 6536 6537 /* For the rest of the values, we need to cast these to FTYPE, so that we 6538 don't get warnings for passing pointer types, etc. */ 6539 parmnum = 0; 6540 while (1) 6541 { 6542 tree val, arg_type; 6543 6544 arg_type = function_args_iter_cond (&iter); 6545 /* XXX void_type_node belies the abstraction. */ 6546 if (arg_type == void_type_node) 6547 break; 6548 6549 ++parmnum; 6550 if (params->length () <= parmnum) 6551 { 6552 error_at (loc, "too few arguments to function %qE", orig_function); 6553 return false; 6554 } 6555 6556 /* Only convert parameters if arg_type is unsigned integer type with 6557 new format sync routines, i.e. don't attempt to convert pointer 6558 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n), 6559 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel 6560 kinds). */ 6561 if (TREE_CODE (arg_type) == INTEGER_TYPE && TYPE_UNSIGNED (arg_type)) 6562 { 6563 /* Ideally for the first conversion we'd use convert_for_assignment 6564 so that we get warnings for anything that doesn't match the pointer 6565 type. This isn't portable across the C and C++ front ends atm. */ 6566 val = (*params)[parmnum]; 6567 val = convert (ptype, val); 6568 val = convert (arg_type, val); 6569 (*params)[parmnum] = val; 6570 } 6571 6572 function_args_iter_next (&iter); 6573 } 6574 6575 /* __atomic routines are not variadic. */ 6576 if (!orig_format && params->length () != parmnum + 1) 6577 { 6578 error_at (loc, "too many arguments to function %qE", orig_function); 6579 return false; 6580 } 6581 6582 /* The definition of these primitives is variadic, with the remaining 6583 being "an optional list of variables protected by the memory barrier". 6584 No clue what that's supposed to mean, precisely, but we consider all 6585 call-clobbered variables to be protected so we're safe. */ 6586 params->truncate (parmnum + 1); 6587 6588 return true; 6589 } 6590 6591 /* A helper function for resolve_overloaded_builtin. Adds a cast to 6592 RESULT to make it match the type of the first pointer argument in 6593 PARAMS. */ 6594 6595 static tree 6596 sync_resolve_return (tree first_param, tree result, bool orig_format) 6597 { 6598 tree ptype = TREE_TYPE (TREE_TYPE (first_param)); 6599 tree rtype = TREE_TYPE (result); 6600 ptype = TYPE_MAIN_VARIANT (ptype); 6601 6602 /* New format doesn't require casting unless the types are the same size. */ 6603 if (orig_format || tree_int_cst_equal (TYPE_SIZE (ptype), TYPE_SIZE (rtype))) 6604 return convert (ptype, result); 6605 else 6606 return result; 6607 } 6608 6609 /* This function verifies the PARAMS to generic atomic FUNCTION. 6610 It returns the size if all the parameters are the same size, otherwise 6611 0 is returned if the parameters are invalid. */ 6612 6613 static int 6614 get_atomic_generic_size (location_t loc, tree function, 6615 vec<tree, va_gc> *params) 6616 { 6617 unsigned int n_param; 6618 unsigned int n_model; 6619 unsigned int x; 6620 int size_0; 6621 tree type_0; 6622 6623 /* Determine the parameter makeup. */ 6624 switch (DECL_FUNCTION_CODE (function)) 6625 { 6626 case BUILT_IN_ATOMIC_EXCHANGE: 6627 n_param = 4; 6628 n_model = 1; 6629 break; 6630 case BUILT_IN_ATOMIC_LOAD: 6631 case BUILT_IN_ATOMIC_STORE: 6632 n_param = 3; 6633 n_model = 1; 6634 break; 6635 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE: 6636 n_param = 6; 6637 n_model = 2; 6638 break; 6639 default: 6640 gcc_unreachable (); 6641 } 6642 6643 if (vec_safe_length (params) != n_param) 6644 { 6645 error_at (loc, "incorrect number of arguments to function %qE", function); 6646 return 0; 6647 } 6648 6649 /* Get type of first parameter, and determine its size. */ 6650 type_0 = TREE_TYPE ((*params)[0]); 6651 if (TREE_CODE (type_0) == ARRAY_TYPE && c_dialect_cxx ()) 6652 { 6653 /* Force array-to-pointer decay for C++. */ 6654 (*params)[0] = default_conversion ((*params)[0]); 6655 type_0 = TREE_TYPE ((*params)[0]); 6656 } 6657 if (TREE_CODE (type_0) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (type_0))) 6658 { 6659 error_at (loc, "argument 1 of %qE must be a non-void pointer type", 6660 function); 6661 return 0; 6662 } 6663 6664 /* Types must be compile time constant sizes. */ 6665 if (TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type_0)))) != INTEGER_CST) 6666 { 6667 error_at (loc, 6668 "argument 1 of %qE must be a pointer to a constant size type", 6669 function); 6670 return 0; 6671 } 6672 6673 size_0 = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type_0))); 6674 6675 /* Zero size objects are not allowed. */ 6676 if (size_0 == 0) 6677 { 6678 error_at (loc, 6679 "argument 1 of %qE must be a pointer to a nonzero size object", 6680 function); 6681 return 0; 6682 } 6683 6684 /* Check each other parameter is a pointer and the same size. */ 6685 for (x = 0; x < n_param - n_model; x++) 6686 { 6687 int size; 6688 tree type = TREE_TYPE ((*params)[x]); 6689 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */ 6690 if (n_param == 6 && x == 3) 6691 continue; 6692 if (TREE_CODE (type) == ARRAY_TYPE && c_dialect_cxx ()) 6693 { 6694 /* Force array-to-pointer decay for C++. */ 6695 (*params)[x] = default_conversion ((*params)[x]); 6696 type = TREE_TYPE ((*params)[x]); 6697 } 6698 if (!POINTER_TYPE_P (type)) 6699 { 6700 error_at (loc, "argument %d of %qE must be a pointer type", x + 1, 6701 function); 6702 return 0; 6703 } 6704 else if (TYPE_SIZE_UNIT (TREE_TYPE (type)) 6705 && TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type)))) 6706 != INTEGER_CST) 6707 { 6708 error_at (loc, "argument %d of %qE must be a pointer to a constant " 6709 "size type", x + 1, function); 6710 return 0; 6711 } 6712 else if (FUNCTION_POINTER_TYPE_P (type)) 6713 { 6714 error_at (loc, "argument %d of %qE must not be a pointer to a " 6715 "function", x + 1, function); 6716 return 0; 6717 } 6718 tree type_size = TYPE_SIZE_UNIT (TREE_TYPE (type)); 6719 size = type_size ? tree_to_uhwi (type_size) : 0; 6720 if (size != size_0) 6721 { 6722 error_at (loc, "size mismatch in argument %d of %qE", x + 1, 6723 function); 6724 return 0; 6725 } 6726 } 6727 6728 /* Check memory model parameters for validity. */ 6729 for (x = n_param - n_model ; x < n_param; x++) 6730 { 6731 tree p = (*params)[x]; 6732 if (!INTEGRAL_TYPE_P (TREE_TYPE (p))) 6733 { 6734 error_at (loc, "non-integer memory model argument %d of %qE", x + 1, 6735 function); 6736 return 0; 6737 } 6738 p = fold_for_warn (p); 6739 if (TREE_CODE (p) == INTEGER_CST) 6740 { 6741 /* memmodel_base masks the low 16 bits, thus ignore any bits above 6742 it by using TREE_INT_CST_LOW instead of tree_to_*hwi. Those high 6743 bits will be checked later during expansion in target specific 6744 way. */ 6745 if (memmodel_base (TREE_INT_CST_LOW (p)) >= MEMMODEL_LAST) 6746 warning_at (loc, OPT_Winvalid_memory_model, 6747 "invalid memory model argument %d of %qE", x + 1, 6748 function); 6749 } 6750 } 6751 6752 return size_0; 6753 } 6754 6755 6756 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N 6757 at the beginning of the parameter list PARAMS representing the size of the 6758 objects. This is to match the library ABI requirement. LOC is the location 6759 of the function call. 6760 The new function is returned if it needed rebuilding, otherwise NULL_TREE is 6761 returned to allow the external call to be constructed. */ 6762 6763 static tree 6764 add_atomic_size_parameter (unsigned n, location_t loc, tree function, 6765 vec<tree, va_gc> *params) 6766 { 6767 tree size_node; 6768 6769 /* Insert a SIZE_T parameter as the first param. If there isn't 6770 enough space, allocate a new vector and recursively re-build with that. */ 6771 if (!params->space (1)) 6772 { 6773 unsigned int z, len; 6774 vec<tree, va_gc> *v; 6775 tree f; 6776 6777 len = params->length (); 6778 vec_alloc (v, len + 1); 6779 v->quick_push (build_int_cst (size_type_node, n)); 6780 for (z = 0; z < len; z++) 6781 v->quick_push ((*params)[z]); 6782 f = build_function_call_vec (loc, vNULL, function, v, NULL); 6783 vec_free (v); 6784 return f; 6785 } 6786 6787 /* Add the size parameter and leave as a function call for processing. */ 6788 size_node = build_int_cst (size_type_node, n); 6789 params->quick_insert (0, size_node); 6790 return NULL_TREE; 6791 } 6792 6793 6794 /* Return whether atomic operations for naturally aligned N-byte 6795 arguments are supported, whether inline or through libatomic. */ 6796 static bool 6797 atomic_size_supported_p (int n) 6798 { 6799 switch (n) 6800 { 6801 case 1: 6802 case 2: 6803 case 4: 6804 case 8: 6805 return true; 6806 6807 case 16: 6808 return targetm.scalar_mode_supported_p (TImode); 6809 6810 default: 6811 return false; 6812 } 6813 } 6814 6815 /* This will process an __atomic_exchange function call, determine whether it 6816 needs to be mapped to the _N variation, or turned into a library call. 6817 LOC is the location of the builtin call. 6818 FUNCTION is the DECL that has been invoked; 6819 PARAMS is the argument list for the call. The return value is non-null 6820 TRUE is returned if it is translated into the proper format for a call to the 6821 external library, and NEW_RETURN is set the tree for that function. 6822 FALSE is returned if processing for the _N variation is required, and 6823 NEW_RETURN is set to the return value the result is copied into. */ 6824 static bool 6825 resolve_overloaded_atomic_exchange (location_t loc, tree function, 6826 vec<tree, va_gc> *params, tree *new_return) 6827 { 6828 tree p0, p1, p2, p3; 6829 tree I_type, I_type_ptr; 6830 int n = get_atomic_generic_size (loc, function, params); 6831 6832 /* Size of 0 is an error condition. */ 6833 if (n == 0) 6834 { 6835 *new_return = error_mark_node; 6836 return true; 6837 } 6838 6839 /* If not a lock-free size, change to the library generic format. */ 6840 if (!atomic_size_supported_p (n)) 6841 { 6842 *new_return = add_atomic_size_parameter (n, loc, function, params); 6843 return true; 6844 } 6845 6846 /* Otherwise there is a lockfree match, transform the call from: 6847 void fn(T* mem, T* desired, T* return, model) 6848 into 6849 *return = (T) (fn (In* mem, (In) *desired, model)) */ 6850 6851 p0 = (*params)[0]; 6852 p1 = (*params)[1]; 6853 p2 = (*params)[2]; 6854 p3 = (*params)[3]; 6855 6856 /* Create pointer to appropriate size. */ 6857 I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1); 6858 I_type_ptr = build_pointer_type (I_type); 6859 6860 /* Convert object pointer to required type. */ 6861 p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0); 6862 (*params)[0] = p0; 6863 /* Convert new value to required type, and dereference it. */ 6864 p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR); 6865 p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1); 6866 (*params)[1] = p1; 6867 6868 /* Move memory model to the 3rd position, and end param list. */ 6869 (*params)[2] = p3; 6870 params->truncate (3); 6871 6872 /* Convert return pointer and dereference it for later assignment. */ 6873 *new_return = build_indirect_ref (loc, p2, RO_UNARY_STAR); 6874 6875 return false; 6876 } 6877 6878 6879 /* This will process an __atomic_compare_exchange function call, determine 6880 whether it needs to be mapped to the _N variation, or turned into a lib call. 6881 LOC is the location of the builtin call. 6882 FUNCTION is the DECL that has been invoked; 6883 PARAMS is the argument list for the call. The return value is non-null 6884 TRUE is returned if it is translated into the proper format for a call to the 6885 external library, and NEW_RETURN is set the tree for that function. 6886 FALSE is returned if processing for the _N variation is required. */ 6887 6888 static bool 6889 resolve_overloaded_atomic_compare_exchange (location_t loc, tree function, 6890 vec<tree, va_gc> *params, 6891 tree *new_return) 6892 { 6893 tree p0, p1, p2; 6894 tree I_type, I_type_ptr; 6895 int n = get_atomic_generic_size (loc, function, params); 6896 6897 /* Size of 0 is an error condition. */ 6898 if (n == 0) 6899 { 6900 *new_return = error_mark_node; 6901 return true; 6902 } 6903 6904 /* If not a lock-free size, change to the library generic format. */ 6905 if (!atomic_size_supported_p (n)) 6906 { 6907 /* The library generic format does not have the weak parameter, so 6908 remove it from the param list. Since a parameter has been removed, 6909 we can be sure that there is room for the SIZE_T parameter, meaning 6910 there will not be a recursive rebuilding of the parameter list, so 6911 there is no danger this will be done twice. */ 6912 if (n > 0) 6913 { 6914 (*params)[3] = (*params)[4]; 6915 (*params)[4] = (*params)[5]; 6916 params->truncate (5); 6917 } 6918 *new_return = add_atomic_size_parameter (n, loc, function, params); 6919 return true; 6920 } 6921 6922 /* Otherwise, there is a match, so the call needs to be transformed from: 6923 bool fn(T* mem, T* desired, T* return, weak, success, failure) 6924 into 6925 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */ 6926 6927 p0 = (*params)[0]; 6928 p1 = (*params)[1]; 6929 p2 = (*params)[2]; 6930 6931 /* Create pointer to appropriate size. */ 6932 I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1); 6933 I_type_ptr = build_pointer_type (I_type); 6934 6935 /* Convert object pointer to required type. */ 6936 p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0); 6937 (*params)[0] = p0; 6938 6939 /* Convert expected pointer to required type. */ 6940 p1 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p1); 6941 (*params)[1] = p1; 6942 6943 /* Convert desired value to required type, and dereference it. */ 6944 p2 = build_indirect_ref (loc, p2, RO_UNARY_STAR); 6945 p2 = build1 (VIEW_CONVERT_EXPR, I_type, p2); 6946 (*params)[2] = p2; 6947 6948 /* The rest of the parameters are fine. NULL means no special return value 6949 processing.*/ 6950 *new_return = NULL; 6951 return false; 6952 } 6953 6954 6955 /* This will process an __atomic_load function call, determine whether it 6956 needs to be mapped to the _N variation, or turned into a library call. 6957 LOC is the location of the builtin call. 6958 FUNCTION is the DECL that has been invoked; 6959 PARAMS is the argument list for the call. The return value is non-null 6960 TRUE is returned if it is translated into the proper format for a call to the 6961 external library, and NEW_RETURN is set the tree for that function. 6962 FALSE is returned if processing for the _N variation is required, and 6963 NEW_RETURN is set to the return value the result is copied into. */ 6964 6965 static bool 6966 resolve_overloaded_atomic_load (location_t loc, tree function, 6967 vec<tree, va_gc> *params, tree *new_return) 6968 { 6969 tree p0, p1, p2; 6970 tree I_type, I_type_ptr; 6971 int n = get_atomic_generic_size (loc, function, params); 6972 6973 /* Size of 0 is an error condition. */ 6974 if (n == 0) 6975 { 6976 *new_return = error_mark_node; 6977 return true; 6978 } 6979 6980 /* If not a lock-free size, change to the library generic format. */ 6981 if (!atomic_size_supported_p (n)) 6982 { 6983 *new_return = add_atomic_size_parameter (n, loc, function, params); 6984 return true; 6985 } 6986 6987 /* Otherwise, there is a match, so the call needs to be transformed from: 6988 void fn(T* mem, T* return, model) 6989 into 6990 *return = (T) (fn ((In *) mem, model)) */ 6991 6992 p0 = (*params)[0]; 6993 p1 = (*params)[1]; 6994 p2 = (*params)[2]; 6995 6996 /* Create pointer to appropriate size. */ 6997 I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1); 6998 I_type_ptr = build_pointer_type (I_type); 6999 7000 /* Convert object pointer to required type. */ 7001 p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0); 7002 (*params)[0] = p0; 7003 7004 /* Move memory model to the 2nd position, and end param list. */ 7005 (*params)[1] = p2; 7006 params->truncate (2); 7007 7008 /* Convert return pointer and dereference it for later assignment. */ 7009 *new_return = build_indirect_ref (loc, p1, RO_UNARY_STAR); 7010 7011 return false; 7012 } 7013 7014 7015 /* This will process an __atomic_store function call, determine whether it 7016 needs to be mapped to the _N variation, or turned into a library call. 7017 LOC is the location of the builtin call. 7018 FUNCTION is the DECL that has been invoked; 7019 PARAMS is the argument list for the call. The return value is non-null 7020 TRUE is returned if it is translated into the proper format for a call to the 7021 external library, and NEW_RETURN is set the tree for that function. 7022 FALSE is returned if processing for the _N variation is required, and 7023 NEW_RETURN is set to the return value the result is copied into. */ 7024 7025 static bool 7026 resolve_overloaded_atomic_store (location_t loc, tree function, 7027 vec<tree, va_gc> *params, tree *new_return) 7028 { 7029 tree p0, p1; 7030 tree I_type, I_type_ptr; 7031 int n = get_atomic_generic_size (loc, function, params); 7032 7033 /* Size of 0 is an error condition. */ 7034 if (n == 0) 7035 { 7036 *new_return = error_mark_node; 7037 return true; 7038 } 7039 7040 /* If not a lock-free size, change to the library generic format. */ 7041 if (!atomic_size_supported_p (n)) 7042 { 7043 *new_return = add_atomic_size_parameter (n, loc, function, params); 7044 return true; 7045 } 7046 7047 /* Otherwise, there is a match, so the call needs to be transformed from: 7048 void fn(T* mem, T* value, model) 7049 into 7050 fn ((In *) mem, (In) *value, model) */ 7051 7052 p0 = (*params)[0]; 7053 p1 = (*params)[1]; 7054 7055 /* Create pointer to appropriate size. */ 7056 I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1); 7057 I_type_ptr = build_pointer_type (I_type); 7058 7059 /* Convert object pointer to required type. */ 7060 p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0); 7061 (*params)[0] = p0; 7062 7063 /* Convert new value to required type, and dereference it. */ 7064 p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR); 7065 p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1); 7066 (*params)[1] = p1; 7067 7068 /* The memory model is in the right spot already. Return is void. */ 7069 *new_return = NULL_TREE; 7070 7071 return false; 7072 } 7073 7074 7075 /* Some builtin functions are placeholders for other expressions. This 7076 function should be called immediately after parsing the call expression 7077 before surrounding code has committed to the type of the expression. 7078 7079 LOC is the location of the builtin call. 7080 7081 FUNCTION is the DECL that has been invoked; it is known to be a builtin. 7082 PARAMS is the argument list for the call. The return value is non-null 7083 when expansion is complete, and null if normal processing should 7084 continue. */ 7085 7086 tree 7087 resolve_overloaded_builtin (location_t loc, tree function, 7088 vec<tree, va_gc> *params) 7089 { 7090 enum built_in_function orig_code = DECL_FUNCTION_CODE (function); 7091 7092 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins? 7093 Those are not valid to call with a pointer to _Bool (or C++ bool) 7094 and so must be rejected. */ 7095 bool fetch_op = true; 7096 bool orig_format = true; 7097 tree new_return = NULL_TREE; 7098 7099 switch (DECL_BUILT_IN_CLASS (function)) 7100 { 7101 case BUILT_IN_NORMAL: 7102 break; 7103 case BUILT_IN_MD: 7104 if (targetm.resolve_overloaded_builtin) 7105 return targetm.resolve_overloaded_builtin (loc, function, params); 7106 else 7107 return NULL_TREE; 7108 default: 7109 return NULL_TREE; 7110 } 7111 7112 /* Handle BUILT_IN_NORMAL here. */ 7113 switch (orig_code) 7114 { 7115 case BUILT_IN_ATOMIC_EXCHANGE: 7116 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE: 7117 case BUILT_IN_ATOMIC_LOAD: 7118 case BUILT_IN_ATOMIC_STORE: 7119 { 7120 /* Handle these 4 together so that they can fall through to the next 7121 case if the call is transformed to an _N variant. */ 7122 switch (orig_code) 7123 { 7124 case BUILT_IN_ATOMIC_EXCHANGE: 7125 { 7126 if (resolve_overloaded_atomic_exchange (loc, function, params, 7127 &new_return)) 7128 return new_return; 7129 /* Change to the _N variant. */ 7130 orig_code = BUILT_IN_ATOMIC_EXCHANGE_N; 7131 break; 7132 } 7133 7134 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE: 7135 { 7136 if (resolve_overloaded_atomic_compare_exchange (loc, function, 7137 params, 7138 &new_return)) 7139 return new_return; 7140 /* Change to the _N variant. */ 7141 orig_code = BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N; 7142 break; 7143 } 7144 case BUILT_IN_ATOMIC_LOAD: 7145 { 7146 if (resolve_overloaded_atomic_load (loc, function, params, 7147 &new_return)) 7148 return new_return; 7149 /* Change to the _N variant. */ 7150 orig_code = BUILT_IN_ATOMIC_LOAD_N; 7151 break; 7152 } 7153 case BUILT_IN_ATOMIC_STORE: 7154 { 7155 if (resolve_overloaded_atomic_store (loc, function, params, 7156 &new_return)) 7157 return new_return; 7158 /* Change to the _N variant. */ 7159 orig_code = BUILT_IN_ATOMIC_STORE_N; 7160 break; 7161 } 7162 default: 7163 gcc_unreachable (); 7164 } 7165 } 7166 /* FALLTHRU */ 7167 case BUILT_IN_ATOMIC_EXCHANGE_N: 7168 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N: 7169 case BUILT_IN_ATOMIC_LOAD_N: 7170 case BUILT_IN_ATOMIC_STORE_N: 7171 fetch_op = false; 7172 /* FALLTHRU */ 7173 case BUILT_IN_ATOMIC_ADD_FETCH_N: 7174 case BUILT_IN_ATOMIC_SUB_FETCH_N: 7175 case BUILT_IN_ATOMIC_AND_FETCH_N: 7176 case BUILT_IN_ATOMIC_NAND_FETCH_N: 7177 case BUILT_IN_ATOMIC_XOR_FETCH_N: 7178 case BUILT_IN_ATOMIC_OR_FETCH_N: 7179 case BUILT_IN_ATOMIC_FETCH_ADD_N: 7180 case BUILT_IN_ATOMIC_FETCH_SUB_N: 7181 case BUILT_IN_ATOMIC_FETCH_AND_N: 7182 case BUILT_IN_ATOMIC_FETCH_NAND_N: 7183 case BUILT_IN_ATOMIC_FETCH_XOR_N: 7184 case BUILT_IN_ATOMIC_FETCH_OR_N: 7185 orig_format = false; 7186 /* FALLTHRU */ 7187 case BUILT_IN_SYNC_FETCH_AND_ADD_N: 7188 case BUILT_IN_SYNC_FETCH_AND_SUB_N: 7189 case BUILT_IN_SYNC_FETCH_AND_OR_N: 7190 case BUILT_IN_SYNC_FETCH_AND_AND_N: 7191 case BUILT_IN_SYNC_FETCH_AND_XOR_N: 7192 case BUILT_IN_SYNC_FETCH_AND_NAND_N: 7193 case BUILT_IN_SYNC_ADD_AND_FETCH_N: 7194 case BUILT_IN_SYNC_SUB_AND_FETCH_N: 7195 case BUILT_IN_SYNC_OR_AND_FETCH_N: 7196 case BUILT_IN_SYNC_AND_AND_FETCH_N: 7197 case BUILT_IN_SYNC_XOR_AND_FETCH_N: 7198 case BUILT_IN_SYNC_NAND_AND_FETCH_N: 7199 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N: 7200 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N: 7201 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N: 7202 case BUILT_IN_SYNC_LOCK_RELEASE_N: 7203 { 7204 /* The following are not _FETCH_OPs and must be accepted with 7205 pointers to _Bool (or C++ bool). */ 7206 if (fetch_op) 7207 fetch_op = 7208 (orig_code != BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N 7209 && orig_code != BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N 7210 && orig_code != BUILT_IN_SYNC_LOCK_TEST_AND_SET_N 7211 && orig_code != BUILT_IN_SYNC_LOCK_RELEASE_N); 7212 7213 int n = sync_resolve_size (function, params, fetch_op); 7214 tree new_function, first_param, result; 7215 enum built_in_function fncode; 7216 7217 if (n == 0) 7218 return error_mark_node; 7219 7220 fncode = (enum built_in_function)((int)orig_code + exact_log2 (n) + 1); 7221 new_function = builtin_decl_explicit (fncode); 7222 if (!sync_resolve_params (loc, function, new_function, params, 7223 orig_format)) 7224 return error_mark_node; 7225 7226 first_param = (*params)[0]; 7227 result = build_function_call_vec (loc, vNULL, new_function, params, 7228 NULL); 7229 if (result == error_mark_node) 7230 return result; 7231 if (orig_code != BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N 7232 && orig_code != BUILT_IN_SYNC_LOCK_RELEASE_N 7233 && orig_code != BUILT_IN_ATOMIC_STORE_N 7234 && orig_code != BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N) 7235 result = sync_resolve_return (first_param, result, orig_format); 7236 7237 if (fetch_op) 7238 /* Prevent -Wunused-value warning. */ 7239 TREE_USED (result) = true; 7240 7241 /* If new_return is set, assign function to that expr and cast the 7242 result to void since the generic interface returned void. */ 7243 if (new_return) 7244 { 7245 /* Cast function result from I{1,2,4,8,16} to the required type. */ 7246 result = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (new_return), result); 7247 result = build2 (MODIFY_EXPR, TREE_TYPE (new_return), new_return, 7248 result); 7249 TREE_SIDE_EFFECTS (result) = 1; 7250 protected_set_expr_location (result, loc); 7251 result = convert (void_type_node, result); 7252 } 7253 return result; 7254 } 7255 7256 default: 7257 return NULL_TREE; 7258 } 7259 } 7260 7261 /* vector_types_compatible_elements_p is used in type checks of vectors 7262 values used as operands of binary operators. Where it returns true, and 7263 the other checks of the caller succeed (being vector types in he first 7264 place, and matching number of elements), we can just treat the types 7265 as essentially the same. 7266 Contrast with vector_targets_convertible_p, which is used for vector 7267 pointer types, and vector_types_convertible_p, which will allow 7268 language-specific matches under the control of flag_lax_vector_conversions, 7269 and might still require a conversion. */ 7270 /* True if vector types T1 and T2 can be inputs to the same binary 7271 operator without conversion. 7272 We don't check the overall vector size here because some of our callers 7273 want to give different error messages when the vectors are compatible 7274 except for the element count. */ 7275 7276 bool 7277 vector_types_compatible_elements_p (tree t1, tree t2) 7278 { 7279 bool opaque = TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2); 7280 t1 = TREE_TYPE (t1); 7281 t2 = TREE_TYPE (t2); 7282 7283 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2); 7284 7285 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE) 7286 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE 7287 || c2 == FIXED_POINT_TYPE)); 7288 7289 t1 = c_common_signed_type (t1); 7290 t2 = c_common_signed_type (t2); 7291 /* Equality works here because c_common_signed_type uses 7292 TYPE_MAIN_VARIANT. */ 7293 if (t1 == t2) 7294 return true; 7295 if (opaque && c1 == c2 7296 && (c1 == INTEGER_TYPE || c1 == REAL_TYPE) 7297 && TYPE_PRECISION (t1) == TYPE_PRECISION (t2)) 7298 return true; 7299 return false; 7300 } 7301 7302 /* Check for missing format attributes on function pointers. LTYPE is 7303 the new type or left-hand side type. RTYPE is the old type or 7304 right-hand side type. Returns TRUE if LTYPE is missing the desired 7305 attribute. */ 7306 7307 bool 7308 check_missing_format_attribute (tree ltype, tree rtype) 7309 { 7310 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype); 7311 tree ra; 7312 7313 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra)) 7314 if (is_attribute_p ("format", TREE_PURPOSE (ra))) 7315 break; 7316 if (ra) 7317 { 7318 tree la; 7319 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la)) 7320 if (is_attribute_p ("format", TREE_PURPOSE (la))) 7321 break; 7322 return !la; 7323 } 7324 else 7325 return false; 7326 } 7327 7328 /* Setup a TYPE_DECL node as a typedef representation. 7329 7330 X is a TYPE_DECL for a typedef statement. Create a brand new 7331 ..._TYPE node (which will be just a variant of the existing 7332 ..._TYPE node with identical properties) and then install X 7333 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node. 7334 7335 The whole point here is to end up with a situation where each 7336 and every ..._TYPE node the compiler creates will be uniquely 7337 associated with AT MOST one node representing a typedef name. 7338 This way, even though the compiler substitutes corresponding 7339 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very 7340 early on, later parts of the compiler can always do the reverse 7341 translation and get back the corresponding typedef name. For 7342 example, given: 7343 7344 typedef struct S MY_TYPE; 7345 MY_TYPE object; 7346 7347 Later parts of the compiler might only know that `object' was of 7348 type `struct S' if it were not for code just below. With this 7349 code however, later parts of the compiler see something like: 7350 7351 struct S' == struct S 7352 typedef struct S' MY_TYPE; 7353 struct S' object; 7354 7355 And they can then deduce (from the node for type struct S') that 7356 the original object declaration was: 7357 7358 MY_TYPE object; 7359 7360 Being able to do this is important for proper support of protoize, 7361 and also for generating precise symbolic debugging information 7362 which takes full account of the programmer's (typedef) vocabulary. 7363 7364 Obviously, we don't want to generate a duplicate ..._TYPE node if 7365 the TYPE_DECL node that we are now processing really represents a 7366 standard built-in type. */ 7367 7368 void 7369 set_underlying_type (tree x) 7370 { 7371 if (x == error_mark_node) 7372 return; 7373 if (DECL_IS_BUILTIN (x) && TREE_CODE (TREE_TYPE (x)) != ARRAY_TYPE) 7374 { 7375 if (TYPE_NAME (TREE_TYPE (x)) == 0) 7376 TYPE_NAME (TREE_TYPE (x)) = x; 7377 } 7378 else if (TREE_TYPE (x) != error_mark_node 7379 && DECL_ORIGINAL_TYPE (x) == NULL_TREE) 7380 { 7381 tree tt = TREE_TYPE (x); 7382 DECL_ORIGINAL_TYPE (x) = tt; 7383 tt = build_variant_type_copy (tt); 7384 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x)); 7385 TYPE_NAME (tt) = x; 7386 7387 /* Mark the type as used only when its type decl is decorated 7388 with attribute unused. */ 7389 if (lookup_attribute ("unused", DECL_ATTRIBUTES (x))) 7390 TREE_USED (tt) = 1; 7391 7392 TREE_TYPE (x) = tt; 7393 } 7394 } 7395 7396 /* Record the types used by the current global variable declaration 7397 being parsed, so that we can decide later to emit their debug info. 7398 Those types are in types_used_by_cur_var_decl, and we are going to 7399 store them in the types_used_by_vars_hash hash table. 7400 DECL is the declaration of the global variable that has been parsed. */ 7401 7402 void 7403 record_types_used_by_current_var_decl (tree decl) 7404 { 7405 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl)); 7406 7407 while (types_used_by_cur_var_decl && !types_used_by_cur_var_decl->is_empty ()) 7408 { 7409 tree type = types_used_by_cur_var_decl->pop (); 7410 types_used_by_var_decl_insert (type, decl); 7411 } 7412 } 7413 7414 /* The C and C++ parsers both use vectors to hold function arguments. 7415 For efficiency, we keep a cache of unused vectors. This is the 7416 cache. */ 7417 7418 typedef vec<tree, va_gc> *tree_gc_vec; 7419 static GTY((deletable)) vec<tree_gc_vec, va_gc> *tree_vector_cache; 7420 7421 /* Return a new vector from the cache. If the cache is empty, 7422 allocate a new vector. These vectors are GC'ed, so it is OK if the 7423 pointer is not released.. */ 7424 7425 vec<tree, va_gc> * 7426 make_tree_vector (void) 7427 { 7428 if (tree_vector_cache && !tree_vector_cache->is_empty ()) 7429 return tree_vector_cache->pop (); 7430 else 7431 { 7432 /* Passing 0 to vec::alloc returns NULL, and our callers require 7433 that we always return a non-NULL value. The vector code uses 7434 4 when growing a NULL vector, so we do too. */ 7435 vec<tree, va_gc> *v; 7436 vec_alloc (v, 4); 7437 return v; 7438 } 7439 } 7440 7441 /* Release a vector of trees back to the cache. */ 7442 7443 void 7444 release_tree_vector (vec<tree, va_gc> *vec) 7445 { 7446 if (vec != NULL) 7447 { 7448 vec->truncate (0); 7449 vec_safe_push (tree_vector_cache, vec); 7450 } 7451 } 7452 7453 /* Get a new tree vector holding a single tree. */ 7454 7455 vec<tree, va_gc> * 7456 make_tree_vector_single (tree t) 7457 { 7458 vec<tree, va_gc> *ret = make_tree_vector (); 7459 ret->quick_push (t); 7460 return ret; 7461 } 7462 7463 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */ 7464 7465 vec<tree, va_gc> * 7466 make_tree_vector_from_list (tree list) 7467 { 7468 vec<tree, va_gc> *ret = make_tree_vector (); 7469 for (; list; list = TREE_CHAIN (list)) 7470 vec_safe_push (ret, TREE_VALUE (list)); 7471 return ret; 7472 } 7473 7474 /* Get a new tree vector of the values of a CONSTRUCTOR. */ 7475 7476 vec<tree, va_gc> * 7477 make_tree_vector_from_ctor (tree ctor) 7478 { 7479 vec<tree,va_gc> *ret = make_tree_vector (); 7480 vec_safe_reserve (ret, CONSTRUCTOR_NELTS (ctor)); 7481 for (unsigned i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i) 7482 ret->quick_push (CONSTRUCTOR_ELT (ctor, i)->value); 7483 return ret; 7484 } 7485 7486 /* Get a new tree vector which is a copy of an existing one. */ 7487 7488 vec<tree, va_gc> * 7489 make_tree_vector_copy (const vec<tree, va_gc> *orig) 7490 { 7491 vec<tree, va_gc> *ret; 7492 unsigned int ix; 7493 tree t; 7494 7495 ret = make_tree_vector (); 7496 vec_safe_reserve (ret, vec_safe_length (orig)); 7497 FOR_EACH_VEC_SAFE_ELT (orig, ix, t) 7498 ret->quick_push (t); 7499 return ret; 7500 } 7501 7502 /* Return true if KEYWORD starts a type specifier. */ 7503 7504 bool 7505 keyword_begins_type_specifier (enum rid keyword) 7506 { 7507 switch (keyword) 7508 { 7509 case RID_AUTO_TYPE: 7510 case RID_INT: 7511 case RID_CHAR: 7512 case RID_FLOAT: 7513 case RID_DOUBLE: 7514 case RID_VOID: 7515 case RID_UNSIGNED: 7516 case RID_LONG: 7517 case RID_SHORT: 7518 case RID_SIGNED: 7519 CASE_RID_FLOATN_NX: 7520 case RID_DFLOAT32: 7521 case RID_DFLOAT64: 7522 case RID_DFLOAT128: 7523 case RID_FRACT: 7524 case RID_ACCUM: 7525 case RID_BOOL: 7526 case RID_WCHAR: 7527 case RID_CHAR16: 7528 case RID_CHAR32: 7529 case RID_SAT: 7530 case RID_COMPLEX: 7531 case RID_TYPEOF: 7532 case RID_STRUCT: 7533 case RID_CLASS: 7534 case RID_UNION: 7535 case RID_ENUM: 7536 return true; 7537 default: 7538 if (keyword >= RID_FIRST_INT_N 7539 && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS 7540 && int_n_enabled_p[keyword-RID_FIRST_INT_N]) 7541 return true; 7542 return false; 7543 } 7544 } 7545 7546 /* Return true if KEYWORD names a type qualifier. */ 7547 7548 bool 7549 keyword_is_type_qualifier (enum rid keyword) 7550 { 7551 switch (keyword) 7552 { 7553 case RID_CONST: 7554 case RID_VOLATILE: 7555 case RID_RESTRICT: 7556 case RID_ATOMIC: 7557 return true; 7558 default: 7559 return false; 7560 } 7561 } 7562 7563 /* Return true if KEYWORD names a storage class specifier. 7564 7565 RID_TYPEDEF is not included in this list despite `typedef' being 7566 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as 7567 such for syntactic convenience only. */ 7568 7569 bool 7570 keyword_is_storage_class_specifier (enum rid keyword) 7571 { 7572 switch (keyword) 7573 { 7574 case RID_STATIC: 7575 case RID_EXTERN: 7576 case RID_REGISTER: 7577 case RID_AUTO: 7578 case RID_MUTABLE: 7579 case RID_THREAD: 7580 return true; 7581 default: 7582 return false; 7583 } 7584 } 7585 7586 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */ 7587 7588 static bool 7589 keyword_is_function_specifier (enum rid keyword) 7590 { 7591 switch (keyword) 7592 { 7593 case RID_INLINE: 7594 case RID_NORETURN: 7595 case RID_VIRTUAL: 7596 case RID_EXPLICIT: 7597 return true; 7598 default: 7599 return false; 7600 } 7601 } 7602 7603 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a 7604 declaration-specifier (C99 6.7). */ 7605 7606 bool 7607 keyword_is_decl_specifier (enum rid keyword) 7608 { 7609 if (keyword_is_storage_class_specifier (keyword) 7610 || keyword_is_type_qualifier (keyword) 7611 || keyword_is_function_specifier (keyword)) 7612 return true; 7613 7614 switch (keyword) 7615 { 7616 case RID_TYPEDEF: 7617 case RID_FRIEND: 7618 case RID_CONSTEXPR: 7619 return true; 7620 default: 7621 return false; 7622 } 7623 } 7624 7625 /* Initialize language-specific-bits of tree_contains_struct. */ 7626 7627 void 7628 c_common_init_ts (void) 7629 { 7630 MARK_TS_TYPED (C_MAYBE_CONST_EXPR); 7631 MARK_TS_TYPED (EXCESS_PRECISION_EXPR); 7632 } 7633 7634 /* Build a user-defined numeric literal out of an integer constant type VALUE 7635 with identifier SUFFIX. */ 7636 7637 tree 7638 build_userdef_literal (tree suffix_id, tree value, 7639 enum overflow_type overflow, tree num_string) 7640 { 7641 tree literal = make_node (USERDEF_LITERAL); 7642 USERDEF_LITERAL_SUFFIX_ID (literal) = suffix_id; 7643 USERDEF_LITERAL_VALUE (literal) = value; 7644 USERDEF_LITERAL_OVERFLOW (literal) = overflow; 7645 USERDEF_LITERAL_NUM_STRING (literal) = num_string; 7646 return literal; 7647 } 7648 7649 /* For vector[index], convert the vector to an array of the underlying type. 7650 Return true if the resulting ARRAY_REF should not be an lvalue. */ 7651 7652 bool 7653 convert_vector_to_array_for_subscript (location_t loc, 7654 tree *vecp, tree index) 7655 { 7656 bool ret = false; 7657 if (VECTOR_TYPE_P (TREE_TYPE (*vecp))) 7658 { 7659 tree type = TREE_TYPE (*vecp); 7660 7661 ret = !lvalue_p (*vecp); 7662 7663 if (TREE_CODE (index) == INTEGER_CST) 7664 if (!tree_fits_uhwi_p (index) 7665 || maybe_ge (tree_to_uhwi (index), TYPE_VECTOR_SUBPARTS (type))) 7666 warning_at (loc, OPT_Warray_bounds, "index value is out of bound"); 7667 7668 /* We are building an ARRAY_REF so mark the vector as addressable 7669 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P 7670 for function parameters. */ 7671 c_common_mark_addressable_vec (*vecp); 7672 7673 *vecp = build1 (VIEW_CONVERT_EXPR, 7674 build_array_type_nelts (TREE_TYPE (type), 7675 TYPE_VECTOR_SUBPARTS (type)), 7676 *vecp); 7677 } 7678 return ret; 7679 } 7680 7681 /* Determine which of the operands, if any, is a scalar that needs to be 7682 converted to a vector, for the range of operations. */ 7683 enum stv_conv 7684 scalar_to_vector (location_t loc, enum tree_code code, tree op0, tree op1, 7685 bool complain) 7686 { 7687 tree type0 = TREE_TYPE (op0); 7688 tree type1 = TREE_TYPE (op1); 7689 bool integer_only_op = false; 7690 enum stv_conv ret = stv_firstarg; 7691 7692 gcc_assert (VECTOR_TYPE_P (type0) || VECTOR_TYPE_P (type1)); 7693 switch (code) 7694 { 7695 /* Most GENERIC binary expressions require homogeneous arguments. 7696 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first 7697 argument that is a vector and a second one that is a scalar, so 7698 we never return stv_secondarg for them. */ 7699 case RSHIFT_EXPR: 7700 case LSHIFT_EXPR: 7701 if (TREE_CODE (type0) == INTEGER_TYPE 7702 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE) 7703 { 7704 if (unsafe_conversion_p (loc, TREE_TYPE (type1), op0, 7705 NULL_TREE, false)) 7706 { 7707 if (complain) 7708 error_at (loc, "conversion of scalar %qT to vector %qT " 7709 "involves truncation", type0, type1); 7710 return stv_error; 7711 } 7712 else 7713 return stv_firstarg; 7714 } 7715 break; 7716 7717 case BIT_IOR_EXPR: 7718 case BIT_XOR_EXPR: 7719 case BIT_AND_EXPR: 7720 integer_only_op = true; 7721 /* fall through */ 7722 7723 case VEC_COND_EXPR: 7724 7725 case PLUS_EXPR: 7726 case MINUS_EXPR: 7727 case MULT_EXPR: 7728 case TRUNC_DIV_EXPR: 7729 case CEIL_DIV_EXPR: 7730 case FLOOR_DIV_EXPR: 7731 case ROUND_DIV_EXPR: 7732 case EXACT_DIV_EXPR: 7733 case TRUNC_MOD_EXPR: 7734 case FLOOR_MOD_EXPR: 7735 case RDIV_EXPR: 7736 case EQ_EXPR: 7737 case NE_EXPR: 7738 case LE_EXPR: 7739 case GE_EXPR: 7740 case LT_EXPR: 7741 case GT_EXPR: 7742 /* What about UNLT_EXPR? */ 7743 if (VECTOR_TYPE_P (type0)) 7744 { 7745 ret = stv_secondarg; 7746 std::swap (type0, type1); 7747 std::swap (op0, op1); 7748 } 7749 7750 if (TREE_CODE (type0) == INTEGER_TYPE 7751 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE) 7752 { 7753 if (unsafe_conversion_p (loc, TREE_TYPE (type1), op0, 7754 NULL_TREE, false)) 7755 { 7756 if (complain) 7757 error_at (loc, "conversion of scalar %qT to vector %qT " 7758 "involves truncation", type0, type1); 7759 return stv_error; 7760 } 7761 return ret; 7762 } 7763 else if (!integer_only_op 7764 /* Allow integer --> real conversion if safe. */ 7765 && (TREE_CODE (type0) == REAL_TYPE 7766 || TREE_CODE (type0) == INTEGER_TYPE) 7767 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1))) 7768 { 7769 if (unsafe_conversion_p (loc, TREE_TYPE (type1), op0, 7770 NULL_TREE, false)) 7771 { 7772 if (complain) 7773 error_at (loc, "conversion of scalar %qT to vector %qT " 7774 "involves truncation", type0, type1); 7775 return stv_error; 7776 } 7777 return ret; 7778 } 7779 default: 7780 break; 7781 } 7782 7783 return stv_nothing; 7784 } 7785 7786 /* Return the alignment of std::max_align_t. 7787 7788 [support.types.layout] The type max_align_t is a POD type whose alignment 7789 requirement is at least as great as that of every scalar type, and whose 7790 alignment requirement is supported in every context. */ 7791 7792 unsigned 7793 max_align_t_align () 7794 { 7795 unsigned int max_align = MAX (TYPE_ALIGN (long_long_integer_type_node), 7796 TYPE_ALIGN (long_double_type_node)); 7797 if (float128_type_node != NULL_TREE) 7798 max_align = MAX (max_align, TYPE_ALIGN (float128_type_node)); 7799 return max_align; 7800 } 7801 7802 /* Return true iff ALIGN is an integral constant that is a fundamental 7803 alignment, as defined by [basic.align] in the c++-11 7804 specifications. 7805 7806 That is: 7807 7808 [A fundamental alignment is represented by an alignment less than or 7809 equal to the greatest alignment supported by the implementation 7810 in all contexts, which is equal to alignof(max_align_t)]. */ 7811 7812 bool 7813 cxx_fundamental_alignment_p (unsigned align) 7814 { 7815 return (align <= max_align_t_align ()); 7816 } 7817 7818 /* Return true if T is a pointer to a zero-sized aggregate. */ 7819 7820 bool 7821 pointer_to_zero_sized_aggr_p (tree t) 7822 { 7823 if (!POINTER_TYPE_P (t)) 7824 return false; 7825 t = TREE_TYPE (t); 7826 return (TYPE_SIZE (t) && integer_zerop (TYPE_SIZE (t))); 7827 } 7828 7829 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function 7830 with no library fallback or for an ADDR_EXPR whose operand is such type 7831 issues an error pointing to the location LOC. 7832 Returns true when the expression has been diagnosed and false 7833 otherwise. */ 7834 7835 bool 7836 reject_gcc_builtin (const_tree expr, location_t loc /* = UNKNOWN_LOCATION */) 7837 { 7838 if (TREE_CODE (expr) == ADDR_EXPR) 7839 expr = TREE_OPERAND (expr, 0); 7840 7841 STRIP_ANY_LOCATION_WRAPPER (expr); 7842 7843 if (TREE_TYPE (expr) 7844 && TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE 7845 && TREE_CODE (expr) == FUNCTION_DECL 7846 /* The intersection of DECL_BUILT_IN and DECL_IS_BUILTIN avoids 7847 false positives for user-declared built-ins such as abs or 7848 strlen, and for C++ operators new and delete. 7849 The c_decl_implicit() test avoids false positives for implicitly 7850 declared built-ins with library fallbacks (such as abs). */ 7851 && DECL_BUILT_IN (expr) 7852 && DECL_IS_BUILTIN (expr) 7853 && !c_decl_implicit (expr) 7854 && !DECL_ASSEMBLER_NAME_SET_P (expr)) 7855 { 7856 if (loc == UNKNOWN_LOCATION) 7857 loc = EXPR_LOC_OR_LOC (expr, input_location); 7858 7859 /* Reject arguments that are built-in functions with 7860 no library fallback. */ 7861 error_at (loc, "built-in function %qE must be directly called", expr); 7862 7863 return true; 7864 } 7865 7866 return false; 7867 } 7868 7869 /* Check if array size calculations overflow or if the array covers more 7870 than half of the address space. Return true if the size of the array 7871 is valid, false otherwise. TYPE is the type of the array and NAME is 7872 the name of the array, or NULL_TREE for unnamed arrays. */ 7873 7874 bool 7875 valid_array_size_p (location_t loc, tree type, tree name) 7876 { 7877 if (type != error_mark_node 7878 && COMPLETE_TYPE_P (type) 7879 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST 7880 && !valid_constant_size_p (TYPE_SIZE_UNIT (type))) 7881 { 7882 if (name) 7883 error_at (loc, "size of array %qE is too large", name); 7884 else 7885 error_at (loc, "size of unnamed array is too large"); 7886 return false; 7887 } 7888 return true; 7889 } 7890 7891 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic 7892 timestamp to replace embedded current dates to get reproducible 7893 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */ 7894 7895 time_t 7896 cb_get_source_date_epoch (cpp_reader *pfile ATTRIBUTE_UNUSED) 7897 { 7898 char *source_date_epoch; 7899 int64_t epoch; 7900 char *endptr; 7901 7902 source_date_epoch = getenv ("SOURCE_DATE_EPOCH"); 7903 if (!source_date_epoch) 7904 return (time_t) -1; 7905 7906 errno = 0; 7907 #if defined(INT64_T_IS_LONG) 7908 epoch = strtol (source_date_epoch, &endptr, 10); 7909 #else 7910 epoch = strtoll (source_date_epoch, &endptr, 10); 7911 #endif 7912 if (errno != 0 || endptr == source_date_epoch || *endptr != '\0' 7913 || epoch < 0 || epoch > MAX_SOURCE_DATE_EPOCH) 7914 { 7915 error_at (input_location, "environment variable SOURCE_DATE_EPOCH must " 7916 "expand to a non-negative integer less than or equal to %wd", 7917 MAX_SOURCE_DATE_EPOCH); 7918 return (time_t) -1; 7919 } 7920 7921 return (time_t) epoch; 7922 } 7923 7924 /* Callback for libcpp for offering spelling suggestions for misspelled 7925 directives. GOAL is an unrecognized string; CANDIDATES is a 7926 NULL-terminated array of candidate strings. Return the closest 7927 match to GOAL within CANDIDATES, or NULL if none are good 7928 suggestions. */ 7929 7930 const char * 7931 cb_get_suggestion (cpp_reader *, const char *goal, 7932 const char *const *candidates) 7933 { 7934 best_match<const char *, const char *> bm (goal); 7935 while (*candidates) 7936 bm.consider (*candidates++); 7937 return bm.get_best_meaningful_candidate (); 7938 } 7939 7940 /* Return the latice point which is the wider of the two FLT_EVAL_METHOD 7941 modes X, Y. This isn't just >, as the FLT_EVAL_METHOD values added 7942 by C TS 18661-3 for interchange types that are computed in their 7943 native precision are larger than the C11 values for evaluating in the 7944 precision of float/double/long double. If either mode is 7945 FLT_EVAL_METHOD_UNPREDICTABLE, return that. */ 7946 7947 enum flt_eval_method 7948 excess_precision_mode_join (enum flt_eval_method x, 7949 enum flt_eval_method y) 7950 { 7951 if (x == FLT_EVAL_METHOD_UNPREDICTABLE 7952 || y == FLT_EVAL_METHOD_UNPREDICTABLE) 7953 return FLT_EVAL_METHOD_UNPREDICTABLE; 7954 7955 /* GCC only supports one interchange type right now, _Float16. If 7956 we're evaluating _Float16 in 16-bit precision, then flt_eval_method 7957 will be FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */ 7958 if (x == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16) 7959 return y; 7960 if (y == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16) 7961 return x; 7962 7963 /* Other values for flt_eval_method are directly comparable, and we want 7964 the maximum. */ 7965 return MAX (x, y); 7966 } 7967 7968 /* Return the value that should be set for FLT_EVAL_METHOD in the 7969 context of ISO/IEC TS 18861-3. 7970 7971 This relates to the effective excess precision seen by the user, 7972 which is the join point of the precision the target requests for 7973 -fexcess-precision={standard,fast} and the implicit excess precision 7974 the target uses. */ 7975 7976 static enum flt_eval_method 7977 c_ts18661_flt_eval_method (void) 7978 { 7979 enum flt_eval_method implicit 7980 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT); 7981 7982 enum excess_precision_type flag_type 7983 = (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD 7984 ? EXCESS_PRECISION_TYPE_STANDARD 7985 : EXCESS_PRECISION_TYPE_FAST); 7986 7987 enum flt_eval_method requested 7988 = targetm.c.excess_precision (flag_type); 7989 7990 return excess_precision_mode_join (implicit, requested); 7991 } 7992 7993 /* As c_cpp_ts18661_flt_eval_method, but clamps the expected values to 7994 those that were permitted by C11. That is to say, eliminates 7995 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */ 7996 7997 static enum flt_eval_method 7998 c_c11_flt_eval_method (void) 7999 { 8000 return excess_precision_mode_join (c_ts18661_flt_eval_method (), 8001 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT); 8002 } 8003 8004 /* Return the value that should be set for FLT_EVAL_METHOD. 8005 MAYBE_C11_ONLY_P is TRUE if we should check 8006 FLAG_PERMITTED_EVAL_METHODS as to whether we should limit the possible 8007 values we can return to those from C99/C11, and FALSE otherwise. 8008 See the comments on c_ts18661_flt_eval_method for what value we choose 8009 to set here. */ 8010 8011 int 8012 c_flt_eval_method (bool maybe_c11_only_p) 8013 { 8014 if (maybe_c11_only_p 8015 && flag_permitted_flt_eval_methods 8016 == PERMITTED_FLT_EVAL_METHODS_C11) 8017 return c_c11_flt_eval_method (); 8018 else 8019 return c_ts18661_flt_eval_method (); 8020 } 8021 8022 /* An enum for get_missing_token_insertion_kind for describing the best 8023 place to insert a missing token, if there is one. */ 8024 8025 enum missing_token_insertion_kind 8026 { 8027 MTIK_IMPOSSIBLE, 8028 MTIK_INSERT_BEFORE_NEXT, 8029 MTIK_INSERT_AFTER_PREV 8030 }; 8031 8032 /* Given a missing token of TYPE, determine if it is reasonable to 8033 emit a fix-it hint suggesting the insertion of the token, and, 8034 if so, where the token should be inserted relative to other tokens. 8035 8036 It only makes sense to do this for values of TYPE that are symbols. 8037 8038 Some symbols should go before the next token, e.g. in: 8039 if flag) 8040 we want to insert the missing '(' immediately before "flag", 8041 giving: 8042 if (flag) 8043 rather than: 8044 if( flag) 8045 These use MTIK_INSERT_BEFORE_NEXT. 8046 8047 Other symbols should go after the previous token, e.g. in: 8048 if (flag 8049 do_something (); 8050 we want to insert the missing ')' immediately after the "flag", 8051 giving: 8052 if (flag) 8053 do_something (); 8054 rather than: 8055 if (flag 8056 )do_something (); 8057 These use MTIK_INSERT_AFTER_PREV. */ 8058 8059 static enum missing_token_insertion_kind 8060 get_missing_token_insertion_kind (enum cpp_ttype type) 8061 { 8062 switch (type) 8063 { 8064 /* Insert missing "opening" brackets immediately 8065 before the next token. */ 8066 case CPP_OPEN_SQUARE: 8067 case CPP_OPEN_PAREN: 8068 return MTIK_INSERT_BEFORE_NEXT; 8069 8070 /* Insert other missing symbols immediately after 8071 the previous token. */ 8072 case CPP_CLOSE_PAREN: 8073 case CPP_CLOSE_SQUARE: 8074 case CPP_SEMICOLON: 8075 case CPP_COMMA: 8076 case CPP_COLON: 8077 return MTIK_INSERT_AFTER_PREV; 8078 8079 /* Other kinds of token don't get fix-it hints. */ 8080 default: 8081 return MTIK_IMPOSSIBLE; 8082 } 8083 } 8084 8085 /* Given RICHLOC, a location for a diagnostic describing a missing token 8086 of kind TOKEN_TYPE, potentially add a fix-it hint suggesting the 8087 insertion of the token. 8088 8089 The location of the attempted fix-it hint depends on TOKEN_TYPE: 8090 it will either be: 8091 (a) immediately after PREV_TOKEN_LOC, or 8092 8093 (b) immediately before the primary location within RICHLOC (taken to 8094 be that of the token following where the token was expected). 8095 8096 If we manage to add a fix-it hint, then the location of the 8097 fix-it hint is likely to be more useful as the primary location 8098 of the diagnostic than that of the following token, so we swap 8099 these locations. 8100 8101 For example, given this bogus code: 8102 123456789012345678901234567890 8103 1 | int missing_semicolon (void) 8104 2 | { 8105 3 | return 42 8106 4 | } 8107 8108 we will emit: 8109 8110 "expected ';' before '}'" 8111 8112 RICHLOC's primary location is at the closing brace, so before "swapping" 8113 we would emit the error at line 4 column 1: 8114 8115 123456789012345678901234567890 8116 3 | return 42 |< fix-it hint emitted for this line 8117 | ; | 8118 4 | } |< "expected ';' before '}'" emitted at this line 8119 | ^ | 8120 8121 It's more useful for the location of the diagnostic to be at the 8122 fix-it hint, so we swap the locations, so the primary location 8123 is at the fix-it hint, with the old primary location inserted 8124 as a secondary location, giving this, with the error at line 3 8125 column 12: 8126 8127 123456789012345678901234567890 8128 3 | return 42 |< "expected ';' before '}'" emitted at this line, 8129 | ^ | with fix-it hint 8130 4 | ; | 8131 | } |< secondary range emitted here 8132 | ~ |. */ 8133 8134 void 8135 maybe_suggest_missing_token_insertion (rich_location *richloc, 8136 enum cpp_ttype token_type, 8137 location_t prev_token_loc) 8138 { 8139 gcc_assert (richloc); 8140 8141 enum missing_token_insertion_kind mtik 8142 = get_missing_token_insertion_kind (token_type); 8143 8144 switch (mtik) 8145 { 8146 default: 8147 gcc_unreachable (); 8148 break; 8149 8150 case MTIK_IMPOSSIBLE: 8151 return; 8152 8153 case MTIK_INSERT_BEFORE_NEXT: 8154 /* Attempt to add the fix-it hint before the primary location 8155 of RICHLOC. */ 8156 richloc->add_fixit_insert_before (cpp_type2name (token_type, 0)); 8157 break; 8158 8159 case MTIK_INSERT_AFTER_PREV: 8160 /* Attempt to add the fix-it hint after PREV_TOKEN_LOC. */ 8161 richloc->add_fixit_insert_after (prev_token_loc, 8162 cpp_type2name (token_type, 0)); 8163 break; 8164 } 8165 8166 /* If we were successful, use the fix-it hint's location as the 8167 primary location within RICHLOC, adding the old primary location 8168 back as a secondary location. */ 8169 if (!richloc->seen_impossible_fixit_p ()) 8170 { 8171 fixit_hint *hint = richloc->get_last_fixit_hint (); 8172 location_t hint_loc = hint->get_start_loc (); 8173 location_t old_loc = richloc->get_loc (); 8174 8175 richloc->set_range (line_table, 0, hint_loc, true); 8176 richloc->add_range (old_loc, false); 8177 } 8178 } 8179 8180 #if CHECKING_P 8181 8182 namespace selftest { 8183 8184 /* Verify that fold_for_warn on error_mark_node is safe. */ 8185 8186 static void 8187 test_fold_for_warn () 8188 { 8189 ASSERT_EQ (error_mark_node, fold_for_warn (error_mark_node)); 8190 } 8191 8192 /* Run all of the selftests within this file. */ 8193 8194 static void 8195 c_common_c_tests () 8196 { 8197 test_fold_for_warn (); 8198 } 8199 8200 /* Run all of the tests within c-family. */ 8201 8202 void 8203 c_family_tests (void) 8204 { 8205 c_common_c_tests (); 8206 c_format_c_tests (); 8207 c_pretty_print_c_tests (); 8208 c_spellcheck_cc_tests (); 8209 } 8210 8211 } // namespace selftest 8212 8213 #endif /* #if CHECKING_P */ 8214 8215 /* Attempt to locate a suitable location within FILE for a 8216 #include directive to be inserted before. FILE should 8217 be a string from libcpp (pointer equality is used). 8218 LOC is the location of the relevant diagnostic. 8219 8220 Attempt to return the location within FILE immediately 8221 after the last #include within that file, or the start of 8222 that file if it has no #include directives. 8223 8224 Return UNKNOWN_LOCATION if no suitable location is found, 8225 or if an error occurs. */ 8226 8227 static location_t 8228 try_to_locate_new_include_insertion_point (const char *file, location_t loc) 8229 { 8230 /* Locate the last ordinary map within FILE that ended with a #include. */ 8231 const line_map_ordinary *last_include_ord_map = NULL; 8232 8233 /* ...and the next ordinary map within FILE after that one. */ 8234 const line_map_ordinary *last_ord_map_after_include = NULL; 8235 8236 /* ...and the first ordinary map within FILE. */ 8237 const line_map_ordinary *first_ord_map_in_file = NULL; 8238 8239 /* Get ordinary map containing LOC (or its expansion). */ 8240 const line_map_ordinary *ord_map_for_loc = NULL; 8241 loc = linemap_resolve_location (line_table, loc, LRK_MACRO_EXPANSION_POINT, 8242 &ord_map_for_loc); 8243 gcc_assert (ord_map_for_loc); 8244 8245 for (unsigned int i = 0; i < LINEMAPS_ORDINARY_USED (line_table); i++) 8246 { 8247 const line_map_ordinary *ord_map 8248 = LINEMAPS_ORDINARY_MAP_AT (line_table, i); 8249 8250 const line_map_ordinary *from = INCLUDED_FROM (line_table, ord_map); 8251 if (from) 8252 if (from->to_file == file) 8253 { 8254 last_include_ord_map = from; 8255 last_ord_map_after_include = NULL; 8256 } 8257 8258 if (ord_map->to_file == file) 8259 { 8260 if (!first_ord_map_in_file) 8261 first_ord_map_in_file = ord_map; 8262 if (last_include_ord_map && !last_ord_map_after_include) 8263 last_ord_map_after_include = ord_map; 8264 } 8265 8266 /* Stop searching when reaching the ord_map containing LOC, 8267 as it makes no sense to provide fix-it hints that appear 8268 after the diagnostic in question. */ 8269 if (ord_map == ord_map_for_loc) 8270 break; 8271 } 8272 8273 /* Determine where to insert the #include. */ 8274 const line_map_ordinary *ord_map_for_insertion; 8275 8276 /* We want the next ordmap in the file after the last one that's a 8277 #include, but failing that, the start of the file. */ 8278 if (last_ord_map_after_include) 8279 ord_map_for_insertion = last_ord_map_after_include; 8280 else 8281 ord_map_for_insertion = first_ord_map_in_file; 8282 8283 if (!ord_map_for_insertion) 8284 return UNKNOWN_LOCATION; 8285 8286 /* The "start_location" is column 0, meaning "the whole line". 8287 rich_location and edit_context can't cope with this, so use 8288 column 1 instead. */ 8289 location_t col_0 = ord_map_for_insertion->start_location; 8290 return linemap_position_for_loc_and_offset (line_table, col_0, 1); 8291 } 8292 8293 /* A map from filenames to sets of headers added to them, for 8294 ensuring idempotency within maybe_add_include_fixit. */ 8295 8296 /* The values within the map. We need string comparison as there's 8297 no guarantee that two different diagnostics that are recommending 8298 adding e.g. "<stdio.h>" are using the same buffer. */ 8299 8300 typedef hash_set <const char *, nofree_string_hash> per_file_includes_t; 8301 8302 /* The map itself. We don't need string comparison for the filename keys, 8303 as they come from libcpp. */ 8304 8305 typedef hash_map <const char *, per_file_includes_t *> added_includes_t; 8306 static added_includes_t *added_includes; 8307 8308 /* Attempt to add a fix-it hint to RICHLOC, adding "#include HEADER\n" 8309 in a suitable location within the file of RICHLOC's primary 8310 location. 8311 8312 This function is idempotent: a header will be added at most once to 8313 any given file. */ 8314 8315 void 8316 maybe_add_include_fixit (rich_location *richloc, const char *header) 8317 { 8318 location_t loc = richloc->get_loc (); 8319 const char *file = LOCATION_FILE (loc); 8320 if (!file) 8321 return; 8322 8323 /* Idempotency: don't add the same header more than once to a given file. */ 8324 if (!added_includes) 8325 added_includes = new added_includes_t (); 8326 per_file_includes_t *&set = added_includes->get_or_insert (file); 8327 if (set) 8328 if (set->contains (header)) 8329 /* ...then we've already added HEADER to that file. */ 8330 return; 8331 if (!set) 8332 set = new per_file_includes_t (); 8333 set->add (header); 8334 8335 /* Attempt to locate a suitable place for the new directive. */ 8336 location_t include_insert_loc 8337 = try_to_locate_new_include_insertion_point (file, loc); 8338 if (include_insert_loc == UNKNOWN_LOCATION) 8339 return; 8340 8341 char *text = xasprintf ("#include %s\n", header); 8342 richloc->add_fixit_insert_before (include_insert_loc, text); 8343 free (text); 8344 } 8345 8346 #include "gt-c-family-c-common.h" 8347