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