gcc/c-common.c

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