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