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:
3076       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3077          since that affects how `default_conversion' will behave.  */
3078       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3079           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3080         break;
3081       /* If this is widening the argument, we can ignore it.  */
3082       if (TYPE_PRECISION (TREE_TYPE (expr))
3083           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3084         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3085       break;
3086
3087     case MODIFY_EXPR:
3088       if (!TREE_NO_WARNING (expr)
3089           && warn_parentheses)
3090         {
3091           warning (OPT_Wparentheses,
3092                    "suggest parentheses around assignment used as truth value");
3093           TREE_NO_WARNING (expr) = 1;
3094         }
3095       break;
3096
3097     default:
3098       break;
3099     }
3100
3101   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3102     {
3103       tree t = save_expr (expr);
3104       return (build_binary_op
3105               ((TREE_SIDE_EFFECTS (expr)
3106                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3107         c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
3108         c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
3109                0));
3110     }
3111
3112   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3113     {
3114       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3115                                           FCONST0 (TYPE_MODE
3116                                                    (TREE_TYPE (expr))));
3117       return build_binary_op (NE_EXPR, expr, fixed_zero_node, 1);
3118     }
3119
3120   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3121 }
3122 \f
3123 static void def_builtin_1  (enum built_in_function fncode,
3124                             const char *name,
3125                             enum built_in_class fnclass,
3126                             tree fntype, tree libtype,
3127                             bool both_p, bool fallback_p, bool nonansi_p,
3128                             tree fnattrs, bool implicit_p);
3129
3130
3131 /* Apply the TYPE_QUALS to the new DECL.  */
3132
3133 void
3134 c_apply_type_quals_to_decl (int type_quals, tree decl)
3135 {
3136   tree type = TREE_TYPE (decl);
3137
3138   if (type == error_mark_node)
3139     return;
3140
3141   if (((type_quals & TYPE_QUAL_CONST)
3142        || (type && TREE_CODE (type) == REFERENCE_TYPE))
3143       /* An object declared 'const' is only readonly after it is
3144          initialized.  We don't have any way of expressing this currently,
3145          so we need to be conservative and unset TREE_READONLY for types
3146          with constructors.  Otherwise aliasing code will ignore stores in
3147          an inline constructor.  */
3148       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3149     TREE_READONLY (decl) = 1;
3150   if (type_quals & TYPE_QUAL_VOLATILE)
3151     {
3152       TREE_SIDE_EFFECTS (decl) = 1;
3153       TREE_THIS_VOLATILE (decl) = 1;
3154     }
3155   if (type_quals & TYPE_QUAL_RESTRICT)
3156     {
3157       while (type && TREE_CODE (type) == ARRAY_TYPE)
3158         /* Allow 'restrict' on arrays of pointers.
3159            FIXME currently we just ignore it.  */
3160         type = TREE_TYPE (type);
3161       if (!type
3162           || !POINTER_TYPE_P (type)
3163           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3164         error ("invalid use of %<restrict%>");
3165       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3166         /* Indicate we need to make a unique alias set for this pointer.
3167            We can't do it here because it might be pointing to an
3168            incomplete type.  */
3169         DECL_POINTER_ALIAS_SET (decl) = -2;
3170     }
3171 }
3172
3173 /* Hash function for the problem of multiple type definitions in
3174    different files.  This must hash all types that will compare
3175    equal via comptypes to the same value.  In practice it hashes
3176    on some of the simple stuff and leaves the details to comptypes.  */
3177
3178 static hashval_t
3179 c_type_hash (const void *p)
3180 {
3181   int i = 0;
3182   int shift, size;
3183   const_tree const t = (const_tree) p;
3184   tree t2;
3185   switch (TREE_CODE (t))
3186     {
3187     /* For pointers, hash on pointee type plus some swizzling.  */
3188     case POINTER_TYPE:
3189       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3190     /* Hash on number of elements and total size.  */
3191     case ENUMERAL_TYPE:
3192       shift = 3;
3193       t2 = TYPE_VALUES (t);
3194       break;
3195     case RECORD_TYPE:
3196       shift = 0;
3197       t2 = TYPE_FIELDS (t);
3198       break;
3199     case QUAL_UNION_TYPE:
3200       shift = 1;
3201       t2 = TYPE_FIELDS (t);
3202       break;
3203     case UNION_TYPE:
3204       shift = 2;
3205       t2 = TYPE_FIELDS (t);
3206       break;
3207     default:
3208       gcc_unreachable ();
3209     }
3210   for (; t2; t2 = TREE_CHAIN (t2))
3211     i++;
3212   /* We might have a VLA here.  */
3213   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3214     size = 0;
3215   else
3216     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3217   return ((size << 24) | (i << shift));
3218 }
3219
3220 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3221
3222 /* Return the typed-based alias set for T, which may be an expression
3223    or a type.  Return -1 if we don't do anything special.  */
3224
3225 alias_set_type
3226 c_common_get_alias_set (tree t)
3227 {
3228   tree u;
3229   PTR *slot;
3230
3231   /* Permit type-punning when accessing a union, provided the access
3232      is directly through the union.  For example, this code does not
3233      permit taking the address of a union member and then storing
3234      through it.  Even the type-punning allowed here is a GCC
3235      extension, albeit a common and useful one; the C standard says
3236      that such accesses have implementation-defined behavior.  */
3237   for (u = t;
3238        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3239        u = TREE_OPERAND (u, 0))
3240     if (TREE_CODE (u) == COMPONENT_REF
3241         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3242       return 0;
3243
3244   /* That's all the expressions we handle specially.  */
3245   if (!TYPE_P (t))
3246     return -1;
3247
3248   /* The C standard guarantees that any object may be accessed via an
3249      lvalue that has character type.  */
3250   if (t == char_type_node
3251       || t == signed_char_type_node
3252       || t == unsigned_char_type_node)
3253     return 0;
3254
3255   /* If it has the may_alias attribute, it can alias anything.  */
3256   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3257     return 0;
3258
3259   /* The C standard specifically allows aliasing between signed and
3260      unsigned variants of the same type.  We treat the signed
3261      variant as canonical.  */
3262   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3263     {
3264       tree t1 = c_common_signed_type (t);
3265
3266       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3267       if (t1 != t)
3268         return get_alias_set (t1);
3269     }
3270   else if (POINTER_TYPE_P (t))
3271     {
3272       tree t1;
3273
3274       /* Unfortunately, there is no canonical form of a pointer type.
3275          In particular, if we have `typedef int I', then `int *', and
3276          `I *' are different types.  So, we have to pick a canonical
3277          representative.  We do this below.
3278
3279          Technically, this approach is actually more conservative that
3280          it needs to be.  In particular, `const int *' and `int *'
3281          should be in different alias sets, according to the C and C++
3282          standard, since their types are not the same, and so,
3283          technically, an `int **' and `const int **' cannot point at
3284          the same thing.
3285
3286          But, the standard is wrong.  In particular, this code is
3287          legal C++:
3288
3289             int *ip;
3290             int **ipp = &ip;
3291             const int* const* cipp = ipp;
3292
3293          And, it doesn't make sense for that to be legal unless you
3294          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3295          the pointed-to types.  This issue has been reported to the
3296          C++ committee.  */
3297       t1 = build_type_no_quals (t);
3298       if (t1 != t)
3299         return get_alias_set (t1);
3300     }
3301
3302   /* Handle the case of multiple type nodes referring to "the same" type,
3303      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
3304      C90 is handled.  (In C99 type compatibility is not transitive, which
3305      complicates things mightily. The alias set splay trees can theoretically
3306      represent this, but insertion is tricky when you consider all the
3307      different orders things might arrive in.) */
3308
3309   if (c_language != clk_c || flag_isoc99)
3310     return -1;
3311
3312   /* Save time if there's only one input file.  */
3313   if (num_in_fnames == 1)
3314     return -1;
3315
3316   /* Pointers need special handling if they point to any type that
3317      needs special handling (below).  */
3318   if (TREE_CODE (t) == POINTER_TYPE)
3319     {
3320       tree t2;
3321       /* Find bottom type under any nested POINTERs.  */
3322       for (t2 = TREE_TYPE (t);
3323            TREE_CODE (t2) == POINTER_TYPE;
3324            t2 = TREE_TYPE (t2))
3325         ;
3326       if (TREE_CODE (t2) != RECORD_TYPE
3327           && TREE_CODE (t2) != ENUMERAL_TYPE
3328           && TREE_CODE (t2) != QUAL_UNION_TYPE
3329           && TREE_CODE (t2) != UNION_TYPE)
3330         return -1;
3331       if (TYPE_SIZE (t2) == 0)
3332         return -1;
3333     }
3334   /* These are the only cases that need special handling.  */
3335   if (TREE_CODE (t) != RECORD_TYPE
3336       && TREE_CODE (t) != ENUMERAL_TYPE
3337       && TREE_CODE (t) != QUAL_UNION_TYPE
3338       && TREE_CODE (t) != UNION_TYPE
3339       && TREE_CODE (t) != POINTER_TYPE)
3340     return -1;
3341   /* Undefined? */
3342   if (TYPE_SIZE (t) == 0)
3343     return -1;
3344
3345   /* Look up t in hash table.  Only one of the compatible types within each
3346      alias set is recorded in the table.  */
3347   if (!type_hash_table)
3348     type_hash_table = htab_create_ggc (1021, c_type_hash,
3349             (htab_eq) lang_hooks.types_compatible_p,
3350             NULL);
3351   slot = htab_find_slot (type_hash_table, t, INSERT);
3352   if (*slot != NULL)
3353     {
3354       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3355       return TYPE_ALIAS_SET ((tree)*slot);
3356     }
3357   else
3358     /* Our caller will assign and record (in t) a new alias set; all we need
3359        to do is remember t in the hash table.  */
3360     *slot = t;
3361
3362   return -1;
3363 }
3364 \f
3365 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3366    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
3367    flag controls whether we should diagnose possibly ill-formed
3368    constructs or not.  */
3369
3370 tree
3371 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3372 {
3373   const char *op_name;
3374   tree value = NULL;
3375   enum tree_code type_code = TREE_CODE (type);
3376
3377   op_name = is_sizeof ? "sizeof" : "__alignof__";
3378
3379   if (type_code == FUNCTION_TYPE)
3380     {
3381       if (is_sizeof)
3382         {
3383           if (complain && (pedantic || warn_pointer_arith))
3384             pedwarn ("invalid application of %<sizeof%> to a function type");
3385           else if (!complain)
3386             return error_mark_node;
3387           value = size_one_node;
3388         }
3389       else
3390         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3391     }
3392   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3393     {
3394       if (type_code == VOID_TYPE
3395           && complain && (pedantic || warn_pointer_arith))
3396         pedwarn ("invalid application of %qs to a void type", op_name);
3397       else if (!complain)
3398         return error_mark_node;
3399       value = size_one_node;
3400     }
3401   else if (!COMPLETE_TYPE_P (type))
3402     {
3403       if (complain)
3404         error ("invalid application of %qs to incomplete type %qT ",
3405                op_name, type);
3406       value = size_zero_node;
3407     }
3408   else
3409     {
3410       if (is_sizeof)
3411         /* Convert in case a char is more than one unit.  */
3412         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3413                             size_int (TYPE_PRECISION (char_type_node)
3414                                       / BITS_PER_UNIT));
3415       else
3416         value = size_int (TYPE_ALIGN_UNIT (type));
3417     }
3418
3419   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3420      TYPE_IS_SIZETYPE means that certain things (like overflow) will
3421      never happen.  However, this node should really have type
3422      `size_t', which is just a typedef for an ordinary integer type.  */
3423   value = fold_convert (size_type_node, value);
3424   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3425
3426   return value;
3427 }
3428
3429 /* Implement the __alignof keyword: Return the minimum required
3430    alignment of EXPR, measured in bytes.  For VAR_DECLs,
3431    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3432    from an "aligned" __attribute__ specification).  */
3433
3434 tree
3435 c_alignof_expr (tree expr)
3436 {
3437   tree t;
3438
3439   if (VAR_OR_FUNCTION_DECL_P (expr))
3440     t = size_int (DECL_ALIGN_UNIT (expr));
3441
3442   else if (TREE_CODE (expr) == COMPONENT_REF
3443            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3444     {
3445       error ("%<__alignof%> applied to a bit-field");
3446       t = size_one_node;
3447     }
3448   else if (TREE_CODE (expr) == COMPONENT_REF
3449            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3450     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3451
3452   else if (TREE_CODE (expr) == INDIRECT_REF)
3453     {
3454       tree t = TREE_OPERAND (expr, 0);
3455       tree best = t;
3456       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3457
3458       while (CONVERT_EXPR_P (t)
3459              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3460         {
3461           int thisalign;
3462
3463           t = TREE_OPERAND (t, 0);
3464           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3465           if (thisalign > bestalign)
3466             best = t, bestalign = thisalign;
3467         }
3468       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3469     }
3470   else
3471     return c_alignof (TREE_TYPE (expr));
3472
3473   return fold_convert (size_type_node, t);
3474 }
3475 \f
3476 /* Handle C and C++ default attributes.  */
3477
3478 enum built_in_attribute
3479 {
3480 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3481 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3482 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3483 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3484 #include "builtin-attrs.def"
3485 #undef DEF_ATTR_NULL_TREE
3486 #undef DEF_ATTR_INT
3487 #undef DEF_ATTR_IDENT
3488 #undef DEF_ATTR_TREE_LIST
3489   ATTR_LAST
3490 };
3491
3492 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3493
3494 static void c_init_attributes (void);
3495
3496 enum c_builtin_type
3497 {
3498 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3499 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3500 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3501 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3502 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3503 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3504 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3505 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3506 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3507 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3508 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3509 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3510 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3511 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3512 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3513   NAME,
3514 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3515 #include "builtin-types.def"
3516 #undef DEF_PRIMITIVE_TYPE
3517 #undef DEF_FUNCTION_TYPE_0
3518 #undef DEF_FUNCTION_TYPE_1
3519 #undef DEF_FUNCTION_TYPE_2
3520 #undef DEF_FUNCTION_TYPE_3
3521 #undef DEF_FUNCTION_TYPE_4
3522 #undef DEF_FUNCTION_TYPE_5
3523 #undef DEF_FUNCTION_TYPE_6
3524 #undef DEF_FUNCTION_TYPE_7
3525 #undef DEF_FUNCTION_TYPE_VAR_0
3526 #undef DEF_FUNCTION_TYPE_VAR_1
3527 #undef DEF_FUNCTION_TYPE_VAR_2
3528 #undef DEF_FUNCTION_TYPE_VAR_3
3529 #undef DEF_FUNCTION_TYPE_VAR_4
3530 #undef DEF_FUNCTION_TYPE_VAR_5
3531 #undef DEF_POINTER_TYPE
3532   BT_LAST
3533 };
3534
3535 typedef enum c_builtin_type builtin_type;
3536
3537 /* A temporary array for c_common_nodes_and_builtins.  Used in
3538    communication with def_fn_type.  */
3539 static tree builtin_types[(int) BT_LAST + 1];
3540
3541 /* A helper function for c_common_nodes_and_builtins.  Build function type
3542    for DEF with return type RET and N arguments.  If VAR is true, then the
3543    function should be variadic after those N arguments.
3544
3545    Takes special care not to ICE if any of the types involved are
3546    error_mark_node, which indicates that said type is not in fact available
3547    (see builtin_type_for_size).  In which case the function type as a whole
3548    should be error_mark_node.  */
3549
3550 static void
3551 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3552 {
3553   tree args = NULL, t;
3554   va_list list;
3555   int i;
3556
3557   va_start (list, n);
3558   for (i = 0; i < n; ++i)
3559     {
3560       builtin_type a = va_arg (list, builtin_type);
3561       t = builtin_types[a];
3562       if (t == error_mark_node)
3563         goto egress;
3564       args = tree_cons (NULL_TREE, t, args);
3565     }
3566   va_end (list);
3567
3568   args = nreverse (args);
3569   if (!var)
3570     args = chainon (args, void_list_node);
3571
3572   t = builtin_types[ret];
3573   if (t == error_mark_node)
3574     goto egress;
3575   t = build_function_type (t, args);
3576
3577  egress:
3578   builtin_types[def] = t;
3579 }
3580
3581 /* Build builtin functions common to both C and C++ language
3582    frontends.  */
3583
3584 static void
3585 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3586 {
3587 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3588   builtin_types[ENUM] = VALUE;
3589 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3590   def_fn_type (ENUM, RETURN, 0, 0);
3591 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3592   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3593 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3594   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3595 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3596   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3597 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3598   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3599 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3600   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3601 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3602                             ARG6)                                       \
3603   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3604 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3605                             ARG6, ARG7)                                 \
3606   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3607 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3608   def_fn_type (ENUM, RETURN, 1, 0);
3609 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3610   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3611 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3612   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3613 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3614   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3615 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3616   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3617 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3618   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3619 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3620   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3621
3622 #include "builtin-types.def"
3623
3624 #undef DEF_PRIMITIVE_TYPE
3625 #undef DEF_FUNCTION_TYPE_1
3626 #undef DEF_FUNCTION_TYPE_2
3627 #undef DEF_FUNCTION_TYPE_3
3628 #undef DEF_FUNCTION_TYPE_4
3629 #undef DEF_FUNCTION_TYPE_5
3630 #undef DEF_FUNCTION_TYPE_6
3631 #undef DEF_FUNCTION_TYPE_VAR_0
3632 #undef DEF_FUNCTION_TYPE_VAR_1
3633 #undef DEF_FUNCTION_TYPE_VAR_2
3634 #undef DEF_FUNCTION_TYPE_VAR_3
3635 #undef DEF_FUNCTION_TYPE_VAR_4
3636 #undef DEF_FUNCTION_TYPE_VAR_5
3637 #undef DEF_POINTER_TYPE
3638   builtin_types[(int) BT_LAST] = NULL_TREE;
3639
3640   c_init_attributes ();
3641
3642 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3643                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
3644   if (NAME && COND)                                                     \
3645     def_builtin_1 (ENUM, NAME, CLASS,                                   \
3646                    builtin_types[(int) TYPE],                           \
3647                    builtin_types[(int) LIBTYPE],                        \
3648                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
3649                    built_in_attributes[(int) ATTRS], IMPLICIT);
3650 #include "builtins.def"
3651 #undef DEF_BUILTIN
3652
3653   targetm.init_builtins ();
3654
3655   build_common_builtin_nodes ();
3656
3657   if (flag_mudflap)
3658     mudflap_init ();
3659 }
3660
3661 /* Build tree nodes and builtin functions common to both C and C++ language
3662    frontends.  */
3663
3664 void
3665 c_common_nodes_and_builtins (void)
3666 {
3667   int char16_type_size;
3668   int char32_type_size;
3669   int wchar_type_size;
3670   tree array_domain_type;
3671   tree va_list_ref_type_node;
3672   tree va_list_arg_type_node;
3673
3674   /* Define `int' and `char' first so that dbx will output them first.  */
3675   record_builtin_type (RID_INT, NULL, integer_type_node);
3676   record_builtin_type (RID_CHAR, "char", char_type_node);
3677
3678   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
3679      "unsigned long", "long long unsigned" and "unsigned short" were in C++
3680      but not C.  Are the conditionals here needed?  */
3681   if (c_dialect_cxx ())
3682     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3683   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3684   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3685   record_builtin_type (RID_MAX, "long unsigned int",
3686                        long_unsigned_type_node);
3687   if (c_dialect_cxx ())
3688     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3689   record_builtin_type (RID_MAX, "long long int",
3690                        long_long_integer_type_node);
3691   record_builtin_type (RID_MAX, "long long unsigned int",
3692                        long_long_unsigned_type_node);
3693   if (c_dialect_cxx ())
3694     record_builtin_type (RID_MAX, "long long unsigned",
3695                          long_long_unsigned_type_node);
3696   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3697   record_builtin_type (RID_MAX, "short unsigned int",
3698                        short_unsigned_type_node);
3699   if (c_dialect_cxx ())
3700     record_builtin_type (RID_MAX, "unsigned short",
3701                          short_unsigned_type_node);
3702
3703   /* Define both `signed char' and `unsigned char'.  */
3704   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3705   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3706
3707   /* These are types that c_common_type_for_size and
3708      c_common_type_for_mode use.  */
3709   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3710                                          intQI_type_node));
3711   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3712                                          intHI_type_node));
3713   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3714                                          intSI_type_node));
3715   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3716                                          intDI_type_node));
3717 #if HOST_BITS_PER_WIDE_INT >= 64
3718   if (targetm.scalar_mode_supported_p (TImode))
3719     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3720                                            get_identifier ("__int128_t"),
3721                                            intTI_type_node));
3722 #endif
3723   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3724                                          unsigned_intQI_type_node));
3725   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3726                                          unsigned_intHI_type_node));
3727   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3728                                          unsigned_intSI_type_node));
3729   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3730                                          unsigned_intDI_type_node));
3731 #if HOST_BITS_PER_WIDE_INT >= 64
3732   if (targetm.scalar_mode_supported_p (TImode))
3733     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3734                                            get_identifier ("__uint128_t"),
3735                                            unsigned_intTI_type_node));
3736 #endif
3737
3738   /* Create the widest literal types.  */
3739   widest_integer_literal_type_node
3740     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3741   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3742                                          widest_integer_literal_type_node));
3743
3744   widest_unsigned_literal_type_node
3745     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3746   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3747                                          widest_unsigned_literal_type_node));
3748
3749   /* `unsigned long' is the standard type for sizeof.
3750      Note that stddef.h uses `unsigned long',
3751      and this must agree, even if long and int are the same size.  */
3752   size_type_node =
3753     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3754   signed_size_type_node = c_common_signed_type (size_type_node);
3755   set_sizetype (size_type_node);
3756
3757   pid_type_node =
3758     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3759
3760   build_common_tree_nodes_2 (flag_short_double);
3761
3762   record_builtin_type (RID_FLOAT, NULL, float_type_node);
3763   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3764   record_builtin_type (RID_MAX, "long double", long_double_type_node);
3765
3766   /* Only supported decimal floating point extension if the target
3767      actually supports underlying modes. */
3768   if (targetm.scalar_mode_supported_p (SDmode)
3769       && targetm.scalar_mode_supported_p (DDmode)
3770       && targetm.scalar_mode_supported_p (TDmode))
3771     {
3772       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3773       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3774       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3775     }
3776
3777   if (targetm.fixed_point_supported_p ())
3778     {
3779       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
3780       record_builtin_type (RID_FRACT, NULL, fract_type_node);
3781       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
3782       record_builtin_type (RID_MAX, "long long _Fract",
3783                            long_long_fract_type_node);
3784       record_builtin_type (RID_MAX, "unsigned short _Fract",
3785                            unsigned_short_fract_type_node);
3786       record_builtin_type (RID_MAX, "unsigned _Fract",
3787                            unsigned_fract_type_node);
3788       record_builtin_type (RID_MAX, "unsigned long _Fract",
3789                            unsigned_long_fract_type_node);
3790       record_builtin_type (RID_MAX, "unsigned long long _Fract",
3791                            unsigned_long_long_fract_type_node);
3792       record_builtin_type (RID_MAX, "_Sat short _Fract",
3793                            sat_short_fract_type_node);
3794       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
3795       record_builtin_type (RID_MAX, "_Sat long _Fract",
3796                            sat_long_fract_type_node);
3797       record_builtin_type (RID_MAX, "_Sat long long _Fract",
3798                            sat_long_long_fract_type_node);
3799       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
3800                            sat_unsigned_short_fract_type_node);
3801       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
3802                            sat_unsigned_fract_type_node);
3803       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
3804                            sat_unsigned_long_fract_type_node);
3805       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
3806                            sat_unsigned_long_long_fract_type_node);
3807       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
3808       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
3809       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
3810       record_builtin_type (RID_MAX, "long long _Accum",
3811                            long_long_accum_type_node);
3812       record_builtin_type (RID_MAX, "unsigned short _Accum",
3813                            unsigned_short_accum_type_node);
3814       record_builtin_type (RID_MAX, "unsigned _Accum",
3815                            unsigned_accum_type_node);
3816       record_builtin_type (RID_MAX, "unsigned long _Accum",
3817                            unsigned_long_accum_type_node);
3818       record_builtin_type (RID_MAX, "unsigned long long _Accum",
3819                            unsigned_long_long_accum_type_node);
3820       record_builtin_type (RID_MAX, "_Sat short _Accum",
3821                            sat_short_accum_type_node);
3822       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
3823       record_builtin_type (RID_MAX, "_Sat long _Accum",
3824                            sat_long_accum_type_node);
3825       record_builtin_type (RID_MAX, "_Sat long long _Accum",
3826                           sat_long_long_accum_type_node);
3827       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
3828                            sat_unsigned_short_accum_type_node);
3829       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
3830                            sat_unsigned_accum_type_node);
3831       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
3832                            sat_unsigned_long_accum_type_node);
3833       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
3834                            sat_unsigned_long_long_accum_type_node);
3835
3836     }
3837
3838   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3839                                          get_identifier ("complex int"),
3840                                          complex_integer_type_node));
3841   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3842                                          get_identifier ("complex float"),
3843                                          complex_float_type_node));
3844   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3845                                          get_identifier ("complex double"),
3846                                          complex_double_type_node));
3847   lang_hooks.decls.pushdecl
3848     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3849                  complex_long_double_type_node));
3850
3851   if (c_dialect_cxx ())
3852     /* For C++, make fileptr_type_node a distinct void * type until
3853        FILE type is defined.  */
3854     fileptr_type_node = build_variant_type_copy (ptr_type_node);
3855
3856   record_builtin_type (RID_VOID, NULL, void_type_node);
3857
3858   /* Set the TYPE_NAME for any variants that were built before
3859      record_builtin_type gave names to the built-in types. */
3860   {
3861     tree void_name = TYPE_NAME (void_type_node);
3862     TYPE_NAME (void_type_node) = NULL_TREE;
3863     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3864       = void_name;
3865     TYPE_NAME (void_type_node) = void_name;
3866   }
3867
3868   /* This node must not be shared.  */
3869   void_zero_node = make_node (INTEGER_CST);
3870   TREE_TYPE (void_zero_node) = void_type_node;
3871
3872   void_list_node = build_void_list_node ();
3873
3874   /* Make a type to be the domain of a few array types
3875      whose domains don't really matter.
3876      200 is small enough that it always fits in size_t
3877      and large enough that it can hold most function names for the
3878      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3879   array_domain_type = build_index_type (size_int (200));
3880
3881   /* Make a type for arrays of characters.
3882      With luck nothing will ever really depend on the length of this
3883      array type.  */
3884   char_array_type_node
3885     = build_array_type (char_type_node, array_domain_type);
3886
3887   /* Likewise for arrays of ints.  */
3888   int_array_type_node
3889     = build_array_type (integer_type_node, array_domain_type);
3890
3891   string_type_node = build_pointer_type (char_type_node);
3892   const_string_type_node
3893     = build_pointer_type (build_qualified_type
3894                           (char_type_node, TYPE_QUAL_CONST));
3895
3896   /* This is special for C++ so functions can be overloaded.  */
3897   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3898   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3899   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3900   if (c_dialect_cxx ())
3901     {
3902       if (TYPE_UNSIGNED (wchar_type_node))
3903         wchar_type_node = make_unsigned_type (wchar_type_size);
3904       else
3905         wchar_type_node = make_signed_type (wchar_type_size);
3906       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3907     }
3908   else
3909     {
3910       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3911       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3912     }
3913
3914   /* This is for wide string constants.  */
3915   wchar_array_type_node
3916     = build_array_type (wchar_type_node, array_domain_type);
3917
3918   /* Define 'char16_t'.  */
3919   char16_type_node = get_identifier (CHAR16_TYPE);
3920   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
3921   char16_type_size = TYPE_PRECISION (char16_type_node);
3922   if (c_dialect_cxx ())
3923     {
3924       char16_type_node = make_unsigned_type (char16_type_size);
3925
3926       if (cxx_dialect == cxx0x)
3927         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
3928     }
3929
3930   /* This is for UTF-16 string constants.  */
3931   char16_array_type_node
3932     = build_array_type (char16_type_node, array_domain_type);
3933
3934   /* Define 'char32_t'.  */
3935   char32_type_node = get_identifier (CHAR32_TYPE);
3936   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
3937   char32_type_size = TYPE_PRECISION (char32_type_node);
3938   if (c_dialect_cxx ())
3939     {
3940       char32_type_node = make_unsigned_type (char32_type_size);
3941
3942       if (cxx_dialect == cxx0x)
3943         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
3944     }
3945
3946   /* This is for UTF-32 string constants.  */
3947   char32_array_type_node
3948     = build_array_type (char32_type_node, array_domain_type);
3949
3950   wint_type_node =
3951     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3952
3953   intmax_type_node =
3954     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3955   uintmax_type_node =
3956     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3957
3958   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3959   ptrdiff_type_node
3960     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3961   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3962
3963   lang_hooks.decls.pushdecl
3964     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3965                  va_list_type_node));
3966
3967   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3968     {
3969       va_list_arg_type_node = va_list_ref_type_node =
3970         build_pointer_type (TREE_TYPE (va_list_type_node));
3971     }
3972   else
3973     {
3974       va_list_arg_type_node = va_list_type_node;
3975       va_list_ref_type_node = build_reference_type (va_list_type_node);
3976     }
3977
3978   if (!flag_preprocess_only)
3979     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3980
3981   main_identifier_node = get_identifier ("main");
3982
3983   /* Create the built-in __null node.  It is important that this is
3984      not shared.  */
3985   null_node = make_node (INTEGER_CST);
3986   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3987
3988   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
3989   memset (builtin_types, 0, sizeof (builtin_types));
3990 }
3991
3992 /* Look up the function in built_in_decls that corresponds to DECL
3993    and set ASMSPEC as its user assembler name.  DECL must be a
3994    function decl that declares a builtin.  */
3995
3996 void
3997 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3998 {
3999   tree builtin;
4000   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4001               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4002               && asmspec != 0);
4003
4004   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4005   set_user_assembler_name (builtin, asmspec);
4006   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
4007     init_block_move_fn (asmspec);
4008   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
4009     init_block_clear_fn (asmspec);
4010 }
4011
4012 /* The number of named compound-literals generated thus far.  */
4013 static GTY(()) int compound_literal_number;
4014
4015 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
4016
4017 void
4018 set_compound_literal_name (tree decl)
4019 {
4020   char *name;
4021   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4022                            compound_literal_number);
4023   compound_literal_number++;
4024   DECL_NAME (decl) = get_identifier (name);
4025 }
4026
4027 tree
4028 build_va_arg (tree expr, tree type)
4029 {
4030   return build1 (VA_ARG_EXPR, type, expr);
4031 }
4032
4033
4034 /* Linked list of disabled built-in functions.  */
4035
4036 typedef struct disabled_builtin
4037 {
4038   const char *name;
4039   struct disabled_builtin *next;
4040 } disabled_builtin;
4041 static disabled_builtin *disabled_builtins = NULL;
4042
4043 static bool builtin_function_disabled_p (const char *);
4044
4045 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
4046    begins with "__builtin_", give an error.  */
4047
4048 void
4049 disable_builtin_function (const char *name)
4050 {
4051   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4052     error ("cannot disable built-in function %qs", name);
4053   else
4054     {
4055       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4056       new_disabled_builtin->name = name;
4057       new_disabled_builtin->next = disabled_builtins;
4058       disabled_builtins = new_disabled_builtin;
4059     }
4060 }
4061
4062
4063 /* Return true if the built-in function NAME has been disabled, false
4064    otherwise.  */
4065
4066 static bool
4067 builtin_function_disabled_p (const char *name)
4068 {
4069   disabled_builtin *p;
4070   for (p = disabled_builtins; p != NULL; p = p->next)
4071     {
4072       if (strcmp (name, p->name) == 0)
4073         return true;
4074     }
4075   return false;
4076 }
4077
4078
4079 /* Worker for DEF_BUILTIN.
4080    Possibly define a builtin function with one or two names.
4081    Does not declare a non-__builtin_ function if flag_no_builtin, or if
4082    nonansi_p and flag_no_nonansi_builtin.  */
4083
4084 static void
4085 def_builtin_1 (enum built_in_function fncode,
4086                const char *name,
4087                enum built_in_class fnclass,
4088                tree fntype, tree libtype,
4089                bool both_p, bool fallback_p, bool nonansi_p,
4090                tree fnattrs, bool implicit_p)
4091 {
4092   tree decl;
4093   const char *libname;
4094
4095   if (fntype == error_mark_node)
4096     return;
4097
4098   gcc_assert ((!both_p && !fallback_p)
4099               || !strncmp (name, "__builtin_",
4100                            strlen ("__builtin_")));
4101
4102   libname = name + strlen ("__builtin_");
4103   decl = add_builtin_function (name, fntype, fncode, fnclass,
4104                                (fallback_p ? libname : NULL),
4105                                fnattrs);
4106   if (both_p
4107       && !flag_no_builtin && !builtin_function_disabled_p (libname)
4108       && !(nonansi_p && flag_no_nonansi_builtin))
4109     add_builtin_function (libname, libtype, fncode, fnclass,
4110                           NULL, fnattrs);
4111
4112   built_in_decls[(int) fncode] = decl;
4113   if (implicit_p)
4114     implicit_built_in_decls[(int) fncode] = decl;
4115 }
4116 \f
4117 /* Nonzero if the type T promotes to int.  This is (nearly) the
4118    integral promotions defined in ISO C99 6.3.1.1/2.  */
4119
4120 bool
4121 c_promoting_integer_type_p (const_tree t)
4122 {
4123   switch (TREE_CODE (t))
4124     {
4125     case INTEGER_TYPE:
4126       return (TYPE_MAIN_VARIANT (t) == char_type_node
4127               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4128               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4129               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4130               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4131               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4132
4133     case ENUMERAL_TYPE:
4134       /* ??? Technically all enumerations not larger than an int
4135          promote to an int.  But this is used along code paths
4136          that only want to notice a size change.  */
4137       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4138
4139     case BOOLEAN_TYPE:
4140       return 1;
4141
4142     default:
4143       return 0;
4144     }
4145 }
4146
4147 /* Return 1 if PARMS specifies a fixed number of parameters
4148    and none of their types is affected by default promotions.  */
4149
4150 int
4151 self_promoting_args_p (const_tree parms)
4152 {
4153   const_tree t;
4154   for (t = parms; t; t = TREE_CHAIN (t))
4155     {
4156       tree type = TREE_VALUE (t);
4157
4158       if (type == error_mark_node)
4159         continue;
4160
4161       if (TREE_CHAIN (t) == 0 && type != void_type_node)
4162         return 0;
4163
4164       if (type == 0)
4165         return 0;
4166
4167       if (TYPE_MAIN_VARIANT (type) == float_type_node)
4168         return 0;
4169
4170       if (c_promoting_integer_type_p (type))
4171         return 0;
4172     }
4173   return 1;
4174 }
4175
4176 /* Recursively remove any '*' or '&' operator from TYPE.  */
4177 tree
4178 strip_pointer_operator (tree t)
4179 {
4180   while (POINTER_TYPE_P (t))
4181     t = TREE_TYPE (t);
4182   return t;
4183 }
4184
4185 /* Recursively remove pointer or array type from TYPE. */
4186 tree
4187 strip_pointer_or_array_types (tree t)
4188 {
4189   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4190     t = TREE_TYPE (t);
4191   return t;
4192 }
4193
4194 /* Used to compare case labels.  K1 and K2 are actually tree nodes
4195    representing case labels, or NULL_TREE for a `default' label.
4196    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4197    K2, and 0 if K1 and K2 are equal.  */
4198
4199 int
4200 case_compare (splay_tree_key k1, splay_tree_key k2)
4201 {
4202   /* Consider a NULL key (such as arises with a `default' label) to be
4203      smaller than anything else.  */
4204   if (!k1)
4205     return k2 ? -1 : 0;
4206   else if (!k2)
4207     return k1 ? 1 : 0;
4208
4209   return tree_int_cst_compare ((tree) k1, (tree) k2);
4210 }
4211
4212 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
4213    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4214    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
4215    case label was declared using the usual C/C++ syntax, rather than
4216    the GNU case range extension.  CASES is a tree containing all the
4217    case ranges processed so far; COND is the condition for the
4218    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
4219    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
4220
4221 tree
4222 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4223                   tree low_value, tree high_value)
4224 {
4225   tree type;
4226   tree label;
4227   tree case_label;
4228   splay_tree_node node;
4229
4230   /* Create the LABEL_DECL itself.  */
4231   label = create_artificial_label ();
4232
4233   /* If there was an error processing the switch condition, bail now
4234      before we get more confused.  */
4235   if (!cond || cond == error_mark_node)
4236     goto error_out;
4237
4238   if ((low_value && TREE_TYPE (low_value)
4239        && POINTER_TYPE_P (TREE_TYPE (low_value)))
4240       || (high_value && TREE_TYPE (high_value)
4241           && POINTER_TYPE_P (TREE_TYPE (high_value))))
4242     {
4243       error ("pointers are not permitted as case values");
4244       goto error_out;
4245     }
4246
4247   /* Case ranges are a GNU extension.  */
4248   if (high_value && pedantic)
4249     pedwarn ("range expressions in switch statements are non-standard");
4250
4251   type = TREE_TYPE (cond);
4252   if (low_value)
4253     {
4254       low_value = check_case_value (low_value);
4255       low_value = convert_and_check (type, low_value);
4256       if (low_value == error_mark_node)
4257         goto error_out;
4258     }
4259   if (high_value)
4260     {
4261       high_value = check_case_value (high_value);
4262       high_value = convert_and_check (type, high_value);
4263       if (high_value == error_mark_node)
4264         goto error_out;
4265     }
4266
4267   if (low_value && high_value)
4268     {
4269       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4270          really a case range, even though it was written that way.
4271          Remove the HIGH_VALUE to simplify later processing.  */
4272       if (tree_int_cst_equal (low_value, high_value))
4273         high_value = NULL_TREE;
4274       else if (!tree_int_cst_lt (low_value, high_value))
4275         warning (0, "empty range specified");
4276     }
4277
4278   /* See if the case is in range of the type of the original testing
4279      expression.  If both low_value and high_value are out of range,
4280      don't insert the case label and return NULL_TREE.  */
4281   if (low_value
4282       && !check_case_bounds (type, orig_type,
4283                              &low_value, high_value ? &high_value : NULL))
4284     return NULL_TREE;
4285
4286   /* Look up the LOW_VALUE in the table of case labels we already
4287      have.  */
4288   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4289   /* If there was not an exact match, check for overlapping ranges.
4290      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4291      that's a `default' label and the only overlap is an exact match.  */
4292   if (!node && (low_value || high_value))
4293     {
4294       splay_tree_node low_bound;
4295       splay_tree_node high_bound;
4296
4297       /* Even though there wasn't an exact match, there might be an
4298          overlap between this case range and another case range.
4299          Since we've (inductively) not allowed any overlapping case
4300          ranges, we simply need to find the greatest low case label
4301          that is smaller that LOW_VALUE, and the smallest low case
4302          label that is greater than LOW_VALUE.  If there is an overlap
4303          it will occur in one of these two ranges.  */
4304       low_bound = splay_tree_predecessor (cases,
4305                                           (splay_tree_key) low_value);
4306       high_bound = splay_tree_successor (cases,
4307                                          (splay_tree_key) low_value);
4308
4309       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
4310          the LOW_VALUE, so there is no need to check unless the
4311          LOW_BOUND is in fact itself a case range.  */
4312       if (low_bound
4313           && CASE_HIGH ((tree) low_bound->value)
4314           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4315                                     low_value) >= 0)
4316         node = low_bound;
4317       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
4318          range is bigger than the low end of the current range, so we
4319          are only interested if the current range is a real range, and
4320          not an ordinary case label.  */
4321       else if (high_bound
4322                && high_value
4323                && (tree_int_cst_compare ((tree) high_bound->key,
4324                                          high_value)
4325                    <= 0))
4326         node = high_bound;
4327     }
4328   /* If there was an overlap, issue an error.  */
4329   if (node)
4330     {
4331       tree duplicate = CASE_LABEL ((tree) node->value);
4332
4333       if (high_value)
4334         {
4335           error ("duplicate (or overlapping) case value");
4336           error ("%Jthis is the first entry overlapping that value", duplicate);
4337         }
4338       else if (low_value)
4339         {
4340           error ("duplicate case value") ;
4341           error ("%Jpreviously used here", duplicate);
4342         }
4343       else
4344         {
4345           error ("multiple default labels in one switch");
4346           error ("%Jthis is the first default label", duplicate);
4347         }
4348       goto error_out;
4349     }
4350
4351   /* Add a CASE_LABEL to the statement-tree.  */
4352   case_label = add_stmt (build_case_label (low_value, high_value, label));
4353   /* Register this case label in the splay tree.  */
4354   splay_tree_insert (cases,
4355                      (splay_tree_key) low_value,
4356                      (splay_tree_value) case_label);
4357
4358   return case_label;
4359
4360  error_out:
4361   /* Add a label so that the back-end doesn't think that the beginning of
4362      the switch is unreachable.  Note that we do not add a case label, as
4363      that just leads to duplicates and thence to failure later on.  */
4364   if (!cases->root)
4365     {
4366       tree t = create_artificial_label ();
4367       add_stmt (build_stmt (LABEL_EXPR, t));
4368     }
4369   return error_mark_node;
4370 }
4371
4372 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4373    Used to verify that case values match up with enumerator values.  */
4374
4375 static void
4376 match_case_to_enum_1 (tree key, tree type, tree label)
4377 {
4378   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4379
4380   /* ??? Not working too hard to print the double-word value.
4381      Should perhaps be done with %lwd in the diagnostic routines?  */
4382   if (TREE_INT_CST_HIGH (key) == 0)
4383     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4384               TREE_INT_CST_LOW (key));
4385   else if (!TYPE_UNSIGNED (type)
4386            && TREE_INT_CST_HIGH (key) == -1
4387            && TREE_INT_CST_LOW (key) != 0)
4388     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4389               -TREE_INT_CST_LOW (key));
4390   else
4391     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4392               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4393               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4394
4395   if (TYPE_NAME (type) == 0)
4396     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4397              "%Jcase value %qs not in enumerated type",
4398              CASE_LABEL (label), buf);
4399   else
4400     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4401              "%Jcase value %qs not in enumerated type %qT",
4402              CASE_LABEL (label), buf, type);
4403 }
4404
4405 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4406    Used to verify that case values match up with enumerator values.  */
4407
4408 static int
4409 match_case_to_enum (splay_tree_node node, void *data)
4410 {
4411   tree label = (tree) node->value;
4412   tree type = (tree) data;
4413
4414   /* Skip default case.  */
4415   if (!CASE_LOW (label))
4416     return 0;
4417
4418   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4419      when we did our enum->case scan.  Reset our scratch bit after.  */
4420   if (!CASE_LOW_SEEN (label))
4421     match_case_to_enum_1 (CASE_LOW (label), type, label);
4422   else
4423     CASE_LOW_SEEN (label) = 0;
4424
4425   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
4426      not set, that means that CASE_HIGH did not appear when we did our
4427      enum->case scan.  Reset our scratch bit after.  */
4428   if (CASE_HIGH (label))
4429     {
4430       if (!CASE_HIGH_SEEN (label))
4431         match_case_to_enum_1 (CASE_HIGH (label), type, label);
4432       else
4433         CASE_HIGH_SEEN (label) = 0;
4434     }
4435
4436   return 0;
4437 }
4438
4439 /* Handle -Wswitch*.  Called from the front end after parsing the
4440    switch construct.  */
4441 /* ??? Should probably be somewhere generic, since other languages
4442    besides C and C++ would want this.  At the moment, however, C/C++
4443    are the only tree-ssa languages that support enumerations at all,
4444    so the point is moot.  */
4445
4446 void
4447 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4448                       tree type, tree cond)
4449 {
4450   splay_tree_node default_node;
4451   splay_tree_node node;
4452   tree chain;
4453   int saved_warn_switch;
4454
4455   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4456     return;
4457
4458   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4459   if (!default_node)
4460     warning (OPT_Wswitch_default, "%Hswitch missing default case",
4461              &switch_location);
4462
4463   /* From here on, we only care about about enumerated types.  */
4464   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4465     return;
4466
4467   /* If the switch expression was an enumerated type, check that
4468      exactly all enumeration literals are covered by the cases.
4469      The check is made when -Wswitch was specified and there is no
4470      default case, or when -Wswitch-enum was specified.  */
4471
4472   if (!warn_switch_enum
4473       && !(warn_switch && !default_node))
4474     return;
4475
4476   /* Clearing COND if it is not an integer constant simplifies
4477      the tests inside the loop below.  */
4478   if (TREE_CODE (cond) != INTEGER_CST)
4479     cond = NULL_TREE;
4480
4481   /* The time complexity here is O(N*lg(N)) worst case, but for the
4482       common case of monotonically increasing enumerators, it is
4483       O(N), since the nature of the splay tree will keep the next
4484       element adjacent to the root at all times.  */
4485
4486   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4487     {
4488       tree value = TREE_VALUE (chain);
4489       node = splay_tree_lookup (cases, (splay_tree_key) value);
4490       if (node)
4491         {
4492           /* Mark the CASE_LOW part of the case entry as seen.  */
4493           tree label = (tree) node->value;
4494           CASE_LOW_SEEN (label) = 1;
4495           continue;
4496         }
4497
4498       /* Even though there wasn't an exact match, there might be a
4499          case range which includes the enumator's value.  */
4500       node = splay_tree_predecessor (cases, (splay_tree_key) value);
4501       if (node && CASE_HIGH ((tree) node->value))
4502         {
4503           tree label = (tree) node->value;
4504           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4505           if (cmp >= 0)
4506             {
4507               /* If we match the upper bound exactly, mark the CASE_HIGH
4508                  part of the case entry as seen.  */
4509               if (cmp == 0)
4510                 CASE_HIGH_SEEN (label) = 1;
4511               continue;
4512             }
4513         }
4514
4515       /* We've now determined that this enumerated literal isn't
4516          handled by the case labels of the switch statement.  */
4517
4518       /* If the switch expression is a constant, we only really care
4519          about whether that constant is handled by the switch.  */
4520       if (cond && tree_int_cst_compare (cond, value))
4521         continue;
4522
4523       /* If there is a default_node, the only relevant option is
4524          Wswitch-enum. Otherwise, if both are enabled then we prefer
4525          to warn using -Wswitch because -Wswitch is enabled by -Wall
4526          while -Wswitch-enum is explicit.  */
4527       warning ((default_node || !warn_switch)
4528                ? OPT_Wswitch_enum : OPT_Wswitch,
4529                "%Henumeration value %qE not handled in switch",
4530                &switch_location, TREE_PURPOSE (chain));
4531     }
4532
4533   /* Warn if there are case expressions that don't correspond to
4534      enumerators.  This can occur since C and C++ don't enforce
4535      type-checking of assignments to enumeration variables.
4536
4537      The time complexity here is now always O(N) worst case, since
4538      we should have marked both the lower bound and upper bound of
4539      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4540      above.  This scan also resets those fields.  */
4541
4542   /* If there is a default_node, the only relevant option is
4543      Wswitch-enum. Otherwise, if both are enabled then we prefer
4544      to warn using -Wswitch because -Wswitch is enabled by -Wall
4545      while -Wswitch-enum is explicit.  */
4546   saved_warn_switch = warn_switch;
4547   if (default_node)
4548     warn_switch = 0;
4549   splay_tree_foreach (cases, match_case_to_enum, type);
4550   warn_switch = saved_warn_switch;
4551
4552 }
4553
4554 /* Finish an expression taking the address of LABEL (an
4555    IDENTIFIER_NODE).  Returns an expression for the address.  */
4556
4557 tree
4558 finish_label_address_expr (tree label)
4559 {
4560   tree result;
4561
4562   if (pedantic)
4563     pedwarn ("taking the address of a label is non-standard");
4564
4565   if (label == error_mark_node)
4566     return error_mark_node;
4567
4568   label = lookup_label (label);
4569   if (label == NULL_TREE)
4570     result = null_pointer_node;
4571   else
4572     {
4573       TREE_USED (label) = 1;
4574       result = build1 (ADDR_EXPR, ptr_type_node, label);
4575       /* The current function in not necessarily uninlinable.
4576          Computed gotos are incompatible with inlining, but the value
4577          here could be used only in a diagnostic, for example.  */
4578     }
4579
4580   return result;
4581 }
4582
4583 /* Hook used by expand_expr to expand language-specific tree codes.  */
4584 /* The only things that should go here are bits needed to expand
4585    constant initializers.  Everything else should be handled by the
4586    gimplification routines.  */
4587
4588 rtx
4589 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4590                int modifier /* Actually enum_modifier.  */,
4591                rtx *alt_rtl)
4592 {
4593   switch (TREE_CODE (exp))
4594     {
4595     case COMPOUND_LITERAL_EXPR:
4596       {
4597         /* Initialize the anonymous variable declared in the compound
4598            literal, then return the variable.  */
4599         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4600         emit_local_var (decl);
4601         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4602       }
4603
4604     default:
4605       gcc_unreachable ();
4606     }
4607 }
4608
4609 /* Hook used by staticp to handle language-specific tree codes.  */
4610
4611 tree
4612 c_staticp (tree exp)
4613 {
4614   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4615           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4616           ? exp : NULL);
4617 }
4618 \f
4619
4620 /* Given a boolean expression ARG, return a tree representing an increment
4621    or decrement (as indicated by CODE) of ARG.  The front end must check for
4622    invalid cases (e.g., decrement in C++).  */
4623 tree
4624 boolean_increment (enum tree_code code, tree arg)
4625 {
4626   tree val;
4627   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
4628
4629   arg = stabilize_reference (arg);
4630   switch (code)
4631     {
4632     case PREINCREMENT_EXPR:
4633       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4634       break;
4635     case POSTINCREMENT_EXPR:
4636       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4637       arg = save_expr (arg);
4638       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4639       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4640       break;
4641     case PREDECREMENT_EXPR:
4642       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4643                     invert_truthvalue (arg));
4644       break;
4645     case POSTDECREMENT_EXPR:
4646       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4647                     invert_truthvalue (arg));
4648       arg = save_expr (arg);
4649       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4650       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4651       break;
4652     default:
4653       gcc_unreachable ();
4654     }
4655   TREE_SIDE_EFFECTS (val) = 1;
4656   return val;
4657 }
4658 \f
4659 /* Built-in macros for stddef.h, that require macros defined in this
4660    file.  */
4661 void
4662 c_stddef_cpp_builtins(void)
4663 {
4664   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4665   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4666   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4667   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4668   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4669   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4670 }
4671
4672 static void
4673 c_init_attributes (void)
4674 {
4675   /* Fill in the built_in_attributes array.  */
4676 #define DEF_ATTR_NULL_TREE(ENUM)                                \
4677   built_in_attributes[(int) ENUM] = NULL_TREE;
4678 #define DEF_ATTR_INT(ENUM, VALUE)                               \
4679   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4680 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
4681   built_in_attributes[(int) ENUM] = get_identifier (STRING);
4682 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4683   built_in_attributes[(int) ENUM]                       \
4684     = tree_cons (built_in_attributes[(int) PURPOSE],    \
4685                  built_in_attributes[(int) VALUE],      \
4686                  built_in_attributes[(int) CHAIN]);
4687 #include "builtin-attrs.def"
4688 #undef DEF_ATTR_NULL_TREE
4689 #undef DEF_ATTR_INT
4690 #undef DEF_ATTR_IDENT
4691 #undef DEF_ATTR_TREE_LIST
4692 }
4693
4694 /* Attribute handlers common to C front ends.  */
4695
4696 /* Handle a "packed" attribute; arguments as in
4697    struct attribute_spec.handler.  */
4698
4699 static tree
4700 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4701                          int flags, bool *no_add_attrs)
4702 {
4703   if (TYPE_P (*node))
4704     {
4705       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4706         *node = build_variant_type_copy (*node);
4707       TYPE_PACKED (*node) = 1;
4708     }
4709   else if (TREE_CODE (*node) == FIELD_DECL)
4710     {
4711       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4712         warning (OPT_Wattributes,
4713                  "%qE attribute ignored for field of type %qT",
4714                  name, TREE_TYPE (*node));
4715       else
4716         DECL_PACKED (*node) = 1;
4717     }
4718   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4719      used for DECL_REGISTER.  It wouldn't mean anything anyway.
4720      We can't set DECL_PACKED on the type of a TYPE_DECL, because
4721      that changes what the typedef is typing.  */
4722   else
4723     {
4724       warning (OPT_Wattributes, "%qE attribute ignored", name);
4725       *no_add_attrs = true;
4726     }
4727
4728   return NULL_TREE;
4729 }
4730
4731 /* Handle a "nocommon" attribute; arguments as in
4732    struct attribute_spec.handler.  */
4733
4734 static tree
4735 handle_nocommon_attribute (tree *node, tree name,
4736                            tree ARG_UNUSED (args),
4737                            int ARG_UNUSED (flags), bool *no_add_attrs)
4738 {
4739   if (TREE_CODE (*node) == VAR_DECL)
4740     DECL_COMMON (*node) = 0;
4741   else
4742     {
4743       warning (OPT_Wattributes, "%qE attribute ignored", name);
4744       *no_add_attrs = true;
4745     }
4746
4747   return NULL_TREE;
4748 }
4749
4750 /* Handle a "common" attribute; arguments as in
4751    struct attribute_spec.handler.  */
4752
4753 static tree
4754 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4755                          int ARG_UNUSED (flags), bool *no_add_attrs)
4756 {
4757   if (TREE_CODE (*node) == VAR_DECL)
4758     DECL_COMMON (*node) = 1;
4759   else
4760     {
4761       warning (OPT_Wattributes, "%qE attribute ignored", name);
4762       *no_add_attrs = true;
4763     }
4764
4765   return NULL_TREE;
4766 }
4767
4768 /* Handle a "noreturn" attribute; arguments as in
4769    struct attribute_spec.handler.  */
4770
4771 static tree
4772 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4773                            int ARG_UNUSED (flags), bool *no_add_attrs)
4774 {
4775   tree type = TREE_TYPE (*node);
4776
4777   /* See FIXME comment in c_common_attribute_table.  */
4778   if (TREE_CODE (*node) == FUNCTION_DECL)
4779     TREE_THIS_VOLATILE (*node) = 1;
4780   else if (TREE_CODE (type) == POINTER_TYPE
4781            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4782     TREE_TYPE (*node)
4783       = build_pointer_type
4784         (build_type_variant (TREE_TYPE (type),
4785                              TYPE_READONLY (TREE_TYPE (type)), 1));
4786   else
4787     {
4788       warning (OPT_Wattributes, "%qE attribute ignored", name);
4789       *no_add_attrs = true;
4790     }
4791
4792   return NULL_TREE;
4793 }
4794
4795 /* Handle a "hot" and attribute; arguments as in
4796    struct attribute_spec.handler.  */
4797
4798 static tree
4799 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4800                           int ARG_UNUSED (flags), bool *no_add_attrs)
4801 {
4802   if (TREE_CODE (*node) == FUNCTION_DECL)
4803     {
4804       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
4805         {
4806           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4807                    name, "cold");
4808           *no_add_attrs = true;
4809         }
4810       /* Do nothing else, just set the attribute.  We'll get at
4811          it later with lookup_attribute.  */
4812     }
4813   else
4814     {
4815       warning (OPT_Wattributes, "%qE attribute ignored", name);
4816       *no_add_attrs = true;
4817     }
4818
4819   return NULL_TREE;
4820 }
4821 /* Handle a "cold" and attribute; arguments as in
4822    struct attribute_spec.handler.  */
4823
4824 static tree
4825 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4826                        int ARG_UNUSED (flags), bool *no_add_attrs)
4827 {
4828   if (TREE_CODE (*node) == FUNCTION_DECL)
4829     {
4830       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
4831         {
4832           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4833                    name, "hot");
4834           *no_add_attrs = true;
4835         }
4836       /* Do nothing else, just set the attribute.  We'll get at
4837          it later with lookup_attribute.  */
4838     }
4839   else
4840     {
4841       warning (OPT_Wattributes, "%qE attribute ignored", name);
4842       *no_add_attrs = true;
4843     }
4844
4845   return NULL_TREE;
4846 }
4847
4848 /* Handle a "noinline" attribute; arguments as in
4849    struct attribute_spec.handler.  */
4850
4851 static tree
4852 handle_noinline_attribute (tree *node, tree name,
4853                            tree ARG_UNUSED (args),
4854                            int ARG_UNUSED (flags), bool *no_add_attrs)
4855 {
4856   if (TREE_CODE (*node) == FUNCTION_DECL)
4857     DECL_UNINLINABLE (*node) = 1;
4858   else
4859     {
4860       warning (OPT_Wattributes, "%qE attribute ignored", name);
4861       *no_add_attrs = true;
4862     }
4863
4864   return NULL_TREE;
4865 }
4866
4867 /* Handle a "always_inline" attribute; arguments as in
4868    struct attribute_spec.handler.  */
4869
4870 static tree
4871 handle_always_inline_attribute (tree *node, tree name,
4872                                 tree ARG_UNUSED (args),
4873                                 int ARG_UNUSED (flags),
4874                                 bool *no_add_attrs)
4875 {
4876   if (TREE_CODE (*node) == FUNCTION_DECL)
4877     {
4878       /* Set the attribute and mark it for disregarding inline
4879          limits.  */
4880       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
4881     }
4882   else
4883     {
4884       warning (OPT_Wattributes, "%qE attribute ignored", name);
4885       *no_add_attrs = true;
4886     }
4887
4888   return NULL_TREE;
4889 }
4890
4891 /* Handle a "gnu_inline" attribute; arguments as in
4892    struct attribute_spec.handler.  */
4893
4894 static tree
4895 handle_gnu_inline_attribute (tree *node, tree name,
4896                              tree ARG_UNUSED (args),
4897                              int ARG_UNUSED (flags),
4898                              bool *no_add_attrs)
4899 {
4900   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4901     {
4902       /* Do nothing else, just set the attribute.  We'll get at
4903          it later with lookup_attribute.  */
4904     }
4905   else
4906     {
4907       warning (OPT_Wattributes, "%qE attribute ignored", name);
4908       *no_add_attrs = true;
4909     }
4910
4911   return NULL_TREE;
4912 }
4913
4914 /* Handle an "artificial" attribute; arguments as in
4915    struct attribute_spec.handler.  */
4916
4917 static tree
4918 handle_artificial_attribute (tree *node, tree name,
4919                              tree ARG_UNUSED (args),
4920                              int ARG_UNUSED (flags),
4921                              bool *no_add_attrs)
4922 {
4923   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4924     {
4925       /* Do nothing else, just set the attribute.  We'll get at
4926          it later with lookup_attribute.  */
4927     }
4928   else
4929     {
4930       warning (OPT_Wattributes, "%qE attribute ignored", name);
4931       *no_add_attrs = true;
4932     }
4933
4934   return NULL_TREE;
4935 }
4936
4937 /* Handle a "flatten" attribute; arguments as in
4938    struct attribute_spec.handler.  */
4939
4940 static tree
4941 handle_flatten_attribute (tree *node, tree name,
4942                           tree args ATTRIBUTE_UNUSED,
4943                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4944 {
4945   if (TREE_CODE (*node) == FUNCTION_DECL)
4946     /* Do nothing else, just set the attribute.  We'll get at
4947        it later with lookup_attribute.  */
4948     ;
4949   else
4950     {
4951       warning (OPT_Wattributes, "%qE attribute ignored", name);
4952       *no_add_attrs = true;
4953     }
4954
4955   return NULL_TREE;
4956 }
4957
4958 /* Handle a "warning" or "error" attribute; arguments as in
4959    struct attribute_spec.handler.  */
4960
4961 static tree
4962 handle_error_attribute (tree *node, tree name, tree args,
4963                         int ARG_UNUSED (flags), bool *no_add_attrs)
4964 {
4965   if (TREE_CODE (*node) == FUNCTION_DECL
4966       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4967     /* Do nothing else, just set the attribute.  We'll get at
4968        it later with lookup_attribute.  */
4969     ;
4970   else
4971     {
4972       warning (OPT_Wattributes, "%qE attribute ignored", name);
4973       *no_add_attrs = true;
4974     }
4975
4976   return NULL_TREE;
4977 }
4978
4979 /* Handle a "used" attribute; arguments as in
4980    struct attribute_spec.handler.  */
4981
4982 static tree
4983 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4984                        int ARG_UNUSED (flags), bool *no_add_attrs)
4985 {
4986   tree node = *pnode;
4987
4988   if (TREE_CODE (node) == FUNCTION_DECL
4989       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4990     {
4991       TREE_USED (node) = 1;
4992       DECL_PRESERVE_P (node) = 1;
4993     }
4994   else
4995     {
4996       warning (OPT_Wattributes, "%qE attribute ignored", name);
4997       *no_add_attrs = true;
4998     }
4999
5000   return NULL_TREE;
5001 }
5002
5003 /* Handle a "unused" attribute; arguments as in
5004    struct attribute_spec.handler.  */
5005
5006 static tree
5007 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5008                          int flags, bool *no_add_attrs)
5009 {
5010   if (DECL_P (*node))
5011     {
5012       tree decl = *node;
5013
5014       if (TREE_CODE (decl) == PARM_DECL
5015           || TREE_CODE (decl) == VAR_DECL
5016           || TREE_CODE (decl) == FUNCTION_DECL
5017           || TREE_CODE (decl) == LABEL_DECL
5018           || TREE_CODE (decl) == TYPE_DECL)
5019         TREE_USED (decl) = 1;
5020       else
5021         {
5022           warning (OPT_Wattributes, "%qE attribute ignored", name);
5023           *no_add_attrs = true;
5024         }
5025     }
5026   else
5027     {
5028       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5029         *node = build_variant_type_copy (*node);
5030       TREE_USED (*node) = 1;
5031     }
5032
5033   return NULL_TREE;
5034 }
5035
5036 /* Handle a "externally_visible" attribute; arguments as in
5037    struct attribute_spec.handler.  */
5038
5039 static tree
5040 handle_externally_visible_attribute (tree *pnode, tree name,
5041                                      tree ARG_UNUSED (args),
5042                                      int ARG_UNUSED (flags),
5043                                      bool *no_add_attrs)
5044 {
5045   tree node = *pnode;
5046
5047   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5048     {
5049       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5050            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5051         {
5052           warning (OPT_Wattributes,
5053                    "%qE attribute have effect only on public objects", name);
5054           *no_add_attrs = true;
5055         }
5056     }
5057   else
5058     {
5059       warning (OPT_Wattributes, "%qE attribute ignored", name);
5060       *no_add_attrs = true;
5061     }
5062
5063   return NULL_TREE;
5064 }
5065
5066 /* Handle a "const" attribute; arguments as in
5067    struct attribute_spec.handler.  */
5068
5069 static tree
5070 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5071                         int ARG_UNUSED (flags), bool *no_add_attrs)
5072 {
5073   tree type = TREE_TYPE (*node);
5074
5075   /* See FIXME comment on noreturn in c_common_attribute_table.  */
5076   if (TREE_CODE (*node) == FUNCTION_DECL)
5077     TREE_READONLY (*node) = 1;
5078   else if (TREE_CODE (type) == POINTER_TYPE
5079            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5080     TREE_TYPE (*node)
5081       = build_pointer_type
5082         (build_type_variant (TREE_TYPE (type), 1,
5083                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
5084   else
5085     {
5086       warning (OPT_Wattributes, "%qE attribute ignored", name);
5087       *no_add_attrs = true;
5088     }
5089
5090   return NULL_TREE;
5091 }
5092
5093 /* Handle a "transparent_union" attribute; arguments as in
5094    struct attribute_spec.handler.  */
5095
5096 static tree
5097 handle_transparent_union_attribute (tree *node, tree name,
5098                                     tree ARG_UNUSED (args), int flags,
5099                                     bool *no_add_attrs)
5100 {
5101   tree type;
5102
5103   *no_add_attrs = true;
5104
5105   if (TREE_CODE (*node) == TYPE_DECL)
5106     node = &TREE_TYPE (*node);
5107   type = *node;
5108
5109   if (TREE_CODE (type) == UNION_TYPE)
5110     {
5111       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5112          the code in finish_struct.  */
5113       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5114         {
5115           if (TYPE_FIELDS (type) == NULL_TREE
5116               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5117             goto ignored;
5118
5119           /* A type variant isn't good enough, since we don't a cast
5120              to such a type removed as a no-op.  */
5121           *node = type = build_duplicate_type (type);
5122         }
5123
5124       TYPE_TRANSPARENT_UNION (type) = 1;
5125       return NULL_TREE;
5126     }
5127
5128  ignored:
5129   warning (OPT_Wattributes, "%qE attribute ignored", name);
5130   return NULL_TREE;
5131 }
5132
5133 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
5134    get the requested priority for a constructor or destructor,
5135    possibly issuing diagnostics for invalid or reserved
5136    priorities.  */
5137
5138 static priority_type
5139 get_priority (tree args, bool is_destructor)
5140 {
5141   HOST_WIDE_INT pri;
5142   tree arg;
5143
5144   if (!args)
5145     return DEFAULT_INIT_PRIORITY;
5146
5147   if (!SUPPORTS_INIT_PRIORITY)
5148     {
5149       if (is_destructor)
5150         error ("destructor priorities are not supported");
5151       else
5152         error ("constructor priorities are not supported");
5153       return DEFAULT_INIT_PRIORITY;
5154     }
5155
5156   arg = TREE_VALUE (args);
5157   if (!host_integerp (arg, /*pos=*/0)
5158       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5159     goto invalid;
5160
5161   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5162   if (pri < 0 || pri > MAX_INIT_PRIORITY)
5163     goto invalid;
5164
5165   if (pri <= MAX_RESERVED_INIT_PRIORITY)
5166     {
5167       if (is_destructor)
5168         warning (0,
5169                  "destructor priorities from 0 to %d are reserved "
5170                  "for the implementation",
5171                  MAX_RESERVED_INIT_PRIORITY);
5172       else
5173         warning (0,
5174                  "constructor priorities from 0 to %d are reserved "
5175                  "for the implementation",
5176                  MAX_RESERVED_INIT_PRIORITY);
5177     }
5178   return pri;
5179
5180  invalid:
5181   if (is_destructor)
5182     error ("destructor priorities must be integers from 0 to %d inclusive",
5183            MAX_INIT_PRIORITY);
5184   else
5185     error ("constructor priorities must be integers from 0 to %d inclusive",
5186            MAX_INIT_PRIORITY);
5187   return DEFAULT_INIT_PRIORITY;
5188 }
5189
5190 /* Handle a "constructor" attribute; arguments as in
5191    struct attribute_spec.handler.  */
5192
5193 static tree
5194 handle_constructor_attribute (tree *node, tree name, tree args,
5195                               int ARG_UNUSED (flags),
5196                               bool *no_add_attrs)
5197 {
5198   tree decl = *node;
5199   tree type = TREE_TYPE (decl);
5200
5201   if (TREE_CODE (decl) == FUNCTION_DECL
5202       && TREE_CODE (type) == FUNCTION_TYPE
5203       && decl_function_context (decl) == 0)
5204     {
5205       priority_type priority;
5206       DECL_STATIC_CONSTRUCTOR (decl) = 1;
5207       priority = get_priority (args, /*is_destructor=*/false);
5208       SET_DECL_INIT_PRIORITY (decl, priority);
5209       TREE_USED (decl) = 1;
5210     }
5211   else
5212     {
5213       warning (OPT_Wattributes, "%qE attribute ignored", name);
5214       *no_add_attrs = true;
5215     }
5216
5217   return NULL_TREE;
5218 }
5219
5220 /* Handle a "destructor" attribute; arguments as in
5221    struct attribute_spec.handler.  */
5222
5223 static tree
5224 handle_destructor_attribute (tree *node, tree name, tree args,
5225                              int ARG_UNUSED (flags),
5226                              bool *no_add_attrs)
5227 {
5228   tree decl = *node;
5229   tree type = TREE_TYPE (decl);
5230
5231   if (TREE_CODE (decl) == FUNCTION_DECL
5232       && TREE_CODE (type) == FUNCTION_TYPE
5233       && decl_function_context (decl) == 0)
5234     {
5235       priority_type priority;
5236       DECL_STATIC_DESTRUCTOR (decl) = 1;
5237       priority = get_priority (args, /*is_destructor=*/true);
5238       SET_DECL_FINI_PRIORITY (decl, priority);
5239       TREE_USED (decl) = 1;
5240     }
5241   else
5242     {
5243       warning (OPT_Wattributes, "%qE attribute ignored", name);
5244       *no_add_attrs = true;
5245     }
5246
5247   return NULL_TREE;
5248 }
5249
5250 /* Handle a "mode" attribute; arguments as in
5251    struct attribute_spec.handler.  */
5252
5253 static tree
5254 handle_mode_attribute (tree *node, tree name, tree args,
5255                        int ARG_UNUSED (flags), bool *no_add_attrs)
5256 {
5257   tree type = *node;
5258
5259   *no_add_attrs = true;
5260
5261   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5262     warning (OPT_Wattributes, "%qE attribute ignored", name);
5263   else
5264     {
5265       int j;
5266       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5267       int len = strlen (p);
5268       enum machine_mode mode = VOIDmode;
5269       tree typefm;
5270       bool valid_mode;
5271
5272       if (len > 4 && p[0] == '_' && p[1] == '_'
5273           && p[len - 1] == '_' && p[len - 2] == '_')
5274         {
5275           char *newp = (char *) alloca (len - 1);
5276
5277           strcpy (newp, &p[2]);
5278           newp[len - 4] = '\0';
5279           p = newp;
5280         }
5281
5282       /* Change this type to have a type with the specified mode.
5283          First check for the special modes.  */
5284       if (!strcmp (p, "byte"))
5285         mode = byte_mode;
5286       else if (!strcmp (p, "word"))
5287         mode = word_mode;
5288       else if (!strcmp (p, "pointer"))
5289         mode = ptr_mode;
5290       else if (!strcmp (p, "libgcc_cmp_return"))
5291         mode = targetm.libgcc_cmp_return_mode ();
5292       else if (!strcmp (p, "libgcc_shift_count"))
5293         mode = targetm.libgcc_shift_count_mode ();
5294       else
5295         for (j = 0; j < NUM_MACHINE_MODES; j++)
5296           if (!strcmp (p, GET_MODE_NAME (j)))
5297             {
5298               mode = (enum machine_mode) j;
5299               break;
5300             }
5301
5302       if (mode == VOIDmode)
5303         {
5304           error ("unknown machine mode %qs", p);
5305           return NULL_TREE;
5306         }
5307
5308       valid_mode = false;
5309       switch (GET_MODE_CLASS (mode))
5310         {
5311         case MODE_INT:
5312         case MODE_PARTIAL_INT:
5313         case MODE_FLOAT:
5314         case MODE_DECIMAL_FLOAT:
5315         case MODE_FRACT:
5316         case MODE_UFRACT:
5317         case MODE_ACCUM:
5318         case MODE_UACCUM:
5319           valid_mode = targetm.scalar_mode_supported_p (mode);
5320           break;
5321
5322         case MODE_COMPLEX_INT:
5323         case MODE_COMPLEX_FLOAT:
5324           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5325           break;
5326
5327         case MODE_VECTOR_INT:
5328         case MODE_VECTOR_FLOAT:
5329         case MODE_VECTOR_FRACT:
5330         case MODE_VECTOR_UFRACT:
5331         case MODE_VECTOR_ACCUM:
5332         case MODE_VECTOR_UACCUM:
5333           warning (OPT_Wattributes, "specifying vector types with "
5334                    "__attribute__ ((mode)) is deprecated");
5335           warning (OPT_Wattributes,
5336                    "use __attribute__ ((vector_size)) instead");
5337           valid_mode = vector_mode_valid_p (mode);
5338           break;
5339
5340         default:
5341           break;
5342         }
5343       if (!valid_mode)
5344         {
5345           error ("unable to emulate %qs", p);
5346           return NULL_TREE;
5347         }
5348
5349       if (POINTER_TYPE_P (type))
5350         {
5351           tree (*fn)(tree, enum machine_mode, bool);
5352
5353           if (!targetm.valid_pointer_mode (mode))
5354             {
5355               error ("invalid pointer mode %qs", p);
5356               return NULL_TREE;
5357             }
5358
5359           if (TREE_CODE (type) == POINTER_TYPE)
5360             fn = build_pointer_type_for_mode;
5361           else
5362             fn = build_reference_type_for_mode;
5363           typefm = fn (TREE_TYPE (type), mode, false);
5364         }
5365       else
5366         {
5367           /* For fixed-point modes, we need to test if the signness of type
5368              and the machine mode are consistent.  */
5369           if (ALL_FIXED_POINT_MODE_P (mode)
5370               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5371             {
5372               error ("signness of type and machine mode %qs don't match", p);
5373               return NULL_TREE;
5374             }
5375           /* For fixed-point modes, we need to pass saturating info.  */
5376           typefm = lang_hooks.types.type_for_mode (mode,
5377                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5378                                                       : TYPE_UNSIGNED (type));
5379         }
5380
5381       if (typefm == NULL_TREE)
5382         {
5383           error ("no data type for mode %qs", p);
5384           return NULL_TREE;
5385         }
5386       else if (TREE_CODE (type) == ENUMERAL_TYPE)
5387         {
5388           /* For enumeral types, copy the precision from the integer
5389              type returned above.  If not an INTEGER_TYPE, we can't use
5390              this mode for this type.  */
5391           if (TREE_CODE (typefm) != INTEGER_TYPE)
5392             {
5393               error ("cannot use mode %qs for enumeral types", p);
5394               return NULL_TREE;
5395             }
5396
5397           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5398             {
5399               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5400               typefm = type;
5401             }
5402           else
5403             {
5404               /* We cannot build a type variant, as there's code that assumes
5405                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
5406                  debug generators.  Instead, create a subrange type.  This
5407                  results in all of the enumeral values being emitted only once
5408                  in the original, and the subtype gets them by reference.  */
5409               if (TYPE_UNSIGNED (type))
5410                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5411               else
5412                 typefm = make_signed_type (TYPE_PRECISION (typefm));
5413               TREE_TYPE (typefm) = type;
5414             }
5415         }
5416       else if (VECTOR_MODE_P (mode)
5417                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5418                : TREE_CODE (type) != TREE_CODE (typefm))
5419         {
5420           error ("mode %qs applied to inappropriate type", p);
5421           return NULL_TREE;
5422         }
5423
5424       *node = typefm;
5425     }
5426
5427   return NULL_TREE;
5428 }
5429
5430 /* Handle a "section" attribute; arguments as in
5431    struct attribute_spec.handler.  */
5432
5433 static tree
5434 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5435                           int ARG_UNUSED (flags), bool *no_add_attrs)
5436 {
5437   tree decl = *node;
5438
5439   if (targetm.have_named_sections)
5440     {
5441       user_defined_section_attribute = true;
5442
5443       if ((TREE_CODE (decl) == FUNCTION_DECL
5444            || TREE_CODE (decl) == VAR_DECL)
5445           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5446         {
5447           if (TREE_CODE (decl) == VAR_DECL
5448               && current_function_decl != NULL_TREE
5449               && !TREE_STATIC (decl))
5450             {
5451               error ("%Jsection attribute cannot be specified for "
5452                      "local variables", decl);
5453               *no_add_attrs = true;
5454             }
5455
5456           /* The decl may have already been given a section attribute
5457              from a previous declaration.  Ensure they match.  */
5458           else if (DECL_SECTION_NAME (decl) != NULL_TREE
5459                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5460                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5461             {
5462               error ("section of %q+D conflicts with previous declaration",
5463                      *node);
5464               *no_add_attrs = true;
5465             }
5466           else if (TREE_CODE (decl) == VAR_DECL
5467                    && !targetm.have_tls && targetm.emutls.tmpl_section
5468                    && DECL_THREAD_LOCAL_P (decl))
5469             {
5470               error ("section of %q+D cannot be overridden", *node);
5471               *no_add_attrs = true;
5472             }
5473           else
5474             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5475         }
5476       else
5477         {
5478           error ("section attribute not allowed for %q+D", *node);
5479           *no_add_attrs = true;
5480         }
5481     }
5482   else
5483     {
5484       error ("%Jsection attributes are not supported for this target", *node);
5485       *no_add_attrs = true;
5486     }
5487
5488   return NULL_TREE;
5489 }
5490
5491 /* Handle a "aligned" attribute; arguments as in
5492    struct attribute_spec.handler.  */
5493
5494 static tree
5495 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5496                           int flags, bool *no_add_attrs)
5497 {
5498   tree decl = NULL_TREE;
5499   tree *type = NULL;
5500   int is_type = 0;
5501   tree align_expr = (args ? TREE_VALUE (args)
5502                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5503   int i;
5504
5505   if (DECL_P (*node))
5506     {
5507       decl = *node;
5508       type = &TREE_TYPE (decl);
5509       is_type = TREE_CODE (*node) == TYPE_DECL;
5510     }
5511   else if (TYPE_P (*node))
5512     type = node, is_type = 1;
5513
5514   if (TREE_CODE (align_expr) != INTEGER_CST)
5515     {
5516       error ("requested alignment is not a constant");
5517       *no_add_attrs = true;
5518     }
5519   else if ((i = tree_log2 (align_expr)) == -1)
5520     {
5521       error ("requested alignment is not a power of 2");
5522       *no_add_attrs = true;
5523     }
5524   else if (i > HOST_BITS_PER_INT - 2)
5525     {
5526       error ("requested alignment is too large");
5527       *no_add_attrs = true;
5528     }
5529   else if (is_type)
5530     {
5531       /* If we have a TYPE_DECL, then copy the type, so that we
5532          don't accidentally modify a builtin type.  See pushdecl.  */
5533       if (decl && TREE_TYPE (decl) != error_mark_node
5534           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5535         {
5536           tree tt = TREE_TYPE (decl);
5537           *type = build_variant_type_copy (*type);
5538           DECL_ORIGINAL_TYPE (decl) = tt;
5539           TYPE_NAME (*type) = decl;
5540           TREE_USED (*type) = TREE_USED (decl);
5541           TREE_TYPE (decl) = *type;
5542         }
5543       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5544         *type = build_variant_type_copy (*type);
5545
5546       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5547       TYPE_USER_ALIGN (*type) = 1;
5548     }
5549   else if (! VAR_OR_FUNCTION_DECL_P (decl)
5550            && TREE_CODE (decl) != FIELD_DECL)
5551     {
5552       error ("alignment may not be specified for %q+D", decl);
5553       *no_add_attrs = true;
5554     }
5555   else if (TREE_CODE (decl) == FUNCTION_DECL
5556            && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5557     {
5558       if (DECL_USER_ALIGN (decl))
5559         error ("alignment for %q+D was previously specified as %d "
5560                "and may not be decreased", decl,
5561                DECL_ALIGN (decl) / BITS_PER_UNIT);
5562       else
5563         error ("alignment for %q+D must be at least %d", decl,
5564                DECL_ALIGN (decl) / BITS_PER_UNIT);
5565       *no_add_attrs = true;
5566     }
5567   else
5568     {
5569       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5570       DECL_USER_ALIGN (decl) = 1;
5571     }
5572
5573   return NULL_TREE;
5574 }
5575
5576 /* Handle a "weak" attribute; arguments as in
5577    struct attribute_spec.handler.  */
5578
5579 static tree
5580 handle_weak_attribute (tree *node, tree name,
5581                        tree ARG_UNUSED (args),
5582                        int ARG_UNUSED (flags),
5583                        bool * ARG_UNUSED (no_add_attrs))
5584 {
5585   if (TREE_CODE (*node) == FUNCTION_DECL
5586       && DECL_DECLARED_INLINE_P (*node))
5587     {
5588       error ("inline function %q+D cannot be declared weak", *node);
5589       *no_add_attrs = true;
5590     }
5591   else if (TREE_CODE (*node) == FUNCTION_DECL
5592            || TREE_CODE (*node) == VAR_DECL)
5593     declare_weak (*node);
5594   else
5595     warning (OPT_Wattributes, "%qE attribute ignored", name);
5596
5597   return NULL_TREE;
5598 }
5599
5600 /* Handle an "alias" attribute; arguments as in
5601    struct attribute_spec.handler.  */
5602
5603 static tree
5604 handle_alias_attribute (tree *node, tree name, tree args,
5605                         int ARG_UNUSED (flags), bool *no_add_attrs)
5606 {
5607   tree decl = *node;
5608
5609   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5610       || (TREE_CODE (decl) != FUNCTION_DECL
5611           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5612       /* A static variable declaration is always a tentative definition,
5613          but the alias is a non-tentative definition which overrides.  */
5614       || (TREE_CODE (decl) != FUNCTION_DECL
5615           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5616     {
5617       error ("%q+D defined both normally and as an alias", decl);
5618       *no_add_attrs = true;
5619     }
5620
5621   /* Note that the very first time we process a nested declaration,
5622      decl_function_context will not be set.  Indeed, *would* never
5623      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5624      we do below.  After such frobbery, pushdecl would set the context.
5625      In any case, this is never what we want.  */
5626   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5627     {
5628       tree id;
5629
5630       id = TREE_VALUE (args);
5631       if (TREE_CODE (id) != STRING_CST)
5632         {
5633           error ("alias argument not a string");
5634           *no_add_attrs = true;
5635           return NULL_TREE;
5636         }
5637       id = get_identifier (TREE_STRING_POINTER (id));
5638       /* This counts as a use of the object pointed to.  */
5639       TREE_USED (id) = 1;
5640
5641       if (TREE_CODE (decl) == FUNCTION_DECL)
5642         DECL_INITIAL (decl) = error_mark_node;
5643       else
5644         {
5645           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5646             DECL_EXTERNAL (decl) = 1;
5647           else
5648             DECL_EXTERNAL (decl) = 0;
5649           TREE_STATIC (decl) = 1;
5650         }
5651     }
5652   else
5653     {
5654       warning (OPT_Wattributes, "%qE attribute ignored", name);
5655       *no_add_attrs = true;
5656     }
5657
5658   return NULL_TREE;
5659 }
5660
5661 /* Handle a "weakref" attribute; arguments as in struct
5662    attribute_spec.handler.  */
5663
5664 static tree
5665 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5666                           int flags, bool *no_add_attrs)
5667 {
5668   tree attr = NULL_TREE;
5669
5670   /* We must ignore the attribute when it is associated with
5671      local-scoped decls, since attribute alias is ignored and many
5672      such symbols do not even have a DECL_WEAK field.  */
5673   if (decl_function_context (*node) || current_function_decl)
5674     {
5675       warning (OPT_Wattributes, "%qE attribute ignored", name);
5676       *no_add_attrs = true;
5677       return NULL_TREE;
5678     }
5679
5680   /* The idea here is that `weakref("name")' mutates into `weakref,
5681      alias("name")', and weakref without arguments, in turn,
5682      implicitly adds weak. */
5683
5684   if (args)
5685     {
5686       attr = tree_cons (get_identifier ("alias"), args, attr);
5687       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5688
5689       *no_add_attrs = true;
5690
5691       decl_attributes (node, attr, flags);
5692     }
5693   else
5694     {
5695       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5696         error ("%Jweakref attribute must appear before alias attribute",
5697                *node);
5698
5699       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5700          and that isn't supported; and because it wants to add it to
5701          the list of weak decls, which isn't helpful.  */
5702       DECL_WEAK (*node) = 1;
5703     }
5704
5705   return NULL_TREE;
5706 }
5707
5708 /* Handle an "visibility" attribute; arguments as in
5709    struct attribute_spec.handler.  */
5710
5711 static tree
5712 handle_visibility_attribute (tree *node, tree name, tree args,
5713                              int ARG_UNUSED (flags),
5714                              bool *ARG_UNUSED (no_add_attrs))
5715 {
5716   tree decl = *node;
5717   tree id = TREE_VALUE (args);
5718   enum symbol_visibility vis;
5719
5720   if (TYPE_P (*node))
5721     {
5722       if (TREE_CODE (*node) == ENUMERAL_TYPE)
5723         /* OK */;
5724       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5725         {
5726           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5727                    name);
5728           return NULL_TREE;
5729         }
5730       else if (TYPE_FIELDS (*node))
5731         {
5732           error ("%qE attribute ignored because %qT is already defined",
5733                  name, *node);
5734           return NULL_TREE;
5735         }
5736     }
5737   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5738     {
5739       warning (OPT_Wattributes, "%qE attribute ignored", name);
5740       return NULL_TREE;
5741     }
5742
5743   if (TREE_CODE (id) != STRING_CST)
5744     {
5745       error ("visibility argument not a string");
5746       return NULL_TREE;
5747     }
5748
5749   /*  If this is a type, set the visibility on the type decl.  */
5750   if (TYPE_P (decl))
5751     {
5752       decl = TYPE_NAME (decl);
5753       if (!decl)
5754         return NULL_TREE;
5755       if (TREE_CODE (decl) == IDENTIFIER_NODE)
5756         {
5757            warning (OPT_Wattributes, "%qE attribute ignored on types",
5758                     name);
5759            return NULL_TREE;
5760         }
5761     }
5762
5763   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5764     vis = VISIBILITY_DEFAULT;
5765   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5766     vis = VISIBILITY_INTERNAL;
5767   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5768     vis = VISIBILITY_HIDDEN;
5769   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5770     vis = VISIBILITY_PROTECTED;
5771   else
5772     {
5773       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5774       vis = VISIBILITY_DEFAULT;
5775     }
5776
5777   if (DECL_VISIBILITY_SPECIFIED (decl)
5778       && vis != DECL_VISIBILITY (decl))
5779     {
5780       tree attributes = (TYPE_P (*node)
5781                          ? TYPE_ATTRIBUTES (*node)
5782                          : DECL_ATTRIBUTES (decl));
5783       if (lookup_attribute ("visibility", attributes))
5784         error ("%qD redeclared with different visibility", decl);
5785       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5786                && lookup_attribute ("dllimport", attributes))
5787         error ("%qD was declared %qs which implies default visibility",
5788                decl, "dllimport");
5789       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5790                && lookup_attribute ("dllexport", attributes))
5791         error ("%qD was declared %qs which implies default visibility",
5792                decl, "dllexport");
5793     }
5794
5795   DECL_VISIBILITY (decl) = vis;
5796   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5797
5798   /* Go ahead and attach the attribute to the node as well.  This is needed
5799      so we can determine whether we have VISIBILITY_DEFAULT because the
5800      visibility was not specified, or because it was explicitly overridden
5801      from the containing scope.  */
5802
5803   return NULL_TREE;
5804 }
5805
5806 /* Determine the ELF symbol visibility for DECL, which is either a
5807    variable or a function.  It is an error to use this function if a
5808    definition of DECL is not available in this translation unit.
5809    Returns true if the final visibility has been determined by this
5810    function; false if the caller is free to make additional
5811    modifications.  */
5812
5813 bool
5814 c_determine_visibility (tree decl)
5815 {
5816   gcc_assert (TREE_CODE (decl) == VAR_DECL
5817               || TREE_CODE (decl) == FUNCTION_DECL);
5818
5819   /* If the user explicitly specified the visibility with an
5820      attribute, honor that.  DECL_VISIBILITY will have been set during
5821      the processing of the attribute.  We check for an explicit
5822      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5823      to distinguish the use of an attribute from the use of a "#pragma
5824      GCC visibility push(...)"; in the latter case we still want other
5825      considerations to be able to overrule the #pragma.  */
5826   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
5827       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5828           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
5829               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
5830     return true;
5831
5832   /* Set default visibility to whatever the user supplied with
5833      visibility_specified depending on #pragma GCC visibility.  */
5834   if (!DECL_VISIBILITY_SPECIFIED (decl))
5835     {
5836       DECL_VISIBILITY (decl) = default_visibility;
5837       DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5838     }
5839   return false;
5840 }
5841
5842 /* Handle an "tls_model" attribute; arguments as in
5843    struct attribute_spec.handler.  */
5844
5845 static tree
5846 handle_tls_model_attribute (tree *node, tree name, tree args,
5847                             int ARG_UNUSED (flags), bool *no_add_attrs)
5848 {
5849   tree id;
5850   tree decl = *node;
5851   enum tls_model kind;
5852
5853   *no_add_attrs = true;
5854
5855   if (!DECL_THREAD_LOCAL_P (decl))
5856     {
5857       warning (OPT_Wattributes, "%qE attribute ignored", name);
5858       return NULL_TREE;
5859     }
5860
5861   kind = DECL_TLS_MODEL (decl);
5862   id = TREE_VALUE (args);
5863   if (TREE_CODE (id) != STRING_CST)
5864     {
5865       error ("tls_model argument not a string");
5866       return NULL_TREE;
5867     }
5868
5869   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5870     kind = TLS_MODEL_LOCAL_EXEC;
5871   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5872     kind = TLS_MODEL_INITIAL_EXEC;
5873   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5874     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5875   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5876     kind = TLS_MODEL_GLOBAL_DYNAMIC;
5877   else
5878     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5879
5880   DECL_TLS_MODEL (decl) = kind;
5881   return NULL_TREE;
5882 }
5883
5884 /* Handle a "no_instrument_function" attribute; arguments as in
5885    struct attribute_spec.handler.  */
5886
5887 static tree
5888 handle_no_instrument_function_attribute (tree *node, tree name,
5889                                          tree ARG_UNUSED (args),
5890                                          int ARG_UNUSED (flags),
5891                                          bool *no_add_attrs)
5892 {
5893   tree decl = *node;
5894
5895   if (TREE_CODE (decl) != FUNCTION_DECL)
5896     {
5897       error ("%J%qE attribute applies only to functions", decl, name);
5898       *no_add_attrs = true;
5899     }
5900   else if (DECL_INITIAL (decl))
5901     {
5902       error ("%Jcan%'t set %qE attribute after definition", decl, name);
5903       *no_add_attrs = true;
5904     }
5905   else
5906     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5907
5908   return NULL_TREE;
5909 }
5910
5911 /* Handle a "malloc" attribute; arguments as in
5912    struct attribute_spec.handler.  */
5913
5914 static tree
5915 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5916                          int ARG_UNUSED (flags), bool *no_add_attrs)
5917 {
5918   if (TREE_CODE (*node) == FUNCTION_DECL
5919       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5920     DECL_IS_MALLOC (*node) = 1;
5921   else
5922     {
5923       warning (OPT_Wattributes, "%qE attribute ignored", name);
5924       *no_add_attrs = true;
5925     }
5926
5927   return NULL_TREE;
5928 }
5929
5930 /* Handle a "alloc_size" attribute; arguments as in
5931    struct attribute_spec.handler.  */
5932
5933 static tree
5934 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5935                              int ARG_UNUSED (flags), bool *no_add_attrs)
5936 {
5937   unsigned arg_count = type_num_arguments (*node);
5938   for (; args; args = TREE_CHAIN (args))
5939     {
5940       tree position = TREE_VALUE (args);
5941
5942       if (TREE_CODE (position) != INTEGER_CST
5943           || TREE_INT_CST_HIGH (position)
5944           || TREE_INT_CST_LOW (position) < 1
5945           || TREE_INT_CST_LOW (position) > arg_count )
5946         {
5947           warning (OPT_Wattributes,
5948                    "alloc_size parameter outside range");
5949           *no_add_attrs = true;
5950           return NULL_TREE;
5951         }
5952     }
5953   return NULL_TREE;
5954 }
5955
5956 /* Handle a "returns_twice" attribute; arguments as in
5957    struct attribute_spec.handler.  */
5958
5959 static tree
5960 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5961                          int ARG_UNUSED (flags), bool *no_add_attrs)
5962 {
5963   if (TREE_CODE (*node) == FUNCTION_DECL)
5964     DECL_IS_RETURNS_TWICE (*node) = 1;
5965   else
5966     {
5967       warning (OPT_Wattributes, "%qE attribute ignored", name);
5968       *no_add_attrs = true;
5969     }
5970
5971   return NULL_TREE;
5972 }
5973
5974 /* Handle a "no_limit_stack" attribute; arguments as in
5975    struct attribute_spec.handler.  */
5976
5977 static tree
5978 handle_no_limit_stack_attribute (tree *node, tree name,
5979                                  tree ARG_UNUSED (args),
5980                                  int ARG_UNUSED (flags),
5981                                  bool *no_add_attrs)
5982 {
5983   tree decl = *node;
5984
5985   if (TREE_CODE (decl) != FUNCTION_DECL)
5986     {
5987       error ("%J%qE attribute applies only to functions", decl, name);
5988       *no_add_attrs = true;
5989     }
5990   else if (DECL_INITIAL (decl))
5991     {
5992       error ("%Jcan%'t set %qE attribute after definition", decl, name);
5993       *no_add_attrs = true;
5994     }
5995   else
5996     DECL_NO_LIMIT_STACK (decl) = 1;
5997
5998   return NULL_TREE;
5999 }
6000
6001 /* Handle a "pure" attribute; arguments as in
6002    struct attribute_spec.handler.  */
6003
6004 static tree
6005 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6006                        int ARG_UNUSED (flags), bool *no_add_attrs)
6007 {
6008   if (TREE_CODE (*node) == FUNCTION_DECL)
6009     DECL_PURE_P (*node) = 1;
6010   /* ??? TODO: Support types.  */
6011   else
6012     {
6013       warning (OPT_Wattributes, "%qE attribute ignored", name);
6014       *no_add_attrs = true;
6015     }
6016
6017   return NULL_TREE;
6018 }
6019
6020 /* Handle a "no vops" attribute; arguments as in
6021    struct attribute_spec.handler.  */
6022
6023 static tree
6024 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6025                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6026                          bool *ARG_UNUSED (no_add_attrs))
6027 {
6028   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6029   DECL_IS_NOVOPS (*node) = 1;
6030   return NULL_TREE;
6031 }
6032
6033 /* Handle a "deprecated" attribute; arguments as in
6034    struct attribute_spec.handler.  */
6035
6036 static tree
6037 handle_deprecated_attribute (tree *node, tree name,
6038                              tree ARG_UNUSED (args), int flags,
6039                              bool *no_add_attrs)
6040 {
6041   tree type = NULL_TREE;
6042   int warn = 0;
6043   tree what = NULL_TREE;
6044
6045   if (DECL_P (*node))
6046     {
6047       tree decl = *node;
6048       type = TREE_TYPE (decl);
6049
6050       if (TREE_CODE (decl) == TYPE_DECL
6051           || TREE_CODE (decl) == PARM_DECL
6052           || TREE_CODE (decl) == VAR_DECL
6053           || TREE_CODE (decl) == FUNCTION_DECL
6054           || TREE_CODE (decl) == FIELD_DECL)
6055         TREE_DEPRECATED (decl) = 1;
6056       else
6057         warn = 1;
6058     }
6059   else if (TYPE_P (*node))
6060     {
6061       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6062         *node = build_variant_type_copy (*node);
6063       TREE_DEPRECATED (*node) = 1;
6064       type = *node;
6065     }
6066   else
6067     warn = 1;
6068
6069   if (warn)
6070     {
6071       *no_add_attrs = true;
6072       if (type && TYPE_NAME (type))
6073         {
6074           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6075             what = TYPE_NAME (*node);
6076           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6077                    && DECL_NAME (TYPE_NAME (type)))
6078             what = DECL_NAME (TYPE_NAME (type));
6079         }
6080       if (what)
6081         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6082       else
6083         warning (OPT_Wattributes, "%qE attribute ignored", name);
6084     }
6085
6086   return NULL_TREE;
6087 }
6088
6089 /* Handle a "vector_size" attribute; arguments as in
6090    struct attribute_spec.handler.  */
6091
6092 static tree
6093 handle_vector_size_attribute (tree *node, tree name, tree args,
6094                               int ARG_UNUSED (flags),
6095                               bool *no_add_attrs)
6096 {
6097   unsigned HOST_WIDE_INT vecsize, nunits;
6098   enum machine_mode orig_mode;
6099   tree type = *node, new_type, size;
6100
6101   *no_add_attrs = true;
6102
6103   size = TREE_VALUE (args);
6104
6105   if (!host_integerp (size, 1))
6106     {
6107       warning (OPT_Wattributes, "%qE attribute ignored", name);
6108       return NULL_TREE;
6109     }
6110
6111   /* Get the vector size (in bytes).  */
6112   vecsize = tree_low_cst (size, 1);
6113
6114   /* We need to provide for vector pointers, vector arrays, and
6115      functions returning vectors.  For example:
6116
6117        __attribute__((vector_size(16))) short *foo;
6118
6119      In this case, the mode is SI, but the type being modified is
6120      HI, so we need to look further.  */
6121
6122   while (POINTER_TYPE_P (type)
6123          || TREE_CODE (type) == FUNCTION_TYPE
6124          || TREE_CODE (type) == METHOD_TYPE
6125          || TREE_CODE (type) == ARRAY_TYPE
6126          || TREE_CODE (type) == OFFSET_TYPE)
6127     type = TREE_TYPE (type);
6128
6129   /* Get the mode of the type being modified.  */
6130   orig_mode = TYPE_MODE (type);
6131
6132   if ((!INTEGRAL_TYPE_P (type)
6133        && !SCALAR_FLOAT_TYPE_P (type)
6134        && !FIXED_POINT_TYPE_P (type))
6135       || (!SCALAR_FLOAT_MODE_P (orig_mode)
6136           && GET_MODE_CLASS (orig_mode) != MODE_INT
6137           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6138       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
6139     {
6140       error ("invalid vector type for attribute %qE", name);
6141       return NULL_TREE;
6142     }
6143
6144   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6145     {
6146       error ("vector size not an integral multiple of component size");
6147       return NULL;
6148     }
6149
6150   if (vecsize == 0)
6151     {
6152       error ("zero vector size");
6153       return NULL;
6154     }
6155
6156   /* Calculate how many units fit in the vector.  */
6157   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6158   if (nunits & (nunits - 1))
6159     {
6160       error ("number of components of the vector not a power of two");
6161       return NULL_TREE;
6162     }
6163
6164   new_type = build_vector_type (type, nunits);
6165
6166   /* Build back pointers if needed.  */
6167   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6168
6169   return NULL_TREE;
6170 }
6171
6172 /* Handle the "nonnull" attribute.  */
6173 static tree
6174 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6175                           tree args, int ARG_UNUSED (flags),
6176                           bool *no_add_attrs)
6177 {
6178   tree type = *node;
6179   unsigned HOST_WIDE_INT attr_arg_num;
6180
6181   /* If no arguments are specified, all pointer arguments should be
6182      non-null.  Verify a full prototype is given so that the arguments
6183      will have the correct types when we actually check them later.  */
6184   if (!args)
6185     {
6186       if (!TYPE_ARG_TYPES (type))
6187         {
6188           error ("nonnull attribute without arguments on a non-prototype");
6189           *no_add_attrs = true;
6190         }
6191       return NULL_TREE;
6192     }
6193
6194   /* Argument list specified.  Verify that each argument number references
6195      a pointer argument.  */
6196   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6197     {
6198       tree argument;
6199       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6200
6201       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6202         {
6203           error ("nonnull argument has invalid operand number (argument %lu)",
6204                  (unsigned long) attr_arg_num);
6205           *no_add_attrs = true;
6206           return NULL_TREE;
6207         }
6208
6209       argument = TYPE_ARG_TYPES (type);
6210       if (argument)
6211         {
6212           for (ck_num = 1; ; ck_num++)
6213             {
6214               if (!argument || ck_num == arg_num)
6215                 break;
6216               argument = TREE_CHAIN (argument);
6217             }
6218
6219           if (!argument
6220               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6221             {
6222               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6223                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
6224               *no_add_attrs = true;
6225               return NULL_TREE;
6226             }
6227
6228           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6229             {
6230               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6231                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
6232               *no_add_attrs = true;
6233               return NULL_TREE;
6234             }
6235         }
6236     }
6237
6238   return NULL_TREE;
6239 }
6240
6241 /* Check the argument list of a function call for null in argument slots
6242    that are marked as requiring a non-null pointer argument.  The NARGS
6243    arguments are passed in the array ARGARRAY.
6244 */
6245
6246 static void
6247 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6248 {
6249   tree a, args;
6250   int i;
6251
6252   for (a = attrs; a; a = TREE_CHAIN (a))
6253     {
6254       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6255         {
6256           args = TREE_VALUE (a);
6257
6258           /* Walk the argument list.  If we encounter an argument number we
6259              should check for non-null, do it.  If the attribute has no args,
6260              then every pointer argument is checked (in which case the check
6261              for pointer type is done in check_nonnull_arg).  */
6262           for (i = 0; i < nargs; i++)
6263             {
6264               if (!args || nonnull_check_p (args, i + 1))
6265                 check_function_arguments_recurse (check_nonnull_arg, NULL,
6266                                                   argarray[i],
6267                                                   i + 1);
6268             }
6269         }
6270     }
6271 }
6272
6273 /* Check that the Nth argument of a function call (counting backwards
6274    from the end) is a (pointer)0.  The NARGS arguments are passed in the
6275    array ARGARRAY.  */
6276
6277 static void
6278 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6279 {
6280   tree attr = lookup_attribute ("sentinel", attrs);
6281
6282   if (attr)
6283     {
6284       int len = 0;
6285       int pos = 0;
6286       tree sentinel;
6287
6288       /* Skip over the named arguments.  */
6289       while (typelist && len < nargs)
6290         {
6291           typelist = TREE_CHAIN (typelist);
6292           len++;
6293         }
6294
6295       if (TREE_VALUE (attr))
6296         {
6297           tree p = TREE_VALUE (TREE_VALUE (attr));
6298           pos = TREE_INT_CST_LOW (p);
6299         }
6300
6301       /* The sentinel must be one of the varargs, i.e.
6302          in position >= the number of fixed arguments.  */
6303       if ((nargs - 1 - pos) < len)
6304         {
6305           warning (OPT_Wformat,
6306                    "not enough variable arguments to fit a sentinel");
6307           return;
6308         }
6309
6310       /* Validate the sentinel.  */
6311       sentinel = argarray[nargs - 1 - pos];
6312       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6313            || !integer_zerop (sentinel))
6314           /* Although __null (in C++) is only an integer we allow it
6315              nevertheless, as we are guaranteed that it's exactly
6316              as wide as a pointer, and we don't want to force
6317              users to cast the NULL they have written there.
6318              We warn with -Wstrict-null-sentinel, though.  */
6319           && (warn_strict_null_sentinel || null_node != sentinel))
6320         warning (OPT_Wformat, "missing sentinel in function call");
6321     }
6322 }
6323
6324 /* Helper for check_function_nonnull; given a list of operands which
6325    must be non-null in ARGS, determine if operand PARAM_NUM should be
6326    checked.  */
6327
6328 static bool
6329 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6330 {
6331   unsigned HOST_WIDE_INT arg_num = 0;
6332
6333   for (; args; args = TREE_CHAIN (args))
6334     {
6335       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6336
6337       gcc_assert (found);
6338
6339       if (arg_num == param_num)
6340         return true;
6341     }
6342   return false;
6343 }
6344
6345 /* Check that the function argument PARAM (which is operand number
6346    PARAM_NUM) is non-null.  This is called by check_function_nonnull
6347    via check_function_arguments_recurse.  */
6348
6349 static void
6350 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6351                    unsigned HOST_WIDE_INT param_num)
6352 {
6353   /* Just skip checking the argument if it's not a pointer.  This can
6354      happen if the "nonnull" attribute was given without an operand
6355      list (which means to check every pointer argument).  */
6356
6357   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6358     return;
6359
6360   if (integer_zerop (param))
6361     warning (OPT_Wnonnull, "null argument where non-null required "
6362              "(argument %lu)", (unsigned long) param_num);
6363 }
6364
6365 /* Helper for nonnull attribute handling; fetch the operand number
6366    from the attribute argument list.  */
6367
6368 static bool
6369 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6370 {
6371   /* Verify the arg number is a constant.  */
6372   if (TREE_CODE (arg_num_expr) != INTEGER_CST
6373       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6374     return false;
6375
6376   *valp = TREE_INT_CST_LOW (arg_num_expr);
6377   return true;
6378 }
6379
6380 /* Handle a "nothrow" attribute; arguments as in
6381    struct attribute_spec.handler.  */
6382
6383 static tree
6384 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6385                           int ARG_UNUSED (flags), bool *no_add_attrs)
6386 {
6387   if (TREE_CODE (*node) == FUNCTION_DECL)
6388     TREE_NOTHROW (*node) = 1;
6389   /* ??? TODO: Support types.  */
6390   else
6391     {
6392       warning (OPT_Wattributes, "%qE attribute ignored", name);
6393       *no_add_attrs = true;
6394     }
6395
6396   return NULL_TREE;
6397 }
6398
6399 /* Handle a "cleanup" attribute; arguments as in
6400    struct attribute_spec.handler.  */
6401
6402 static tree
6403 handle_cleanup_attribute (tree *node, tree name, tree args,
6404                           int ARG_UNUSED (flags), bool *no_add_attrs)
6405 {
6406   tree decl = *node;
6407   tree cleanup_id, cleanup_decl;
6408
6409   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6410      for global destructors in C++.  This requires infrastructure that
6411      we don't have generically at the moment.  It's also not a feature
6412      we'd be missing too much, since we do have attribute constructor.  */
6413   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6414     {
6415       warning (OPT_Wattributes, "%qE attribute ignored", name);
6416       *no_add_attrs = true;
6417       return NULL_TREE;
6418     }
6419
6420   /* Verify that the argument is a function in scope.  */
6421   /* ??? We could support pointers to functions here as well, if
6422      that was considered desirable.  */
6423   cleanup_id = TREE_VALUE (args);
6424   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6425     {
6426       error ("cleanup argument not an identifier");
6427       *no_add_attrs = true;
6428       return NULL_TREE;
6429     }
6430   cleanup_decl = lookup_name (cleanup_id);
6431   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6432     {
6433       error ("cleanup argument not a function");
6434       *no_add_attrs = true;
6435       return NULL_TREE;
6436     }
6437
6438   /* That the function has proper type is checked with the
6439      eventual call to build_function_call.  */
6440
6441   return NULL_TREE;
6442 }
6443
6444 /* Handle a "warn_unused_result" attribute.  No special handling.  */
6445
6446 static tree
6447 handle_warn_unused_result_attribute (tree *node, tree name,
6448                                tree ARG_UNUSED (args),
6449                                int ARG_UNUSED (flags), bool *no_add_attrs)
6450 {
6451   /* Ignore the attribute for functions not returning any value.  */
6452   if (VOID_TYPE_P (TREE_TYPE (*node)))
6453     {
6454       warning (OPT_Wattributes, "%qE attribute ignored", name);
6455       *no_add_attrs = true;
6456     }
6457
6458   return NULL_TREE;
6459 }
6460
6461 /* Handle a "sentinel" attribute.  */
6462
6463 static tree
6464 handle_sentinel_attribute (tree *node, tree name, tree args,
6465                            int ARG_UNUSED (flags), bool *no_add_attrs)
6466 {
6467   tree params = TYPE_ARG_TYPES (*node);
6468
6469   if (!params)
6470     {
6471       warning (OPT_Wattributes,
6472                "%qE attribute requires prototypes with named arguments", name);
6473       *no_add_attrs = true;
6474     }
6475   else
6476     {
6477       while (TREE_CHAIN (params))
6478         params = TREE_CHAIN (params);
6479
6480       if (VOID_TYPE_P (TREE_VALUE (params)))
6481         {
6482           warning (OPT_Wattributes,
6483                    "%qE attribute only applies to variadic functions", name);
6484           *no_add_attrs = true;
6485         }
6486     }
6487
6488   if (args)
6489     {
6490       tree position = TREE_VALUE (args);
6491
6492       if (TREE_CODE (position) != INTEGER_CST)
6493         {
6494           warning (OPT_Wattributes,
6495                    "requested position is not an integer constant");
6496           *no_add_attrs = true;
6497         }
6498       else
6499         {
6500           if (tree_int_cst_lt (position, integer_zero_node))
6501             {
6502               warning (OPT_Wattributes,
6503                        "requested position is less than zero");
6504               *no_add_attrs = true;
6505             }
6506         }
6507     }
6508
6509   return NULL_TREE;
6510 }
6511
6512 /* Handle a "type_generic" attribute.  */
6513
6514 static tree
6515 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6516                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6517                                bool * ARG_UNUSED (no_add_attrs))
6518 {
6519   tree params;
6520
6521   /* Ensure we have a function type.  */
6522   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6523
6524   params = TYPE_ARG_TYPES (*node);
6525   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6526     params = TREE_CHAIN (params);
6527
6528   /* Ensure we have a variadic function.  */
6529   gcc_assert (!params);
6530
6531   return NULL_TREE;
6532 }
6533 \f
6534 /* Check for valid arguments being passed to a function.
6535    ATTRS is a list of attributes.  There are NARGS arguments in the array
6536    ARGARRAY.  TYPELIST is the list of argument types for the function.
6537  */
6538 void
6539 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
6540 {
6541   /* Check for null being passed in a pointer argument that must be
6542      non-null.  We also need to do this if format checking is enabled.  */
6543
6544   if (warn_nonnull)
6545     check_function_nonnull (attrs, nargs, argarray);
6546
6547   /* Check for errors in format strings.  */
6548
6549   if (warn_format || warn_missing_format_attribute)
6550     check_function_format (attrs, nargs, argarray);
6551
6552   if (warn_format)
6553     check_function_sentinel (attrs, nargs, argarray, typelist);
6554 }
6555
6556 /* Generic argument checking recursion routine.  PARAM is the argument to
6557    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
6558    once the argument is resolved.  CTX is context for the callback.  */
6559 void
6560 check_function_arguments_recurse (void (*callback)
6561                                   (void *, tree, unsigned HOST_WIDE_INT),
6562                                   void *ctx, tree param,
6563                                   unsigned HOST_WIDE_INT param_num)
6564 {
6565   if (CONVERT_EXPR_P (param)
6566       && (TYPE_PRECISION (TREE_TYPE (param))
6567           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6568     {
6569       /* Strip coercion.  */
6570       check_function_arguments_recurse (callback, ctx,
6571                                         TREE_OPERAND (param, 0), param_num);
6572       return;
6573     }
6574
6575   if (TREE_CODE (param) == CALL_EXPR)
6576     {
6577       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6578       tree attrs;
6579       bool found_format_arg = false;
6580
6581       /* See if this is a call to a known internationalization function
6582          that modifies a format arg.  Such a function may have multiple
6583          format_arg attributes (for example, ngettext).  */
6584
6585       for (attrs = TYPE_ATTRIBUTES (type);
6586            attrs;
6587            attrs = TREE_CHAIN (attrs))
6588         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6589           {
6590             tree inner_arg;
6591             tree format_num_expr;
6592             int format_num;
6593             int i;
6594             call_expr_arg_iterator iter;
6595
6596             /* Extract the argument number, which was previously checked
6597                to be valid.  */
6598             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6599
6600             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6601                         && !TREE_INT_CST_HIGH (format_num_expr));
6602
6603             format_num = TREE_INT_CST_LOW (format_num_expr);
6604
6605             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6606                  inner_arg != 0;
6607                  inner_arg = next_call_expr_arg (&iter), i++)
6608               if (i == format_num)
6609                 {
6610                   check_function_arguments_recurse (callback, ctx,
6611                                                     inner_arg, param_num);
6612                   found_format_arg = true;
6613                   break;
6614                 }
6615           }
6616
6617       /* If we found a format_arg attribute and did a recursive check,
6618          we are done with checking this argument.  Otherwise, we continue
6619          and this will be considered a non-literal.  */
6620       if (found_format_arg)
6621         return;
6622     }
6623
6624   if (TREE_CODE (param) == COND_EXPR)
6625     {
6626       /* Check both halves of the conditional expression.  */
6627       check_function_arguments_recurse (callback, ctx,
6628                                         TREE_OPERAND (param, 1), param_num);
6629       check_function_arguments_recurse (callback, ctx,
6630                                         TREE_OPERAND (param, 2), param_num);
6631       return;
6632     }
6633
6634   (*callback) (ctx, param, param_num);
6635 }
6636
6637 /* Checks the number of arguments NARGS against the required number
6638    REQUIRED and issues an error if there is a mismatch.  Returns true
6639    if the number of arguments is correct, otherwise false.  */
6640
6641 static bool
6642 validate_nargs (tree fndecl, int nargs, int required)
6643 {
6644   if (nargs < required)
6645     {
6646       error ("not enough arguments to function %qE", fndecl);
6647       return false;
6648     }
6649   else if (nargs > required)
6650     {
6651       error ("too many arguments to function %qE", fndecl);
6652       return false;
6653     }
6654   return true;
6655 }
6656
6657 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
6658    Returns false if there was an error, otherwise true.  */
6659
6660 bool
6661 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
6662 {
6663   if (!DECL_BUILT_IN (fndecl)
6664       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
6665     return true;
6666
6667   switch (DECL_FUNCTION_CODE (fndecl))
6668     {
6669     case BUILT_IN_CONSTANT_P:
6670       return validate_nargs (fndecl, nargs, 1);
6671
6672     case BUILT_IN_ISFINITE:
6673     case BUILT_IN_ISINF:
6674     case BUILT_IN_ISINF_SIGN:
6675     case BUILT_IN_ISNAN:
6676     case BUILT_IN_ISNORMAL:
6677       if (validate_nargs (fndecl, nargs, 1))
6678         {
6679           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
6680             {
6681               error ("non-floating-point argument in call to "
6682                      "function %qE", fndecl);
6683               return false;
6684             }
6685           return true;
6686         }
6687       return false;
6688
6689     case BUILT_IN_ISGREATER:
6690     case BUILT_IN_ISGREATEREQUAL:
6691     case BUILT_IN_ISLESS:
6692     case BUILT_IN_ISLESSEQUAL:
6693     case BUILT_IN_ISLESSGREATER:
6694     case BUILT_IN_ISUNORDERED:
6695       if (validate_nargs (fndecl, nargs, 2))
6696         {
6697           enum tree_code code0, code1;
6698           code0 = TREE_CODE (TREE_TYPE (args[0]));
6699           code1 = TREE_CODE (TREE_TYPE (args[1]));
6700           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
6701                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
6702                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
6703             {
6704               error ("non-floating-point arguments in call to "
6705                      "function %qE", fndecl);
6706               return false;
6707             }
6708           return true;
6709         }
6710       return false;
6711
6712     case BUILT_IN_FPCLASSIFY:
6713       if (validate_nargs (fndecl, nargs, 6))
6714         {
6715           unsigned i;
6716
6717           for (i=0; i<5; i++)
6718             if (TREE_CODE (args[i]) != INTEGER_CST)
6719               {
6720                 error ("non-const integer argument %u in call to function %qE",
6721                        i+1, fndecl);
6722                 return false;
6723               }
6724
6725           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
6726             {
6727               error ("non-floating-point argument in call to function %qE",
6728                      fndecl);
6729               return false;
6730             }
6731           return true;
6732         }
6733       return false;
6734
6735     default:
6736       return true;
6737     }
6738 }
6739
6740 /* Function to help qsort sort FIELD_DECLs by name order.  */
6741
6742 int
6743 field_decl_cmp (const void *x_p, const void *y_p)
6744 {
6745   const tree *const x = (const tree *const) x_p;
6746   const tree *const y = (const tree *const) y_p;
6747
6748   if (DECL_NAME (*x) == DECL_NAME (*y))
6749     /* A nontype is "greater" than a type.  */
6750     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6751   if (DECL_NAME (*x) == NULL_TREE)
6752     return -1;
6753   if (DECL_NAME (*y) == NULL_TREE)
6754     return 1;
6755   if (DECL_NAME (*x) < DECL_NAME (*y))
6756     return -1;
6757   return 1;
6758 }
6759
6760 static struct {
6761   gt_pointer_operator new_value;
6762   void *cookie;
6763 } resort_data;
6764
6765 /* This routine compares two fields like field_decl_cmp but using the
6766 pointer operator in resort_data.  */
6767
6768 static int
6769 resort_field_decl_cmp (const void *x_p, const void *y_p)
6770 {
6771   const tree *const x = (const tree *const) x_p;
6772   const tree *const y = (const tree *const) y_p;
6773
6774   if (DECL_NAME (*x) == DECL_NAME (*y))
6775     /* A nontype is "greater" than a type.  */
6776     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6777   if (DECL_NAME (*x) == NULL_TREE)
6778     return -1;
6779   if (DECL_NAME (*y) == NULL_TREE)
6780     return 1;
6781   {
6782     tree d1 = DECL_NAME (*x);
6783     tree d2 = DECL_NAME (*y);
6784     resort_data.new_value (&d1, resort_data.cookie);
6785     resort_data.new_value (&d2, resort_data.cookie);
6786     if (d1 < d2)
6787       return -1;
6788   }
6789   return 1;
6790 }
6791
6792 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
6793
6794 void
6795 resort_sorted_fields (void *obj,
6796                       void * ARG_UNUSED (orig_obj),
6797                       gt_pointer_operator new_value,
6798                       void *cookie)
6799 {
6800   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6801   resort_data.new_value = new_value;
6802   resort_data.cookie = cookie;
6803   qsort (&sf->elts[0], sf->len, sizeof (tree),
6804          resort_field_decl_cmp);
6805 }
6806
6807 /* Subroutine of c_parse_error.
6808    Return the result of concatenating LHS and RHS. RHS is really
6809    a string literal, its first character is indicated by RHS_START and
6810    RHS_SIZE is its length (including the terminating NUL character).
6811
6812    The caller is responsible for deleting the returned pointer.  */
6813
6814 static char *
6815 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6816 {
6817   const int lhs_size = strlen (lhs);
6818   char *result = XNEWVEC (char, lhs_size + rhs_size);
6819   strncpy (result, lhs, lhs_size);
6820   strncpy (result + lhs_size, rhs_start, rhs_size);
6821   return result;
6822 }
6823
6824 /* Issue the error given by GMSGID, indicating that it occurred before
6825    TOKEN, which had the associated VALUE.  */
6826
6827 void
6828 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6829 {
6830 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6831
6832   char *message = NULL;
6833
6834   if (token == CPP_EOF)
6835     message = catenate_messages (gmsgid, " at end of input");
6836   else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
6837            || token == CPP_CHAR32)
6838     {
6839       unsigned int val = TREE_INT_CST_LOW (value);
6840       const char *prefix;
6841
6842       switch (token)
6843         {
6844         default:
6845           prefix = "";
6846           break;
6847         case CPP_WCHAR:
6848           prefix = "L";
6849           break;
6850         case CPP_CHAR16:
6851           prefix = "u";
6852           break;
6853         case CPP_CHAR32:
6854           prefix = "U";
6855           break;
6856         }
6857
6858       if (val <= UCHAR_MAX && ISGRAPH (val))
6859         message = catenate_messages (gmsgid, " before %s'%c'");
6860       else
6861         message = catenate_messages (gmsgid, " before %s'\\x%x'");
6862
6863       error (message, prefix, val);
6864       free (message);
6865       message = NULL;
6866     }
6867   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
6868            || token == CPP_STRING32)
6869     message = catenate_messages (gmsgid, " before string constant");
6870   else if (token == CPP_NUMBER)
6871     message = catenate_messages (gmsgid, " before numeric constant");
6872   else if (token == CPP_NAME)
6873     {
6874       message = catenate_messages (gmsgid, " before %qE");
6875       error (message, value);
6876       free (message);
6877       message = NULL;
6878     }
6879   else if (token == CPP_PRAGMA)
6880     message = catenate_messages (gmsgid, " before %<#pragma%>");
6881   else if (token == CPP_PRAGMA_EOL)
6882     message = catenate_messages (gmsgid, " before end of line");
6883   else if (token < N_TTYPES)
6884     {
6885       message = catenate_messages (gmsgid, " before %qs token");
6886       error (message, cpp_type2name (token));
6887       free (message);
6888       message = NULL;
6889     }
6890   else
6891     error (gmsgid);
6892
6893   if (message)
6894     {
6895       error (message);
6896       free (message);
6897     }
6898 #undef catenate_messages
6899 }
6900
6901 /* Walk a gimplified function and warn for functions whose return value is
6902    ignored and attribute((warn_unused_result)) is set.  This is done before
6903    inlining, so we don't have to worry about that.  */
6904
6905 void
6906 c_warn_unused_result (tree *top_p)
6907 {
6908   tree t = *top_p;
6909   tree_stmt_iterator i;
6910   tree fdecl, ftype;
6911
6912   switch (TREE_CODE (t))
6913     {
6914     case STATEMENT_LIST:
6915       for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6916         c_warn_unused_result (tsi_stmt_ptr (i));
6917       break;
6918
6919     case COND_EXPR:
6920       c_warn_unused_result (&COND_EXPR_THEN (t));
6921       c_warn_unused_result (&COND_EXPR_ELSE (t));
6922       break;
6923     case BIND_EXPR:
6924       c_warn_unused_result (&BIND_EXPR_BODY (t));
6925       break;
6926     case TRY_FINALLY_EXPR:
6927     case TRY_CATCH_EXPR:
6928       c_warn_unused_result (&TREE_OPERAND (t, 0));
6929       c_warn_unused_result (&TREE_OPERAND (t, 1));
6930       break;
6931     case CATCH_EXPR:
6932       c_warn_unused_result (&CATCH_BODY (t));
6933       break;
6934     case EH_FILTER_EXPR:
6935       c_warn_unused_result (&EH_FILTER_FAILURE (t));
6936       break;
6937
6938     case CALL_EXPR:
6939       if (TREE_USED (t))
6940         break;
6941
6942       /* This is a naked call, as opposed to a CALL_EXPR nested inside
6943          a MODIFY_EXPR.  All calls whose value is ignored should be
6944          represented like this.  Look for the attribute.  */
6945       fdecl = get_callee_fndecl (t);
6946       if (fdecl)
6947         ftype = TREE_TYPE (fdecl);
6948       else
6949         {
6950           ftype = TREE_TYPE (CALL_EXPR_FN (t));
6951           /* Look past pointer-to-function to the function type itself.  */
6952           ftype = TREE_TYPE (ftype);
6953         }
6954
6955       if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6956         {
6957           if (fdecl)
6958             warning (0, "%Hignoring return value of %qD, "
6959                      "declared with attribute warn_unused_result",
6960                      EXPR_LOCUS (t), fdecl);
6961           else
6962             warning (0, "%Hignoring return value of function "
6963                      "declared with attribute warn_unused_result",
6964                      EXPR_LOCUS (t));
6965         }
6966       break;
6967
6968     default:
6969       /* Not a container, not a call, or a call whose value is used.  */
6970       break;
6971     }
6972 }
6973
6974 /* Convert a character from the host to the target execution character
6975    set.  cpplib handles this, mostly.  */
6976
6977 HOST_WIDE_INT
6978 c_common_to_target_charset (HOST_WIDE_INT c)
6979 {
6980   /* Character constants in GCC proper are sign-extended under -fsigned-char,
6981      zero-extended under -fno-signed-char.  cpplib insists that characters
6982      and character constants are always unsigned.  Hence we must convert
6983      back and forth.  */
6984   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6985
6986   uc = cpp_host_to_exec_charset (parse_in, uc);
6987
6988   if (flag_signed_char)
6989     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6990                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6991   else
6992     return uc;
6993 }
6994
6995 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
6996    component references, with STOP_REF, or alternatively an INDIRECT_REF of
6997    NULL, at the bottom; much like the traditional rendering of offsetof as a
6998    macro.  Returns the folded and properly cast result.  */
6999
7000 static tree
7001 fold_offsetof_1 (tree expr, tree stop_ref)
7002 {
7003   enum tree_code code = PLUS_EXPR;
7004   tree base, off, t;
7005
7006   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7007     return size_zero_node;
7008
7009   switch (TREE_CODE (expr))
7010     {
7011     case ERROR_MARK:
7012       return expr;
7013
7014     case VAR_DECL:
7015       error ("cannot apply %<offsetof%> to static data member %qD", expr);
7016       return error_mark_node;
7017
7018     case CALL_EXPR:
7019       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7020       return error_mark_node;
7021
7022     case INTEGER_CST:
7023       gcc_assert (integer_zerop (expr));
7024       return size_zero_node;
7025
7026     case NOP_EXPR:
7027     case INDIRECT_REF:
7028       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7029       gcc_assert (base == error_mark_node || base == size_zero_node);
7030       return base;
7031
7032     case COMPONENT_REF:
7033       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7034       if (base == error_mark_node)
7035         return base;
7036
7037       t = TREE_OPERAND (expr, 1);
7038       if (DECL_C_BIT_FIELD (t))
7039         {
7040           error ("attempt to take address of bit-field structure "
7041                  "member %qD", t);
7042           return error_mark_node;
7043         }
7044       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7045                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7046                                   / BITS_PER_UNIT));
7047       break;
7048
7049     case ARRAY_REF:
7050       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7051       if (base == error_mark_node)
7052         return base;
7053
7054       t = TREE_OPERAND (expr, 1);
7055       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7056         {
7057           code = MINUS_EXPR;
7058           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7059         }
7060       t = convert (sizetype, t);
7061       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7062       break;
7063
7064     case COMPOUND_EXPR:
7065       /* Handle static members of volatile structs.  */
7066       t = TREE_OPERAND (expr, 1);
7067       gcc_assert (TREE_CODE (t) == VAR_DECL);
7068       return fold_offsetof_1 (t, stop_ref);
7069
7070     default:
7071       gcc_unreachable ();
7072     }
7073
7074   return size_binop (code, base, off);
7075 }
7076
7077 tree
7078 fold_offsetof (tree expr, tree stop_ref)
7079 {
7080   /* Convert back from the internal sizetype to size_t.  */
7081   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7082 }
7083
7084 /* Print an error message for an invalid lvalue.  USE says
7085    how the lvalue is being used and so selects the error message.  */
7086
7087 void
7088 lvalue_error (enum lvalue_use use)
7089 {
7090   switch (use)
7091     {
7092     case lv_assign:
7093       error ("lvalue required as left operand of assignment");
7094       break;
7095     case lv_increment:
7096       error ("lvalue required as increment operand");
7097       break;
7098     case lv_decrement:
7099       error ("lvalue required as decrement operand");
7100       break;
7101     case lv_addressof:
7102       error ("lvalue required as unary %<&%> operand");
7103       break;
7104     case lv_asm:
7105       error ("lvalue required in asm statement");
7106       break;
7107     default:
7108       gcc_unreachable ();
7109     }
7110 }
7111 \f
7112 /* *PTYPE is an incomplete array.  Complete it with a domain based on
7113    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7114    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7115    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
7116
7117 int
7118 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7119 {
7120   tree maxindex, type, main_type, elt, unqual_elt;
7121   int failure = 0, quals;
7122   hashval_t hashcode = 0;
7123
7124   maxindex = size_zero_node;
7125   if (initial_value)
7126     {
7127       if (TREE_CODE (initial_value) == STRING_CST)
7128         {
7129           int eltsize
7130             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7131           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7132         }
7133       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7134         {
7135           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7136
7137           if (VEC_empty (constructor_elt, v))
7138             {
7139               if (pedantic)
7140                 failure = 3;
7141               maxindex = integer_minus_one_node;
7142             }
7143           else
7144             {
7145               tree curindex;
7146               unsigned HOST_WIDE_INT cnt;
7147               constructor_elt *ce;
7148
7149               if (VEC_index (constructor_elt, v, 0)->index)
7150                 maxindex = fold_convert (sizetype,
7151                                          VEC_index (constructor_elt,
7152                                                     v, 0)->index);
7153               curindex = maxindex;
7154
7155               for (cnt = 1;
7156                    VEC_iterate (constructor_elt, v, cnt, ce);
7157                    cnt++)
7158                 {
7159                   if (ce->index)
7160                     curindex = fold_convert (sizetype, ce->index);
7161                   else
7162                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7163
7164                   if (tree_int_cst_lt (maxindex, curindex))
7165                     maxindex = curindex;
7166                 }
7167             }
7168         }
7169       else
7170         {
7171           /* Make an error message unless that happened already.  */
7172           if (initial_value != error_mark_node)
7173             failure = 1;
7174         }
7175     }
7176   else
7177     {
7178       failure = 2;
7179       if (!do_default)
7180         return failure;
7181     }
7182
7183   type = *ptype;
7184   elt = TREE_TYPE (type);
7185   quals = TYPE_QUALS (strip_array_types (elt));
7186   if (quals == 0)
7187     unqual_elt = elt;
7188   else
7189     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7190
7191   /* Using build_distinct_type_copy and modifying things afterward instead
7192      of using build_array_type to create a new type preserves all of the
7193      TYPE_LANG_FLAG_? bits that the front end may have set.  */
7194   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7195   TREE_TYPE (main_type) = unqual_elt;
7196   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7197   layout_type (main_type);
7198
7199   /* Make sure we have the canonical MAIN_TYPE. */
7200   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7201   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7202                                     hashcode);
7203   main_type = type_hash_canon (hashcode, main_type);
7204
7205   /* Fix the canonical type.  */
7206   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7207       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7208     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7209   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7210            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7211                != TYPE_DOMAIN (main_type)))
7212     TYPE_CANONICAL (main_type)
7213       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7214                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7215   else
7216     TYPE_CANONICAL (main_type) = main_type;
7217
7218   if (quals == 0)
7219     type = main_type;
7220   else
7221     type = c_build_qualified_type (main_type, quals);
7222
7223   if (COMPLETE_TYPE_P (type)
7224       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7225       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7226     {
7227       error ("size of array is too large");
7228       /* If we proceed with the array type as it is, we'll eventually
7229          crash in tree_low_cst().  */
7230       type = error_mark_node;
7231     }
7232
7233   *ptype = type;
7234   return failure;
7235 }
7236
7237 \f
7238 /* Used to help initialize the builtin-types.def table.  When a type of
7239    the correct size doesn't exist, use error_mark_node instead of NULL.
7240    The later results in segfaults even when a decl using the type doesn't
7241    get invoked.  */
7242
7243 tree
7244 builtin_type_for_size (int size, bool unsignedp)
7245 {
7246   tree type = lang_hooks.types.type_for_size (size, unsignedp);
7247   return type ? type : error_mark_node;
7248 }
7249
7250 /* A helper function for resolve_overloaded_builtin in resolving the
7251    overloaded __sync_ builtins.  Returns a positive power of 2 if the
7252    first operand of PARAMS is a pointer to a supported data type.
7253    Returns 0 if an error is encountered.  */
7254
7255 static int
7256 sync_resolve_size (tree function, tree params)
7257 {
7258   tree type;
7259   int size;
7260
7261   if (params == NULL)
7262     {
7263       error ("too few arguments to function %qE", function);
7264       return 0;
7265     }
7266
7267   type = TREE_TYPE (TREE_VALUE (params));
7268   if (TREE_CODE (type) != POINTER_TYPE)
7269     goto incompatible;
7270
7271   type = TREE_TYPE (type);
7272   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7273     goto incompatible;
7274
7275   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7276   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7277     return size;
7278
7279  incompatible:
7280   error ("incompatible type for argument %d of %qE", 1, function);
7281   return 0;
7282 }
7283
7284 /* A helper function for resolve_overloaded_builtin.  Adds casts to
7285    PARAMS to make arguments match up with those of FUNCTION.  Drops
7286    the variadic arguments at the end.  Returns false if some error
7287    was encountered; true on success.  */
7288
7289 static bool
7290 sync_resolve_params (tree orig_function, tree function, tree params)
7291 {
7292   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7293   tree ptype;
7294   int number;
7295
7296   /* We've declared the implementation functions to use "volatile void *"
7297      as the pointer parameter, so we shouldn't get any complaints from the
7298      call to check_function_arguments what ever type the user used.  */
7299   arg_types = TREE_CHAIN (arg_types);
7300   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7301   number = 2;
7302
7303   /* For the rest of the values, we need to cast these to FTYPE, so that we
7304      don't get warnings for passing pointer types, etc.  */
7305   while (arg_types != void_list_node)
7306     {
7307       tree val;
7308
7309       params = TREE_CHAIN (params);
7310       if (params == NULL)
7311         {
7312           error ("too few arguments to function %qE", orig_function);
7313           return false;
7314         }
7315
7316       /* ??? Ideally for the first conversion we'd use convert_for_assignment
7317          so that we get warnings for anything that doesn't match the pointer
7318          type.  This isn't portable across the C and C++ front ends atm.  */
7319       val = TREE_VALUE (params);
7320       val = convert (ptype, val);
7321       val = convert (TREE_VALUE (arg_types), val);
7322       TREE_VALUE (params) = val;
7323
7324       arg_types = TREE_CHAIN (arg_types);
7325       number++;
7326     }
7327
7328   /* The definition of these primitives is variadic, with the remaining
7329      being "an optional list of variables protected by the memory barrier".
7330      No clue what that's supposed to mean, precisely, but we consider all
7331      call-clobbered variables to be protected so we're safe.  */
7332   TREE_CHAIN (params) = NULL;
7333
7334   return true;
7335 }
7336
7337 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
7338    RESULT to make it match the type of the first pointer argument in
7339    PARAMS.  */
7340
7341 static tree
7342 sync_resolve_return (tree params, tree result)
7343 {
7344   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7345   ptype = TYPE_MAIN_VARIANT (ptype);
7346   return convert (ptype, result);
7347 }
7348
7349 /* Some builtin functions are placeholders for other expressions.  This
7350    function should be called immediately after parsing the call expression
7351    before surrounding code has committed to the type of the expression.
7352
7353    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7354    PARAMS is the argument list for the call.  The return value is non-null
7355    when expansion is complete, and null if normal processing should
7356    continue.  */
7357
7358 tree
7359 resolve_overloaded_builtin (tree function, tree params)
7360 {
7361   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7362   switch (DECL_BUILT_IN_CLASS (function))
7363     {
7364     case BUILT_IN_NORMAL:
7365       break;
7366     case BUILT_IN_MD:
7367       if (targetm.resolve_overloaded_builtin)
7368         return targetm.resolve_overloaded_builtin (function, params);
7369       else
7370         return NULL_TREE;
7371     default:
7372       return NULL_TREE;
7373     }
7374
7375   /* Handle BUILT_IN_NORMAL here.  */
7376   switch (orig_code)
7377     {
7378     case BUILT_IN_FETCH_AND_ADD_N:
7379     case BUILT_IN_FETCH_AND_SUB_N:
7380     case BUILT_IN_FETCH_AND_OR_N:
7381     case BUILT_IN_FETCH_AND_AND_N:
7382     case BUILT_IN_FETCH_AND_XOR_N:
7383     case BUILT_IN_FETCH_AND_NAND_N:
7384     case BUILT_IN_ADD_AND_FETCH_N:
7385     case BUILT_IN_SUB_AND_FETCH_N:
7386     case BUILT_IN_OR_AND_FETCH_N:
7387     case BUILT_IN_AND_AND_FETCH_N:
7388     case BUILT_IN_XOR_AND_FETCH_N:
7389     case BUILT_IN_NAND_AND_FETCH_N:
7390     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
7391     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
7392     case BUILT_IN_LOCK_TEST_AND_SET_N:
7393     case BUILT_IN_LOCK_RELEASE_N:
7394       {
7395         int n = sync_resolve_size (function, params);
7396         tree new_function, result;
7397
7398         if (n == 0)
7399           return error_mark_node;
7400
7401         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
7402         if (!sync_resolve_params (function, new_function, params))
7403           return error_mark_node;
7404
7405         result = build_function_call (new_function, params);
7406         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
7407             && orig_code != BUILT_IN_LOCK_RELEASE_N)
7408           result = sync_resolve_return (params, result);
7409
7410         return result;
7411       }
7412
7413     default:
7414       return NULL_TREE;
7415     }
7416 }
7417
7418 /* Ignoring their sign, return true if two scalar types are the same.  */
7419 bool
7420 same_scalar_type_ignoring_signedness (tree t1, tree t2)
7421 {
7422   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
7423
7424   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
7425               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
7426                   || c2 == FIXED_POINT_TYPE));
7427
7428   /* Equality works here because c_common_signed_type uses
7429      TYPE_MAIN_VARIANT.  */
7430   return c_common_signed_type (t1)
7431     == c_common_signed_type (t2);
7432 }
7433
7434 /* Check for missing format attributes on function pointers.  LTYPE is
7435    the new type or left-hand side type.  RTYPE is the old type or
7436    right-hand side type.  Returns TRUE if LTYPE is missing the desired
7437    attribute.  */
7438
7439 bool
7440 check_missing_format_attribute (tree ltype, tree rtype)
7441 {
7442   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
7443   tree ra;
7444
7445   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
7446     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
7447       break;
7448   if (ra)
7449     {
7450       tree la;
7451       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
7452         if (is_attribute_p ("format", TREE_PURPOSE (la)))
7453           break;
7454       return !la;
7455     }
7456   else
7457     return false;
7458 }
7459
7460 /* Subscripting with type char is likely to lose on a machine where
7461    chars are signed.  So warn on any machine, but optionally.  Don't
7462    warn for unsigned char since that type is safe.  Don't warn for
7463    signed char because anyone who uses that must have done so
7464    deliberately. Furthermore, we reduce the false positive load by
7465    warning only for non-constant value of type char.  */
7466
7467 void
7468 warn_array_subscript_with_type_char (tree index)
7469 {
7470   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
7471       && TREE_CODE (index) != INTEGER_CST)
7472     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
7473 }
7474
7475 /* Implement -Wparentheses for the unexpected C precedence rules, to
7476    cover cases like x + y << z which readers are likely to
7477    misinterpret.  We have seen an expression in which CODE is a binary
7478    operator used to combine expressions headed by CODE_LEFT and
7479    CODE_RIGHT.  CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
7480    means that that side of the expression was not formed using a
7481    binary operator, or it was enclosed in parentheses.  */
7482
7483 void
7484 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
7485                         enum tree_code code_right)
7486 {
7487   if (!warn_parentheses)
7488     return;
7489
7490   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
7491     {
7492       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7493           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7494         warning (OPT_Wparentheses,
7495                  "suggest parentheses around + or - inside shift");
7496     }
7497
7498   if (code == TRUTH_ORIF_EXPR)
7499     {
7500       if (code_left == TRUTH_ANDIF_EXPR
7501           || code_right == TRUTH_ANDIF_EXPR)
7502         warning (OPT_Wparentheses,
7503                  "suggest parentheses around && within ||");
7504     }
7505
7506   if (code == BIT_IOR_EXPR)
7507     {
7508       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
7509           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7510           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
7511           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7512         warning (OPT_Wparentheses,
7513                  "suggest parentheses around arithmetic in operand of |");
7514       /* Check cases like x|y==z */
7515       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7516           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7517         warning (OPT_Wparentheses,
7518                  "suggest parentheses around comparison in operand of |");
7519     }
7520
7521   if (code == BIT_XOR_EXPR)
7522     {
7523       if (code_left == BIT_AND_EXPR
7524           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7525           || code_right == BIT_AND_EXPR
7526           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7527         warning (OPT_Wparentheses,
7528                  "suggest parentheses around arithmetic in operand of ^");
7529       /* Check cases like x^y==z */
7530       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7531           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7532         warning (OPT_Wparentheses,
7533                  "suggest parentheses around comparison in operand of ^");
7534     }
7535
7536   if (code == BIT_AND_EXPR)
7537     {
7538       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7539           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7540         warning (OPT_Wparentheses,
7541                  "suggest parentheses around + or - in operand of &");
7542       /* Check cases like x&y==z */
7543       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7544           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7545         warning (OPT_Wparentheses,
7546                  "suggest parentheses around comparison in operand of &");
7547     }
7548
7549   if (code == EQ_EXPR || code == NE_EXPR)
7550     {
7551       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7552           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7553         warning (OPT_Wparentheses,
7554                  "suggest parentheses around comparison in operand of %s",
7555                  code == EQ_EXPR ? "==" : "!=");
7556     }
7557   else if (TREE_CODE_CLASS (code) == tcc_comparison)
7558     {
7559       if ((TREE_CODE_CLASS (code_left) == tcc_comparison
7560            && code_left != NE_EXPR && code_left != EQ_EXPR)
7561           || (TREE_CODE_CLASS (code_right) == tcc_comparison
7562               && code_right != NE_EXPR && code_right != EQ_EXPR))
7563         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
7564                  "have their mathematical meaning");
7565     }
7566 }
7567
7568 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
7569
7570 void
7571 warn_for_unused_label (tree label)
7572 {
7573   if (!TREE_USED (label))
7574     {
7575       if (DECL_INITIAL (label))
7576         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
7577       else
7578         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
7579     }
7580 }
7581
7582 #ifndef TARGET_HAS_TARGETCM
7583 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
7584 #endif
7585
7586 /* Warn for division by zero according to the value of DIVISOR.  */
7587
7588 void
7589 warn_for_div_by_zero (tree divisor)
7590 {
7591   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
7592      about division by zero.  Do not issue a warning if DIVISOR has a
7593      floating-point type, since we consider 0.0/0.0 a valid way of
7594      generating a NaN.  */
7595   if (skip_evaluation == 0
7596       && (integer_zerop (divisor) || fixed_zerop (divisor)))
7597     warning (OPT_Wdiv_by_zero, "division by zero");
7598 }
7599
7600 #include "gt-c-common.h"