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