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