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