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 #ifdef TARGET_ENUM_VA_LIST
4006   {
4007     int l;
4008     const char *pname;
4009     tree ptype;
4010     for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4011       {
4012         lang_hooks.decls.pushdecl
4013           (build_decl (TYPE_DECL, get_identifier (pname),
4014                        ptype));
4015
4016       }
4017   }
4018 #endif
4019
4020   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4021     {
4022       va_list_arg_type_node = va_list_ref_type_node =
4023         build_pointer_type (TREE_TYPE (va_list_type_node));
4024     }
4025   else
4026     {
4027       va_list_arg_type_node = va_list_type_node;
4028       va_list_ref_type_node = build_reference_type (va_list_type_node);
4029     }
4030
4031   if (!flag_preprocess_only)
4032     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4033
4034   main_identifier_node = get_identifier ("main");
4035
4036   /* Create the built-in __null node.  It is important that this is
4037      not shared.  */
4038   null_node = make_node (INTEGER_CST);
4039   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4040
4041   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
4042   memset (builtin_types, 0, sizeof (builtin_types));
4043 }
4044
4045 /* Look up the function in built_in_decls that corresponds to DECL
4046    and set ASMSPEC as its user assembler name.  DECL must be a
4047    function decl that declares a builtin.  */
4048
4049 void
4050 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4051 {
4052   tree builtin;
4053   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4054               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4055               && asmspec != 0);
4056
4057   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4058   set_user_assembler_name (builtin, asmspec);
4059   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
4060     init_block_move_fn (asmspec);
4061   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
4062     init_block_clear_fn (asmspec);
4063 }
4064
4065 /* The number of named compound-literals generated thus far.  */
4066 static GTY(()) int compound_literal_number;
4067
4068 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
4069
4070 void
4071 set_compound_literal_name (tree decl)
4072 {
4073   char *name;
4074   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4075                            compound_literal_number);
4076   compound_literal_number++;
4077   DECL_NAME (decl) = get_identifier (name);
4078 }
4079
4080 tree
4081 build_va_arg (tree expr, tree type)
4082 {
4083   return build1 (VA_ARG_EXPR, type, expr);
4084 }
4085
4086
4087 /* Linked list of disabled built-in functions.  */
4088
4089 typedef struct disabled_builtin
4090 {
4091   const char *name;
4092   struct disabled_builtin *next;
4093 } disabled_builtin;
4094 static disabled_builtin *disabled_builtins = NULL;
4095
4096 static bool builtin_function_disabled_p (const char *);
4097
4098 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
4099    begins with "__builtin_", give an error.  */
4100
4101 void
4102 disable_builtin_function (const char *name)
4103 {
4104   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4105     error ("cannot disable built-in function %qs", name);
4106   else
4107     {
4108       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4109       new_disabled_builtin->name = name;
4110       new_disabled_builtin->next = disabled_builtins;
4111       disabled_builtins = new_disabled_builtin;
4112     }
4113 }
4114
4115
4116 /* Return true if the built-in function NAME has been disabled, false
4117    otherwise.  */
4118
4119 static bool
4120 builtin_function_disabled_p (const char *name)
4121 {
4122   disabled_builtin *p;
4123   for (p = disabled_builtins; p != NULL; p = p->next)
4124     {
4125       if (strcmp (name, p->name) == 0)
4126         return true;
4127     }
4128   return false;
4129 }
4130
4131
4132 /* Worker for DEF_BUILTIN.
4133    Possibly define a builtin function with one or two names.
4134    Does not declare a non-__builtin_ function if flag_no_builtin, or if
4135    nonansi_p and flag_no_nonansi_builtin.  */
4136
4137 static void
4138 def_builtin_1 (enum built_in_function fncode,
4139                const char *name,
4140                enum built_in_class fnclass,
4141                tree fntype, tree libtype,
4142                bool both_p, bool fallback_p, bool nonansi_p,
4143                tree fnattrs, bool implicit_p)
4144 {
4145   tree decl;
4146   const char *libname;
4147
4148   if (fntype == error_mark_node)
4149     return;
4150
4151   gcc_assert ((!both_p && !fallback_p)
4152               || !strncmp (name, "__builtin_",
4153                            strlen ("__builtin_")));
4154
4155   libname = name + strlen ("__builtin_");
4156   decl = add_builtin_function (name, fntype, fncode, fnclass,
4157                                (fallback_p ? libname : NULL),
4158                                fnattrs);
4159   if (both_p
4160       && !flag_no_builtin && !builtin_function_disabled_p (libname)
4161       && !(nonansi_p && flag_no_nonansi_builtin))
4162     add_builtin_function (libname, libtype, fncode, fnclass,
4163                           NULL, fnattrs);
4164
4165   built_in_decls[(int) fncode] = decl;
4166   if (implicit_p)
4167     implicit_built_in_decls[(int) fncode] = decl;
4168 }
4169 \f
4170 /* Nonzero if the type T promotes to int.  This is (nearly) the
4171    integral promotions defined in ISO C99 6.3.1.1/2.  */
4172
4173 bool
4174 c_promoting_integer_type_p (const_tree t)
4175 {
4176   switch (TREE_CODE (t))
4177     {
4178     case INTEGER_TYPE:
4179       return (TYPE_MAIN_VARIANT (t) == char_type_node
4180               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4181               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4182               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4183               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4184               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4185
4186     case ENUMERAL_TYPE:
4187       /* ??? Technically all enumerations not larger than an int
4188          promote to an int.  But this is used along code paths
4189          that only want to notice a size change.  */
4190       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4191
4192     case BOOLEAN_TYPE:
4193       return 1;
4194
4195     default:
4196       return 0;
4197     }
4198 }
4199
4200 /* Return 1 if PARMS specifies a fixed number of parameters
4201    and none of their types is affected by default promotions.  */
4202
4203 int
4204 self_promoting_args_p (const_tree parms)
4205 {
4206   const_tree t;
4207   for (t = parms; t; t = TREE_CHAIN (t))
4208     {
4209       tree type = TREE_VALUE (t);
4210
4211       if (type == error_mark_node)
4212         continue;
4213
4214       if (TREE_CHAIN (t) == 0 && type != void_type_node)
4215         return 0;
4216
4217       if (type == 0)
4218         return 0;
4219
4220       if (TYPE_MAIN_VARIANT (type) == float_type_node)
4221         return 0;
4222
4223       if (c_promoting_integer_type_p (type))
4224         return 0;
4225     }
4226   return 1;
4227 }
4228
4229 /* Recursively remove any '*' or '&' operator from TYPE.  */
4230 tree
4231 strip_pointer_operator (tree t)
4232 {
4233   while (POINTER_TYPE_P (t))
4234     t = TREE_TYPE (t);
4235   return t;
4236 }
4237
4238 /* Recursively remove pointer or array type from TYPE. */
4239 tree
4240 strip_pointer_or_array_types (tree t)
4241 {
4242   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4243     t = TREE_TYPE (t);
4244   return t;
4245 }
4246
4247 /* Used to compare case labels.  K1 and K2 are actually tree nodes
4248    representing case labels, or NULL_TREE for a `default' label.
4249    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4250    K2, and 0 if K1 and K2 are equal.  */
4251
4252 int
4253 case_compare (splay_tree_key k1, splay_tree_key k2)
4254 {
4255   /* Consider a NULL key (such as arises with a `default' label) to be
4256      smaller than anything else.  */
4257   if (!k1)
4258     return k2 ? -1 : 0;
4259   else if (!k2)
4260     return k1 ? 1 : 0;
4261
4262   return tree_int_cst_compare ((tree) k1, (tree) k2);
4263 }
4264
4265 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
4266    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4267    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
4268    case label was declared using the usual C/C++ syntax, rather than
4269    the GNU case range extension.  CASES is a tree containing all the
4270    case ranges processed so far; COND is the condition for the
4271    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
4272    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
4273
4274 tree
4275 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4276                   tree low_value, tree high_value)
4277 {
4278   tree type;
4279   tree label;
4280   tree case_label;
4281   splay_tree_node node;
4282
4283   /* Create the LABEL_DECL itself.  */
4284   label = create_artificial_label ();
4285
4286   /* If there was an error processing the switch condition, bail now
4287      before we get more confused.  */
4288   if (!cond || cond == error_mark_node)
4289     goto error_out;
4290
4291   if ((low_value && TREE_TYPE (low_value)
4292        && POINTER_TYPE_P (TREE_TYPE (low_value)))
4293       || (high_value && TREE_TYPE (high_value)
4294           && POINTER_TYPE_P (TREE_TYPE (high_value))))
4295     {
4296       error ("pointers are not permitted as case values");
4297       goto error_out;
4298     }
4299
4300   /* Case ranges are a GNU extension.  */
4301   if (high_value && pedantic)
4302     pedwarn ("range expressions in switch statements are non-standard");
4303
4304   type = TREE_TYPE (cond);
4305   if (low_value)
4306     {
4307       low_value = check_case_value (low_value);
4308       low_value = convert_and_check (type, low_value);
4309       if (low_value == error_mark_node)
4310         goto error_out;
4311     }
4312   if (high_value)
4313     {
4314       high_value = check_case_value (high_value);
4315       high_value = convert_and_check (type, high_value);
4316       if (high_value == error_mark_node)
4317         goto error_out;
4318     }
4319
4320   if (low_value && high_value)
4321     {
4322       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4323          really a case range, even though it was written that way.
4324          Remove the HIGH_VALUE to simplify later processing.  */
4325       if (tree_int_cst_equal (low_value, high_value))
4326         high_value = NULL_TREE;
4327       else if (!tree_int_cst_lt (low_value, high_value))
4328         warning (0, "empty range specified");
4329     }
4330
4331   /* See if the case is in range of the type of the original testing
4332      expression.  If both low_value and high_value are out of range,
4333      don't insert the case label and return NULL_TREE.  */
4334   if (low_value
4335       && !check_case_bounds (type, orig_type,
4336                              &low_value, high_value ? &high_value : NULL))
4337     return NULL_TREE;
4338
4339   /* Look up the LOW_VALUE in the table of case labels we already
4340      have.  */
4341   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4342   /* If there was not an exact match, check for overlapping ranges.
4343      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4344      that's a `default' label and the only overlap is an exact match.  */
4345   if (!node && (low_value || high_value))
4346     {
4347       splay_tree_node low_bound;
4348       splay_tree_node high_bound;
4349
4350       /* Even though there wasn't an exact match, there might be an
4351          overlap between this case range and another case range.
4352          Since we've (inductively) not allowed any overlapping case
4353          ranges, we simply need to find the greatest low case label
4354          that is smaller that LOW_VALUE, and the smallest low case
4355          label that is greater than LOW_VALUE.  If there is an overlap
4356          it will occur in one of these two ranges.  */
4357       low_bound = splay_tree_predecessor (cases,
4358                                           (splay_tree_key) low_value);
4359       high_bound = splay_tree_successor (cases,
4360                                          (splay_tree_key) low_value);
4361
4362       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
4363          the LOW_VALUE, so there is no need to check unless the
4364          LOW_BOUND is in fact itself a case range.  */
4365       if (low_bound
4366           && CASE_HIGH ((tree) low_bound->value)
4367           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4368                                     low_value) >= 0)
4369         node = low_bound;
4370       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
4371          range is bigger than the low end of the current range, so we
4372          are only interested if the current range is a real range, and
4373          not an ordinary case label.  */
4374       else if (high_bound
4375                && high_value
4376                && (tree_int_cst_compare ((tree) high_bound->key,
4377                                          high_value)
4378                    <= 0))
4379         node = high_bound;
4380     }
4381   /* If there was an overlap, issue an error.  */
4382   if (node)
4383     {
4384       tree duplicate = CASE_LABEL ((tree) node->value);
4385
4386       if (high_value)
4387         {
4388           error ("duplicate (or overlapping) case value");
4389           error ("%Jthis is the first entry overlapping that value", duplicate);
4390         }
4391       else if (low_value)
4392         {
4393           error ("duplicate case value") ;
4394           error ("%Jpreviously used here", duplicate);
4395         }
4396       else
4397         {
4398           error ("multiple default labels in one switch");
4399           error ("%Jthis is the first default label", duplicate);
4400         }
4401       goto error_out;
4402     }
4403
4404   /* Add a CASE_LABEL to the statement-tree.  */
4405   case_label = add_stmt (build_case_label (low_value, high_value, label));
4406   /* Register this case label in the splay tree.  */
4407   splay_tree_insert (cases,
4408                      (splay_tree_key) low_value,
4409                      (splay_tree_value) case_label);
4410
4411   return case_label;
4412
4413  error_out:
4414   /* Add a label so that the back-end doesn't think that the beginning of
4415      the switch is unreachable.  Note that we do not add a case label, as
4416      that just leads to duplicates and thence to failure later on.  */
4417   if (!cases->root)
4418     {
4419       tree t = create_artificial_label ();
4420       add_stmt (build_stmt (LABEL_EXPR, t));
4421     }
4422   return error_mark_node;
4423 }
4424
4425 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4426    Used to verify that case values match up with enumerator values.  */
4427
4428 static void
4429 match_case_to_enum_1 (tree key, tree type, tree label)
4430 {
4431   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4432
4433   /* ??? Not working too hard to print the double-word value.
4434      Should perhaps be done with %lwd in the diagnostic routines?  */
4435   if (TREE_INT_CST_HIGH (key) == 0)
4436     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4437               TREE_INT_CST_LOW (key));
4438   else if (!TYPE_UNSIGNED (type)
4439            && TREE_INT_CST_HIGH (key) == -1
4440            && TREE_INT_CST_LOW (key) != 0)
4441     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4442               -TREE_INT_CST_LOW (key));
4443   else
4444     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4445               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4446               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4447
4448   if (TYPE_NAME (type) == 0)
4449     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4450              "%Jcase value %qs not in enumerated type",
4451              CASE_LABEL (label), buf);
4452   else
4453     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4454              "%Jcase value %qs not in enumerated type %qT",
4455              CASE_LABEL (label), buf, type);
4456 }
4457
4458 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4459    Used to verify that case values match up with enumerator values.  */
4460
4461 static int
4462 match_case_to_enum (splay_tree_node node, void *data)
4463 {
4464   tree label = (tree) node->value;
4465   tree type = (tree) data;
4466
4467   /* Skip default case.  */
4468   if (!CASE_LOW (label))
4469     return 0;
4470
4471   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4472      when we did our enum->case scan.  Reset our scratch bit after.  */
4473   if (!CASE_LOW_SEEN (label))
4474     match_case_to_enum_1 (CASE_LOW (label), type, label);
4475   else
4476     CASE_LOW_SEEN (label) = 0;
4477
4478   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
4479      not set, that means that CASE_HIGH did not appear when we did our
4480      enum->case scan.  Reset our scratch bit after.  */
4481   if (CASE_HIGH (label))
4482     {
4483       if (!CASE_HIGH_SEEN (label))
4484         match_case_to_enum_1 (CASE_HIGH (label), type, label);
4485       else
4486         CASE_HIGH_SEEN (label) = 0;
4487     }
4488
4489   return 0;
4490 }
4491
4492 /* Handle -Wswitch*.  Called from the front end after parsing the
4493    switch construct.  */
4494 /* ??? Should probably be somewhere generic, since other languages
4495    besides C and C++ would want this.  At the moment, however, C/C++
4496    are the only tree-ssa languages that support enumerations at all,
4497    so the point is moot.  */
4498
4499 void
4500 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4501                       tree type, tree cond)
4502 {
4503   splay_tree_node default_node;
4504   splay_tree_node node;
4505   tree chain;
4506   int saved_warn_switch;
4507
4508   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4509     return;
4510
4511   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4512   if (!default_node)
4513     warning (OPT_Wswitch_default, "%Hswitch missing default case",
4514              &switch_location);
4515
4516   /* From here on, we only care about about enumerated types.  */
4517   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4518     return;
4519
4520   /* If the switch expression was an enumerated type, check that
4521      exactly all enumeration literals are covered by the cases.
4522      The check is made when -Wswitch was specified and there is no
4523      default case, or when -Wswitch-enum was specified.  */
4524
4525   if (!warn_switch_enum
4526       && !(warn_switch && !default_node))
4527     return;
4528
4529   /* Clearing COND if it is not an integer constant simplifies
4530      the tests inside the loop below.  */
4531   if (TREE_CODE (cond) != INTEGER_CST)
4532     cond = NULL_TREE;
4533
4534   /* The time complexity here is O(N*lg(N)) worst case, but for the
4535       common case of monotonically increasing enumerators, it is
4536       O(N), since the nature of the splay tree will keep the next
4537       element adjacent to the root at all times.  */
4538
4539   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4540     {
4541       tree value = TREE_VALUE (chain);
4542       node = splay_tree_lookup (cases, (splay_tree_key) value);
4543       if (node)
4544         {
4545           /* Mark the CASE_LOW part of the case entry as seen.  */
4546           tree label = (tree) node->value;
4547           CASE_LOW_SEEN (label) = 1;
4548           continue;
4549         }
4550
4551       /* Even though there wasn't an exact match, there might be a
4552          case range which includes the enumerator's value.  */
4553       node = splay_tree_predecessor (cases, (splay_tree_key) value);
4554       if (node && CASE_HIGH ((tree) node->value))
4555         {
4556           tree label = (tree) node->value;
4557           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4558           if (cmp >= 0)
4559             {
4560               /* If we match the upper bound exactly, mark the CASE_HIGH
4561                  part of the case entry as seen.  */
4562               if (cmp == 0)
4563                 CASE_HIGH_SEEN (label) = 1;
4564               continue;
4565             }
4566         }
4567
4568       /* We've now determined that this enumerated literal isn't
4569          handled by the case labels of the switch statement.  */
4570
4571       /* If the switch expression is a constant, we only really care
4572          about whether that constant is handled by the switch.  */
4573       if (cond && tree_int_cst_compare (cond, value))
4574         continue;
4575
4576       /* If there is a default_node, the only relevant option is
4577          Wswitch-enum. Otherwise, if both are enabled then we prefer
4578          to warn using -Wswitch because -Wswitch is enabled by -Wall
4579          while -Wswitch-enum is explicit.  */
4580       warning ((default_node || !warn_switch)
4581                ? OPT_Wswitch_enum : OPT_Wswitch,
4582                "%Henumeration value %qE not handled in switch",
4583                &switch_location, TREE_PURPOSE (chain));
4584     }
4585
4586   /* Warn if there are case expressions that don't correspond to
4587      enumerators.  This can occur since C and C++ don't enforce
4588      type-checking of assignments to enumeration variables.
4589
4590      The time complexity here is now always O(N) worst case, since
4591      we should have marked both the lower bound and upper bound of
4592      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4593      above.  This scan also resets those fields.  */
4594
4595   /* If there is a default_node, the only relevant option is
4596      Wswitch-enum. Otherwise, if both are enabled then we prefer
4597      to warn using -Wswitch because -Wswitch is enabled by -Wall
4598      while -Wswitch-enum is explicit.  */
4599   saved_warn_switch = warn_switch;
4600   if (default_node)
4601     warn_switch = 0;
4602   splay_tree_foreach (cases, match_case_to_enum, type);
4603   warn_switch = saved_warn_switch;
4604
4605 }
4606
4607 /* Finish an expression taking the address of LABEL (an
4608    IDENTIFIER_NODE).  Returns an expression for the address.  */
4609
4610 tree
4611 finish_label_address_expr (tree label)
4612 {
4613   tree result;
4614
4615   if (pedantic)
4616     pedwarn ("taking the address of a label is non-standard");
4617
4618   if (label == error_mark_node)
4619     return error_mark_node;
4620
4621   label = lookup_label (label);
4622   if (label == NULL_TREE)
4623     result = null_pointer_node;
4624   else
4625     {
4626       TREE_USED (label) = 1;
4627       result = build1 (ADDR_EXPR, ptr_type_node, label);
4628       /* The current function in not necessarily uninlinable.
4629          Computed gotos are incompatible with inlining, but the value
4630          here could be used only in a diagnostic, for example.  */
4631     }
4632
4633   return result;
4634 }
4635
4636 /* Hook used by expand_expr to expand language-specific tree codes.  */
4637 /* The only things that should go here are bits needed to expand
4638    constant initializers.  Everything else should be handled by the
4639    gimplification routines.  */
4640
4641 rtx
4642 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4643                int modifiera /* Actually enum expand_modifier.  */,
4644                rtx *alt_rtl)
4645 {
4646   enum expand_modifier modifier = (enum expand_modifier) modifiera;
4647   switch (TREE_CODE (exp))
4648     {
4649     case COMPOUND_LITERAL_EXPR:
4650       {
4651         /* Initialize the anonymous variable declared in the compound
4652            literal, then return the variable.  */
4653         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4654         emit_local_var (decl);
4655         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4656       }
4657
4658     default:
4659       gcc_unreachable ();
4660     }
4661 }
4662
4663 /* Hook used by staticp to handle language-specific tree codes.  */
4664
4665 tree
4666 c_staticp (tree exp)
4667 {
4668   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4669           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4670           ? exp : NULL);
4671 }
4672 \f
4673
4674 /* Given a boolean expression ARG, return a tree representing an increment
4675    or decrement (as indicated by CODE) of ARG.  The front end must check for
4676    invalid cases (e.g., decrement in C++).  */
4677 tree
4678 boolean_increment (enum tree_code code, tree arg)
4679 {
4680   tree val;
4681   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
4682
4683   arg = stabilize_reference (arg);
4684   switch (code)
4685     {
4686     case PREINCREMENT_EXPR:
4687       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4688       break;
4689     case POSTINCREMENT_EXPR:
4690       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4691       arg = save_expr (arg);
4692       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4693       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4694       break;
4695     case PREDECREMENT_EXPR:
4696       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4697                     invert_truthvalue (arg));
4698       break;
4699     case POSTDECREMENT_EXPR:
4700       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4701                     invert_truthvalue (arg));
4702       arg = save_expr (arg);
4703       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4704       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4705       break;
4706     default:
4707       gcc_unreachable ();
4708     }
4709   TREE_SIDE_EFFECTS (val) = 1;
4710   return val;
4711 }
4712 \f
4713 /* Built-in macros for stddef.h, that require macros defined in this
4714    file.  */
4715 void
4716 c_stddef_cpp_builtins(void)
4717 {
4718   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4719   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4720   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4721   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4722   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4723   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4724 }
4725
4726 static void
4727 c_init_attributes (void)
4728 {
4729   /* Fill in the built_in_attributes array.  */
4730 #define DEF_ATTR_NULL_TREE(ENUM)                                \
4731   built_in_attributes[(int) ENUM] = NULL_TREE;
4732 #define DEF_ATTR_INT(ENUM, VALUE)                               \
4733   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4734 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
4735   built_in_attributes[(int) ENUM] = get_identifier (STRING);
4736 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4737   built_in_attributes[(int) ENUM]                       \
4738     = tree_cons (built_in_attributes[(int) PURPOSE],    \
4739                  built_in_attributes[(int) VALUE],      \
4740                  built_in_attributes[(int) CHAIN]);
4741 #include "builtin-attrs.def"
4742 #undef DEF_ATTR_NULL_TREE
4743 #undef DEF_ATTR_INT
4744 #undef DEF_ATTR_IDENT
4745 #undef DEF_ATTR_TREE_LIST
4746 }
4747
4748 /* Attribute handlers common to C front ends.  */
4749
4750 /* Handle a "packed" attribute; arguments as in
4751    struct attribute_spec.handler.  */
4752
4753 static tree
4754 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4755                          int flags, bool *no_add_attrs)
4756 {
4757   if (TYPE_P (*node))
4758     {
4759       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4760         *node = build_variant_type_copy (*node);
4761       TYPE_PACKED (*node) = 1;
4762     }
4763   else if (TREE_CODE (*node) == FIELD_DECL)
4764     {
4765       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4766         warning (OPT_Wattributes,
4767                  "%qE attribute ignored for field of type %qT",
4768                  name, TREE_TYPE (*node));
4769       else
4770         DECL_PACKED (*node) = 1;
4771     }
4772   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4773      used for DECL_REGISTER.  It wouldn't mean anything anyway.
4774      We can't set DECL_PACKED on the type of a TYPE_DECL, because
4775      that changes what the typedef is typing.  */
4776   else
4777     {
4778       warning (OPT_Wattributes, "%qE attribute ignored", name);
4779       *no_add_attrs = true;
4780     }
4781
4782   return NULL_TREE;
4783 }
4784
4785 /* Handle a "nocommon" attribute; arguments as in
4786    struct attribute_spec.handler.  */
4787
4788 static tree
4789 handle_nocommon_attribute (tree *node, tree name,
4790                            tree ARG_UNUSED (args),
4791                            int ARG_UNUSED (flags), bool *no_add_attrs)
4792 {
4793   if (TREE_CODE (*node) == VAR_DECL)
4794     DECL_COMMON (*node) = 0;
4795   else
4796     {
4797       warning (OPT_Wattributes, "%qE attribute ignored", name);
4798       *no_add_attrs = true;
4799     }
4800
4801   return NULL_TREE;
4802 }
4803
4804 /* Handle a "common" attribute; arguments as in
4805    struct attribute_spec.handler.  */
4806
4807 static tree
4808 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4809                          int ARG_UNUSED (flags), bool *no_add_attrs)
4810 {
4811   if (TREE_CODE (*node) == VAR_DECL)
4812     DECL_COMMON (*node) = 1;
4813   else
4814     {
4815       warning (OPT_Wattributes, "%qE attribute ignored", name);
4816       *no_add_attrs = true;
4817     }
4818
4819   return NULL_TREE;
4820 }
4821
4822 /* Handle a "noreturn" attribute; arguments as in
4823    struct attribute_spec.handler.  */
4824
4825 static tree
4826 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4827                            int ARG_UNUSED (flags), bool *no_add_attrs)
4828 {
4829   tree type = TREE_TYPE (*node);
4830
4831   /* See FIXME comment in c_common_attribute_table.  */
4832   if (TREE_CODE (*node) == FUNCTION_DECL)
4833     TREE_THIS_VOLATILE (*node) = 1;
4834   else if (TREE_CODE (type) == POINTER_TYPE
4835            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4836     TREE_TYPE (*node)
4837       = build_pointer_type
4838         (build_type_variant (TREE_TYPE (type),
4839                              TYPE_READONLY (TREE_TYPE (type)), 1));
4840   else
4841     {
4842       warning (OPT_Wattributes, "%qE attribute ignored", name);
4843       *no_add_attrs = true;
4844     }
4845
4846   return NULL_TREE;
4847 }
4848
4849 /* Handle a "hot" and attribute; arguments as in
4850    struct attribute_spec.handler.  */
4851
4852 static tree
4853 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4854                           int ARG_UNUSED (flags), bool *no_add_attrs)
4855 {
4856   if (TREE_CODE (*node) == FUNCTION_DECL)
4857     {
4858       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
4859         {
4860           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4861                    name, "cold");
4862           *no_add_attrs = true;
4863         }
4864       /* Do nothing else, just set the attribute.  We'll get at
4865          it later with lookup_attribute.  */
4866     }
4867   else
4868     {
4869       warning (OPT_Wattributes, "%qE attribute ignored", name);
4870       *no_add_attrs = true;
4871     }
4872
4873   return NULL_TREE;
4874 }
4875 /* Handle a "cold" and attribute; arguments as in
4876    struct attribute_spec.handler.  */
4877
4878 static tree
4879 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4880                        int ARG_UNUSED (flags), bool *no_add_attrs)
4881 {
4882   if (TREE_CODE (*node) == FUNCTION_DECL)
4883     {
4884       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
4885         {
4886           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4887                    name, "hot");
4888           *no_add_attrs = true;
4889         }
4890       /* Do nothing else, just set the attribute.  We'll get at
4891          it later with lookup_attribute.  */
4892     }
4893   else
4894     {
4895       warning (OPT_Wattributes, "%qE attribute ignored", name);
4896       *no_add_attrs = true;
4897     }
4898
4899   return NULL_TREE;
4900 }
4901
4902 /* Handle a "noinline" attribute; arguments as in
4903    struct attribute_spec.handler.  */
4904
4905 static tree
4906 handle_noinline_attribute (tree *node, tree name,
4907                            tree ARG_UNUSED (args),
4908                            int ARG_UNUSED (flags), bool *no_add_attrs)
4909 {
4910   if (TREE_CODE (*node) == FUNCTION_DECL)
4911     DECL_UNINLINABLE (*node) = 1;
4912   else
4913     {
4914       warning (OPT_Wattributes, "%qE attribute ignored", name);
4915       *no_add_attrs = true;
4916     }
4917
4918   return NULL_TREE;
4919 }
4920
4921 /* Handle a "always_inline" attribute; arguments as in
4922    struct attribute_spec.handler.  */
4923
4924 static tree
4925 handle_always_inline_attribute (tree *node, tree name,
4926                                 tree ARG_UNUSED (args),
4927                                 int ARG_UNUSED (flags),
4928                                 bool *no_add_attrs)
4929 {
4930   if (TREE_CODE (*node) == FUNCTION_DECL)
4931     {
4932       /* Set the attribute and mark it for disregarding inline
4933          limits.  */
4934       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
4935     }
4936   else
4937     {
4938       warning (OPT_Wattributes, "%qE attribute ignored", name);
4939       *no_add_attrs = true;
4940     }
4941
4942   return NULL_TREE;
4943 }
4944
4945 /* Handle a "gnu_inline" attribute; arguments as in
4946    struct attribute_spec.handler.  */
4947
4948 static tree
4949 handle_gnu_inline_attribute (tree *node, tree name,
4950                              tree ARG_UNUSED (args),
4951                              int ARG_UNUSED (flags),
4952                              bool *no_add_attrs)
4953 {
4954   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4955     {
4956       /* Do nothing else, just set the attribute.  We'll get at
4957          it later with lookup_attribute.  */
4958     }
4959   else
4960     {
4961       warning (OPT_Wattributes, "%qE attribute ignored", name);
4962       *no_add_attrs = true;
4963     }
4964
4965   return NULL_TREE;
4966 }
4967
4968 /* Handle an "artificial" attribute; arguments as in
4969    struct attribute_spec.handler.  */
4970
4971 static tree
4972 handle_artificial_attribute (tree *node, tree name,
4973                              tree ARG_UNUSED (args),
4974                              int ARG_UNUSED (flags),
4975                              bool *no_add_attrs)
4976 {
4977   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4978     {
4979       /* Do nothing else, just set the attribute.  We'll get at
4980          it later with lookup_attribute.  */
4981     }
4982   else
4983     {
4984       warning (OPT_Wattributes, "%qE attribute ignored", name);
4985       *no_add_attrs = true;
4986     }
4987
4988   return NULL_TREE;
4989 }
4990
4991 /* Handle a "flatten" attribute; arguments as in
4992    struct attribute_spec.handler.  */
4993
4994 static tree
4995 handle_flatten_attribute (tree *node, tree name,
4996                           tree args ATTRIBUTE_UNUSED,
4997                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4998 {
4999   if (TREE_CODE (*node) == FUNCTION_DECL)
5000     /* Do nothing else, just set the attribute.  We'll get at
5001        it later with lookup_attribute.  */
5002     ;
5003   else
5004     {
5005       warning (OPT_Wattributes, "%qE attribute ignored", name);
5006       *no_add_attrs = true;
5007     }
5008
5009   return NULL_TREE;
5010 }
5011
5012 /* Handle a "warning" or "error" attribute; arguments as in
5013    struct attribute_spec.handler.  */
5014
5015 static tree
5016 handle_error_attribute (tree *node, tree name, tree args,
5017                         int ARG_UNUSED (flags), bool *no_add_attrs)
5018 {
5019   if (TREE_CODE (*node) == FUNCTION_DECL
5020       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5021     /* Do nothing else, just set the attribute.  We'll get at
5022        it later with lookup_attribute.  */
5023     ;
5024   else
5025     {
5026       warning (OPT_Wattributes, "%qE attribute ignored", name);
5027       *no_add_attrs = true;
5028     }
5029
5030   return NULL_TREE;
5031 }
5032
5033 /* Handle a "used" attribute; arguments as in
5034    struct attribute_spec.handler.  */
5035
5036 static tree
5037 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5038                        int ARG_UNUSED (flags), bool *no_add_attrs)
5039 {
5040   tree node = *pnode;
5041
5042   if (TREE_CODE (node) == FUNCTION_DECL
5043       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5044     {
5045       TREE_USED (node) = 1;
5046       DECL_PRESERVE_P (node) = 1;
5047     }
5048   else
5049     {
5050       warning (OPT_Wattributes, "%qE attribute ignored", name);
5051       *no_add_attrs = true;
5052     }
5053
5054   return NULL_TREE;
5055 }
5056
5057 /* Handle a "unused" attribute; arguments as in
5058    struct attribute_spec.handler.  */
5059
5060 static tree
5061 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5062                          int flags, bool *no_add_attrs)
5063 {
5064   if (DECL_P (*node))
5065     {
5066       tree decl = *node;
5067
5068       if (TREE_CODE (decl) == PARM_DECL
5069           || TREE_CODE (decl) == VAR_DECL
5070           || TREE_CODE (decl) == FUNCTION_DECL
5071           || TREE_CODE (decl) == LABEL_DECL
5072           || TREE_CODE (decl) == TYPE_DECL)
5073         TREE_USED (decl) = 1;
5074       else
5075         {
5076           warning (OPT_Wattributes, "%qE attribute ignored", name);
5077           *no_add_attrs = true;
5078         }
5079     }
5080   else
5081     {
5082       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5083         *node = build_variant_type_copy (*node);
5084       TREE_USED (*node) = 1;
5085     }
5086
5087   return NULL_TREE;
5088 }
5089
5090 /* Handle a "externally_visible" attribute; arguments as in
5091    struct attribute_spec.handler.  */
5092
5093 static tree
5094 handle_externally_visible_attribute (tree *pnode, tree name,
5095                                      tree ARG_UNUSED (args),
5096                                      int ARG_UNUSED (flags),
5097                                      bool *no_add_attrs)
5098 {
5099   tree node = *pnode;
5100
5101   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5102     {
5103       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5104            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5105         {
5106           warning (OPT_Wattributes,
5107                    "%qE attribute have effect only on public objects", name);
5108           *no_add_attrs = true;
5109         }
5110     }
5111   else
5112     {
5113       warning (OPT_Wattributes, "%qE attribute ignored", name);
5114       *no_add_attrs = true;
5115     }
5116
5117   return NULL_TREE;
5118 }
5119
5120 /* Handle a "const" attribute; arguments as in
5121    struct attribute_spec.handler.  */
5122
5123 static tree
5124 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5125                         int ARG_UNUSED (flags), bool *no_add_attrs)
5126 {
5127   tree type = TREE_TYPE (*node);
5128
5129   /* See FIXME comment on noreturn in c_common_attribute_table.  */
5130   if (TREE_CODE (*node) == FUNCTION_DECL)
5131     TREE_READONLY (*node) = 1;
5132   else if (TREE_CODE (type) == POINTER_TYPE
5133            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5134     TREE_TYPE (*node)
5135       = build_pointer_type
5136         (build_type_variant (TREE_TYPE (type), 1,
5137                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
5138   else
5139     {
5140       warning (OPT_Wattributes, "%qE attribute ignored", name);
5141       *no_add_attrs = true;
5142     }
5143
5144   return NULL_TREE;
5145 }
5146
5147 /* Handle a "transparent_union" attribute; arguments as in
5148    struct attribute_spec.handler.  */
5149
5150 static tree
5151 handle_transparent_union_attribute (tree *node, tree name,
5152                                     tree ARG_UNUSED (args), int flags,
5153                                     bool *no_add_attrs)
5154 {
5155   tree type;
5156
5157   *no_add_attrs = true;
5158
5159   if (TREE_CODE (*node) == TYPE_DECL)
5160     node = &TREE_TYPE (*node);
5161   type = *node;
5162
5163   if (TREE_CODE (type) == UNION_TYPE)
5164     {
5165       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5166          the code in finish_struct.  */
5167       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5168         {
5169           if (TYPE_FIELDS (type) == NULL_TREE
5170               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5171             goto ignored;
5172
5173           /* A type variant isn't good enough, since we don't a cast
5174              to such a type removed as a no-op.  */
5175           *node = type = build_duplicate_type (type);
5176         }
5177
5178       TYPE_TRANSPARENT_UNION (type) = 1;
5179       return NULL_TREE;
5180     }
5181
5182  ignored:
5183   warning (OPT_Wattributes, "%qE attribute ignored", name);
5184   return NULL_TREE;
5185 }
5186
5187 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
5188    get the requested priority for a constructor or destructor,
5189    possibly issuing diagnostics for invalid or reserved
5190    priorities.  */
5191
5192 static priority_type
5193 get_priority (tree args, bool is_destructor)
5194 {
5195   HOST_WIDE_INT pri;
5196   tree arg;
5197
5198   if (!args)
5199     return DEFAULT_INIT_PRIORITY;
5200
5201   if (!SUPPORTS_INIT_PRIORITY)
5202     {
5203       if (is_destructor)
5204         error ("destructor priorities are not supported");
5205       else
5206         error ("constructor priorities are not supported");
5207       return DEFAULT_INIT_PRIORITY;
5208     }
5209
5210   arg = TREE_VALUE (args);
5211   if (!host_integerp (arg, /*pos=*/0)
5212       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5213     goto invalid;
5214
5215   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5216   if (pri < 0 || pri > MAX_INIT_PRIORITY)
5217     goto invalid;
5218
5219   if (pri <= MAX_RESERVED_INIT_PRIORITY)
5220     {
5221       if (is_destructor)
5222         warning (0,
5223                  "destructor priorities from 0 to %d are reserved "
5224                  "for the implementation",
5225                  MAX_RESERVED_INIT_PRIORITY);
5226       else
5227         warning (0,
5228                  "constructor priorities from 0 to %d are reserved "
5229                  "for the implementation",
5230                  MAX_RESERVED_INIT_PRIORITY);
5231     }
5232   return pri;
5233
5234  invalid:
5235   if (is_destructor)
5236     error ("destructor priorities must be integers from 0 to %d inclusive",
5237            MAX_INIT_PRIORITY);
5238   else
5239     error ("constructor priorities must be integers from 0 to %d inclusive",
5240            MAX_INIT_PRIORITY);
5241   return DEFAULT_INIT_PRIORITY;
5242 }
5243
5244 /* Handle a "constructor" attribute; arguments as in
5245    struct attribute_spec.handler.  */
5246
5247 static tree
5248 handle_constructor_attribute (tree *node, tree name, tree args,
5249                               int ARG_UNUSED (flags),
5250                               bool *no_add_attrs)
5251 {
5252   tree decl = *node;
5253   tree type = TREE_TYPE (decl);
5254
5255   if (TREE_CODE (decl) == FUNCTION_DECL
5256       && TREE_CODE (type) == FUNCTION_TYPE
5257       && decl_function_context (decl) == 0)
5258     {
5259       priority_type priority;
5260       DECL_STATIC_CONSTRUCTOR (decl) = 1;
5261       priority = get_priority (args, /*is_destructor=*/false);
5262       SET_DECL_INIT_PRIORITY (decl, priority);
5263       TREE_USED (decl) = 1;
5264     }
5265   else
5266     {
5267       warning (OPT_Wattributes, "%qE attribute ignored", name);
5268       *no_add_attrs = true;
5269     }
5270
5271   return NULL_TREE;
5272 }
5273
5274 /* Handle a "destructor" attribute; arguments as in
5275    struct attribute_spec.handler.  */
5276
5277 static tree
5278 handle_destructor_attribute (tree *node, tree name, tree args,
5279                              int ARG_UNUSED (flags),
5280                              bool *no_add_attrs)
5281 {
5282   tree decl = *node;
5283   tree type = TREE_TYPE (decl);
5284
5285   if (TREE_CODE (decl) == FUNCTION_DECL
5286       && TREE_CODE (type) == FUNCTION_TYPE
5287       && decl_function_context (decl) == 0)
5288     {
5289       priority_type priority;
5290       DECL_STATIC_DESTRUCTOR (decl) = 1;
5291       priority = get_priority (args, /*is_destructor=*/true);
5292       SET_DECL_FINI_PRIORITY (decl, priority);
5293       TREE_USED (decl) = 1;
5294     }
5295   else
5296     {
5297       warning (OPT_Wattributes, "%qE attribute ignored", name);
5298       *no_add_attrs = true;
5299     }
5300
5301   return NULL_TREE;
5302 }
5303
5304 /* Handle a "mode" attribute; arguments as in
5305    struct attribute_spec.handler.  */
5306
5307 static tree
5308 handle_mode_attribute (tree *node, tree name, tree args,
5309                        int ARG_UNUSED (flags), bool *no_add_attrs)
5310 {
5311   tree type = *node;
5312
5313   *no_add_attrs = true;
5314
5315   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5316     warning (OPT_Wattributes, "%qE attribute ignored", name);
5317   else
5318     {
5319       int j;
5320       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5321       int len = strlen (p);
5322       enum machine_mode mode = VOIDmode;
5323       tree typefm;
5324       bool valid_mode;
5325
5326       if (len > 4 && p[0] == '_' && p[1] == '_'
5327           && p[len - 1] == '_' && p[len - 2] == '_')
5328         {
5329           char *newp = (char *) alloca (len - 1);
5330
5331           strcpy (newp, &p[2]);
5332           newp[len - 4] = '\0';
5333           p = newp;
5334         }
5335
5336       /* Change this type to have a type with the specified mode.
5337          First check for the special modes.  */
5338       if (!strcmp (p, "byte"))
5339         mode = byte_mode;
5340       else if (!strcmp (p, "word"))
5341         mode = word_mode;
5342       else if (!strcmp (p, "pointer"))
5343         mode = ptr_mode;
5344       else if (!strcmp (p, "libgcc_cmp_return"))
5345         mode = targetm.libgcc_cmp_return_mode ();
5346       else if (!strcmp (p, "libgcc_shift_count"))
5347         mode = targetm.libgcc_shift_count_mode ();
5348       else if (!strcmp (p, "unwind_word"))
5349         mode = targetm.unwind_word_mode ();
5350       else
5351         for (j = 0; j < NUM_MACHINE_MODES; j++)
5352           if (!strcmp (p, GET_MODE_NAME (j)))
5353             {
5354               mode = (enum machine_mode) j;
5355               break;
5356             }
5357
5358       if (mode == VOIDmode)
5359         {
5360           error ("unknown machine mode %qs", p);
5361           return NULL_TREE;
5362         }
5363
5364       valid_mode = false;
5365       switch (GET_MODE_CLASS (mode))
5366         {
5367         case MODE_INT:
5368         case MODE_PARTIAL_INT:
5369         case MODE_FLOAT:
5370         case MODE_DECIMAL_FLOAT:
5371         case MODE_FRACT:
5372         case MODE_UFRACT:
5373         case MODE_ACCUM:
5374         case MODE_UACCUM:
5375           valid_mode = targetm.scalar_mode_supported_p (mode);
5376           break;
5377
5378         case MODE_COMPLEX_INT:
5379         case MODE_COMPLEX_FLOAT:
5380           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5381           break;
5382
5383         case MODE_VECTOR_INT:
5384         case MODE_VECTOR_FLOAT:
5385         case MODE_VECTOR_FRACT:
5386         case MODE_VECTOR_UFRACT:
5387         case MODE_VECTOR_ACCUM:
5388         case MODE_VECTOR_UACCUM:
5389           warning (OPT_Wattributes, "specifying vector types with "
5390                    "__attribute__ ((mode)) is deprecated");
5391           warning (OPT_Wattributes,
5392                    "use __attribute__ ((vector_size)) instead");
5393           valid_mode = vector_mode_valid_p (mode);
5394           break;
5395
5396         default:
5397           break;
5398         }
5399       if (!valid_mode)
5400         {
5401           error ("unable to emulate %qs", p);
5402           return NULL_TREE;
5403         }
5404
5405       if (POINTER_TYPE_P (type))
5406         {
5407           tree (*fn)(tree, enum machine_mode, bool);
5408
5409           if (!targetm.valid_pointer_mode (mode))
5410             {
5411               error ("invalid pointer mode %qs", p);
5412               return NULL_TREE;
5413             }
5414
5415           if (TREE_CODE (type) == POINTER_TYPE)
5416             fn = build_pointer_type_for_mode;
5417           else
5418             fn = build_reference_type_for_mode;
5419           typefm = fn (TREE_TYPE (type), mode, false);
5420         }
5421       else
5422         {
5423           /* For fixed-point modes, we need to test if the signness of type
5424              and the machine mode are consistent.  */
5425           if (ALL_FIXED_POINT_MODE_P (mode)
5426               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5427             {
5428               error ("signness of type and machine mode %qs don't match", p);
5429               return NULL_TREE;
5430             }
5431           /* For fixed-point modes, we need to pass saturating info.  */
5432           typefm = lang_hooks.types.type_for_mode (mode,
5433                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5434                                                       : TYPE_UNSIGNED (type));
5435         }
5436
5437       if (typefm == NULL_TREE)
5438         {
5439           error ("no data type for mode %qs", p);
5440           return NULL_TREE;
5441         }
5442       else if (TREE_CODE (type) == ENUMERAL_TYPE)
5443         {
5444           /* For enumeral types, copy the precision from the integer
5445              type returned above.  If not an INTEGER_TYPE, we can't use
5446              this mode for this type.  */
5447           if (TREE_CODE (typefm) != INTEGER_TYPE)
5448             {
5449               error ("cannot use mode %qs for enumeral types", p);
5450               return NULL_TREE;
5451             }
5452
5453           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5454             {
5455               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5456               typefm = type;
5457             }
5458           else
5459             {
5460               /* We cannot build a type variant, as there's code that assumes
5461                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
5462                  debug generators.  Instead, create a subrange type.  This
5463                  results in all of the enumeral values being emitted only once
5464                  in the original, and the subtype gets them by reference.  */
5465               if (TYPE_UNSIGNED (type))
5466                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5467               else
5468                 typefm = make_signed_type (TYPE_PRECISION (typefm));
5469               TREE_TYPE (typefm) = type;
5470             }
5471         }
5472       else if (VECTOR_MODE_P (mode)
5473                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5474                : TREE_CODE (type) != TREE_CODE (typefm))
5475         {
5476           error ("mode %qs applied to inappropriate type", p);
5477           return NULL_TREE;
5478         }
5479
5480       *node = typefm;
5481     }
5482
5483   return NULL_TREE;
5484 }
5485
5486 /* Handle a "section" attribute; arguments as in
5487    struct attribute_spec.handler.  */
5488
5489 static tree
5490 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5491                           int ARG_UNUSED (flags), bool *no_add_attrs)
5492 {
5493   tree decl = *node;
5494
5495   if (targetm.have_named_sections)
5496     {
5497       user_defined_section_attribute = true;
5498
5499       if ((TREE_CODE (decl) == FUNCTION_DECL
5500            || TREE_CODE (decl) == VAR_DECL)
5501           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5502         {
5503           if (TREE_CODE (decl) == VAR_DECL
5504               && current_function_decl != NULL_TREE
5505               && !TREE_STATIC (decl))
5506             {
5507               error ("%Jsection attribute cannot be specified for "
5508                      "local variables", decl);
5509               *no_add_attrs = true;
5510             }
5511
5512           /* The decl may have already been given a section attribute
5513              from a previous declaration.  Ensure they match.  */
5514           else if (DECL_SECTION_NAME (decl) != NULL_TREE
5515                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5516                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5517             {
5518               error ("section of %q+D conflicts with previous declaration",
5519                      *node);
5520               *no_add_attrs = true;
5521             }
5522           else if (TREE_CODE (decl) == VAR_DECL
5523                    && !targetm.have_tls && targetm.emutls.tmpl_section
5524                    && DECL_THREAD_LOCAL_P (decl))
5525             {
5526               error ("section of %q+D cannot be overridden", *node);
5527               *no_add_attrs = true;
5528             }
5529           else
5530             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5531         }
5532       else
5533         {
5534           error ("section attribute not allowed for %q+D", *node);
5535           *no_add_attrs = true;
5536         }
5537     }
5538   else
5539     {
5540       error ("%Jsection attributes are not supported for this target", *node);
5541       *no_add_attrs = true;
5542     }
5543
5544   return NULL_TREE;
5545 }
5546
5547 /* Handle a "aligned" attribute; arguments as in
5548    struct attribute_spec.handler.  */
5549
5550 static tree
5551 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5552                           int flags, bool *no_add_attrs)
5553 {
5554   tree decl = NULL_TREE;
5555   tree *type = NULL;
5556   int is_type = 0;
5557   tree align_expr = (args ? TREE_VALUE (args)
5558                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5559   int i;
5560
5561   if (DECL_P (*node))
5562     {
5563       decl = *node;
5564       type = &TREE_TYPE (decl);
5565       is_type = TREE_CODE (*node) == TYPE_DECL;
5566     }
5567   else if (TYPE_P (*node))
5568     type = node, is_type = 1;
5569
5570   if (TREE_CODE (align_expr) != INTEGER_CST)
5571     {
5572       error ("requested alignment is not a constant");
5573       *no_add_attrs = true;
5574     }
5575   else if ((i = tree_log2 (align_expr)) == -1)
5576     {
5577       error ("requested alignment is not a power of 2");
5578       *no_add_attrs = true;
5579     }
5580   else if (i > HOST_BITS_PER_INT - 2)
5581     {
5582       error ("requested alignment is too large");
5583       *no_add_attrs = true;
5584     }
5585   else if (is_type)
5586     {
5587       /* If we have a TYPE_DECL, then copy the type, so that we
5588          don't accidentally modify a builtin type.  See pushdecl.  */
5589       if (decl && TREE_TYPE (decl) != error_mark_node
5590           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5591         {
5592           tree tt = TREE_TYPE (decl);
5593           *type = build_variant_type_copy (*type);
5594           DECL_ORIGINAL_TYPE (decl) = tt;
5595           TYPE_NAME (*type) = decl;
5596           TREE_USED (*type) = TREE_USED (decl);
5597           TREE_TYPE (decl) = *type;
5598         }
5599       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5600         *type = build_variant_type_copy (*type);
5601
5602       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5603       TYPE_USER_ALIGN (*type) = 1;
5604     }
5605   else if (! VAR_OR_FUNCTION_DECL_P (decl)
5606            && TREE_CODE (decl) != FIELD_DECL)
5607     {
5608       error ("alignment may not be specified for %q+D", decl);
5609       *no_add_attrs = true;
5610     }
5611   else if (TREE_CODE (decl) == FUNCTION_DECL
5612            && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5613     {
5614       if (DECL_USER_ALIGN (decl))
5615         error ("alignment for %q+D was previously specified as %d "
5616                "and may not be decreased", decl,
5617                DECL_ALIGN (decl) / BITS_PER_UNIT);
5618       else
5619         error ("alignment for %q+D must be at least %d", decl,
5620                DECL_ALIGN (decl) / BITS_PER_UNIT);
5621       *no_add_attrs = true;
5622     }
5623   else
5624     {
5625       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5626       DECL_USER_ALIGN (decl) = 1;
5627     }
5628
5629   return NULL_TREE;
5630 }
5631
5632 /* Handle a "weak" attribute; arguments as in
5633    struct attribute_spec.handler.  */
5634
5635 static tree
5636 handle_weak_attribute (tree *node, tree name,
5637                        tree ARG_UNUSED (args),
5638                        int ARG_UNUSED (flags),
5639                        bool * ARG_UNUSED (no_add_attrs))
5640 {
5641   if (TREE_CODE (*node) == FUNCTION_DECL
5642       && DECL_DECLARED_INLINE_P (*node))
5643     {
5644       error ("inline function %q+D cannot be declared weak", *node);
5645       *no_add_attrs = true;
5646     }
5647   else if (TREE_CODE (*node) == FUNCTION_DECL
5648            || TREE_CODE (*node) == VAR_DECL)
5649     declare_weak (*node);
5650   else
5651     warning (OPT_Wattributes, "%qE attribute ignored", name);
5652
5653   return NULL_TREE;
5654 }
5655
5656 /* Handle an "alias" attribute; arguments as in
5657    struct attribute_spec.handler.  */
5658
5659 static tree
5660 handle_alias_attribute (tree *node, tree name, tree args,
5661                         int ARG_UNUSED (flags), bool *no_add_attrs)
5662 {
5663   tree decl = *node;
5664
5665   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5666       || (TREE_CODE (decl) != FUNCTION_DECL
5667           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5668       /* A static variable declaration is always a tentative definition,
5669          but the alias is a non-tentative definition which overrides.  */
5670       || (TREE_CODE (decl) != FUNCTION_DECL
5671           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5672     {
5673       error ("%q+D defined both normally and as an alias", decl);
5674       *no_add_attrs = true;
5675     }
5676
5677   /* Note that the very first time we process a nested declaration,
5678      decl_function_context will not be set.  Indeed, *would* never
5679      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5680      we do below.  After such frobbery, pushdecl would set the context.
5681      In any case, this is never what we want.  */
5682   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5683     {
5684       tree id;
5685
5686       id = TREE_VALUE (args);
5687       if (TREE_CODE (id) != STRING_CST)
5688         {
5689           error ("alias argument not a string");
5690           *no_add_attrs = true;
5691           return NULL_TREE;
5692         }
5693       id = get_identifier (TREE_STRING_POINTER (id));
5694       /* This counts as a use of the object pointed to.  */
5695       TREE_USED (id) = 1;
5696
5697       if (TREE_CODE (decl) == FUNCTION_DECL)
5698         DECL_INITIAL (decl) = error_mark_node;
5699       else
5700         {
5701           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5702             DECL_EXTERNAL (decl) = 1;
5703           else
5704             DECL_EXTERNAL (decl) = 0;
5705           TREE_STATIC (decl) = 1;
5706         }
5707     }
5708   else
5709     {
5710       warning (OPT_Wattributes, "%qE attribute ignored", name);
5711       *no_add_attrs = true;
5712     }
5713
5714   return NULL_TREE;
5715 }
5716
5717 /* Handle a "weakref" attribute; arguments as in struct
5718    attribute_spec.handler.  */
5719
5720 static tree
5721 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5722                           int flags, bool *no_add_attrs)
5723 {
5724   tree attr = NULL_TREE;
5725
5726   /* We must ignore the attribute when it is associated with
5727      local-scoped decls, since attribute alias is ignored and many
5728      such symbols do not even have a DECL_WEAK field.  */
5729   if (decl_function_context (*node) || current_function_decl)
5730     {
5731       warning (OPT_Wattributes, "%qE attribute ignored", name);
5732       *no_add_attrs = true;
5733       return NULL_TREE;
5734     }
5735
5736   /* The idea here is that `weakref("name")' mutates into `weakref,
5737      alias("name")', and weakref without arguments, in turn,
5738      implicitly adds weak. */
5739
5740   if (args)
5741     {
5742       attr = tree_cons (get_identifier ("alias"), args, attr);
5743       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5744
5745       *no_add_attrs = true;
5746
5747       decl_attributes (node, attr, flags);
5748     }
5749   else
5750     {
5751       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5752         error ("%Jweakref attribute must appear before alias attribute",
5753                *node);
5754
5755       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5756          and that isn't supported; and because it wants to add it to
5757          the list of weak decls, which isn't helpful.  */
5758       DECL_WEAK (*node) = 1;
5759     }
5760
5761   return NULL_TREE;
5762 }
5763
5764 /* Handle an "visibility" attribute; arguments as in
5765    struct attribute_spec.handler.  */
5766
5767 static tree
5768 handle_visibility_attribute (tree *node, tree name, tree args,
5769                              int ARG_UNUSED (flags),
5770                              bool *ARG_UNUSED (no_add_attrs))
5771 {
5772   tree decl = *node;
5773   tree id = TREE_VALUE (args);
5774   enum symbol_visibility vis;
5775
5776   if (TYPE_P (*node))
5777     {
5778       if (TREE_CODE (*node) == ENUMERAL_TYPE)
5779         /* OK */;
5780       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5781         {
5782           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5783                    name);
5784           return NULL_TREE;
5785         }
5786       else if (TYPE_FIELDS (*node))
5787         {
5788           error ("%qE attribute ignored because %qT is already defined",
5789                  name, *node);
5790           return NULL_TREE;
5791         }
5792     }
5793   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5794     {
5795       warning (OPT_Wattributes, "%qE attribute ignored", name);
5796       return NULL_TREE;
5797     }
5798
5799   if (TREE_CODE (id) != STRING_CST)
5800     {
5801       error ("visibility argument not a string");
5802       return NULL_TREE;
5803     }
5804
5805   /*  If this is a type, set the visibility on the type decl.  */
5806   if (TYPE_P (decl))
5807     {
5808       decl = TYPE_NAME (decl);
5809       if (!decl)
5810         return NULL_TREE;
5811       if (TREE_CODE (decl) == IDENTIFIER_NODE)
5812         {
5813            warning (OPT_Wattributes, "%qE attribute ignored on types",
5814                     name);
5815            return NULL_TREE;
5816         }
5817     }
5818
5819   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5820     vis = VISIBILITY_DEFAULT;
5821   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5822     vis = VISIBILITY_INTERNAL;
5823   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5824     vis = VISIBILITY_HIDDEN;
5825   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5826     vis = VISIBILITY_PROTECTED;
5827   else
5828     {
5829       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5830       vis = VISIBILITY_DEFAULT;
5831     }
5832
5833   if (DECL_VISIBILITY_SPECIFIED (decl)
5834       && vis != DECL_VISIBILITY (decl))
5835     {
5836       tree attributes = (TYPE_P (*node)
5837                          ? TYPE_ATTRIBUTES (*node)
5838                          : DECL_ATTRIBUTES (decl));
5839       if (lookup_attribute ("visibility", attributes))
5840         error ("%qD redeclared with different visibility", decl);
5841       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5842                && lookup_attribute ("dllimport", attributes))
5843         error ("%qD was declared %qs which implies default visibility",
5844                decl, "dllimport");
5845       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5846                && lookup_attribute ("dllexport", attributes))
5847         error ("%qD was declared %qs which implies default visibility",
5848                decl, "dllexport");
5849     }
5850
5851   DECL_VISIBILITY (decl) = vis;
5852   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5853
5854   /* Go ahead and attach the attribute to the node as well.  This is needed
5855      so we can determine whether we have VISIBILITY_DEFAULT because the
5856      visibility was not specified, or because it was explicitly overridden
5857      from the containing scope.  */
5858
5859   return NULL_TREE;
5860 }
5861
5862 /* Determine the ELF symbol visibility for DECL, which is either a
5863    variable or a function.  It is an error to use this function if a
5864    definition of DECL is not available in this translation unit.
5865    Returns true if the final visibility has been determined by this
5866    function; false if the caller is free to make additional
5867    modifications.  */
5868
5869 bool
5870 c_determine_visibility (tree decl)
5871 {
5872   gcc_assert (TREE_CODE (decl) == VAR_DECL
5873               || TREE_CODE (decl) == FUNCTION_DECL);
5874
5875   /* If the user explicitly specified the visibility with an
5876      attribute, honor that.  DECL_VISIBILITY will have been set during
5877      the processing of the attribute.  We check for an explicit
5878      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5879      to distinguish the use of an attribute from the use of a "#pragma
5880      GCC visibility push(...)"; in the latter case we still want other
5881      considerations to be able to overrule the #pragma.  */
5882   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
5883       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5884           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
5885               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
5886     return true;
5887
5888   /* Set default visibility to whatever the user supplied with
5889      visibility_specified depending on #pragma GCC visibility.  */
5890   if (!DECL_VISIBILITY_SPECIFIED (decl))
5891     {
5892       DECL_VISIBILITY (decl) = default_visibility;
5893       DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5894     }
5895   return false;
5896 }
5897
5898 /* Handle an "tls_model" attribute; arguments as in
5899    struct attribute_spec.handler.  */
5900
5901 static tree
5902 handle_tls_model_attribute (tree *node, tree name, tree args,
5903                             int ARG_UNUSED (flags), bool *no_add_attrs)
5904 {
5905   tree id;
5906   tree decl = *node;
5907   enum tls_model kind;
5908
5909   *no_add_attrs = true;
5910
5911   if (!DECL_THREAD_LOCAL_P (decl))
5912     {
5913       warning (OPT_Wattributes, "%qE attribute ignored", name);
5914       return NULL_TREE;
5915     }
5916
5917   kind = DECL_TLS_MODEL (decl);
5918   id = TREE_VALUE (args);
5919   if (TREE_CODE (id) != STRING_CST)
5920     {
5921       error ("tls_model argument not a string");
5922       return NULL_TREE;
5923     }
5924
5925   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5926     kind = TLS_MODEL_LOCAL_EXEC;
5927   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5928     kind = TLS_MODEL_INITIAL_EXEC;
5929   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5930     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5931   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5932     kind = TLS_MODEL_GLOBAL_DYNAMIC;
5933   else
5934     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5935
5936   DECL_TLS_MODEL (decl) = kind;
5937   return NULL_TREE;
5938 }
5939
5940 /* Handle a "no_instrument_function" attribute; arguments as in
5941    struct attribute_spec.handler.  */
5942
5943 static tree
5944 handle_no_instrument_function_attribute (tree *node, tree name,
5945                                          tree ARG_UNUSED (args),
5946                                          int ARG_UNUSED (flags),
5947                                          bool *no_add_attrs)
5948 {
5949   tree decl = *node;
5950
5951   if (TREE_CODE (decl) != FUNCTION_DECL)
5952     {
5953       error ("%J%qE attribute applies only to functions", decl, name);
5954       *no_add_attrs = true;
5955     }
5956   else if (DECL_INITIAL (decl))
5957     {
5958       error ("%Jcan%'t set %qE attribute after definition", decl, name);
5959       *no_add_attrs = true;
5960     }
5961   else
5962     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5963
5964   return NULL_TREE;
5965 }
5966
5967 /* Handle a "malloc" attribute; arguments as in
5968    struct attribute_spec.handler.  */
5969
5970 static tree
5971 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5972                          int ARG_UNUSED (flags), bool *no_add_attrs)
5973 {
5974   if (TREE_CODE (*node) == FUNCTION_DECL
5975       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5976     DECL_IS_MALLOC (*node) = 1;
5977   else
5978     {
5979       warning (OPT_Wattributes, "%qE attribute ignored", name);
5980       *no_add_attrs = true;
5981     }
5982
5983   return NULL_TREE;
5984 }
5985
5986 /* Handle a "alloc_size" attribute; arguments as in
5987    struct attribute_spec.handler.  */
5988
5989 static tree
5990 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5991                              int ARG_UNUSED (flags), bool *no_add_attrs)
5992 {
5993   unsigned arg_count = type_num_arguments (*node);
5994   for (; args; args = TREE_CHAIN (args))
5995     {
5996       tree position = TREE_VALUE (args);
5997
5998       if (TREE_CODE (position) != INTEGER_CST
5999           || TREE_INT_CST_HIGH (position)
6000           || TREE_INT_CST_LOW (position) < 1
6001           || TREE_INT_CST_LOW (position) > arg_count )
6002         {
6003           warning (OPT_Wattributes,
6004                    "alloc_size parameter outside range");
6005           *no_add_attrs = true;
6006           return NULL_TREE;
6007         }
6008     }
6009   return NULL_TREE;
6010 }
6011
6012 /* Handle a "returns_twice" attribute; arguments as in
6013    struct attribute_spec.handler.  */
6014
6015 static tree
6016 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6017                          int ARG_UNUSED (flags), bool *no_add_attrs)
6018 {
6019   if (TREE_CODE (*node) == FUNCTION_DECL)
6020     DECL_IS_RETURNS_TWICE (*node) = 1;
6021   else
6022     {
6023       warning (OPT_Wattributes, "%qE attribute ignored", name);
6024       *no_add_attrs = true;
6025     }
6026
6027   return NULL_TREE;
6028 }
6029
6030 /* Handle a "no_limit_stack" attribute; arguments as in
6031    struct attribute_spec.handler.  */
6032
6033 static tree
6034 handle_no_limit_stack_attribute (tree *node, tree name,
6035                                  tree ARG_UNUSED (args),
6036                                  int ARG_UNUSED (flags),
6037                                  bool *no_add_attrs)
6038 {
6039   tree decl = *node;
6040
6041   if (TREE_CODE (decl) != FUNCTION_DECL)
6042     {
6043       error ("%J%qE attribute applies only to functions", decl, name);
6044       *no_add_attrs = true;
6045     }
6046   else if (DECL_INITIAL (decl))
6047     {
6048       error ("%Jcan%'t set %qE attribute after definition", decl, name);
6049       *no_add_attrs = true;
6050     }
6051   else
6052     DECL_NO_LIMIT_STACK (decl) = 1;
6053
6054   return NULL_TREE;
6055 }
6056
6057 /* Handle a "pure" attribute; arguments as in
6058    struct attribute_spec.handler.  */
6059
6060 static tree
6061 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6062                        int ARG_UNUSED (flags), bool *no_add_attrs)
6063 {
6064   if (TREE_CODE (*node) == FUNCTION_DECL)
6065     DECL_PURE_P (*node) = 1;
6066   /* ??? TODO: Support types.  */
6067   else
6068     {
6069       warning (OPT_Wattributes, "%qE attribute ignored", name);
6070       *no_add_attrs = true;
6071     }
6072
6073   return NULL_TREE;
6074 }
6075
6076 /* Handle a "no vops" attribute; arguments as in
6077    struct attribute_spec.handler.  */
6078
6079 static tree
6080 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6081                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6082                          bool *ARG_UNUSED (no_add_attrs))
6083 {
6084   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6085   DECL_IS_NOVOPS (*node) = 1;
6086   return NULL_TREE;
6087 }
6088
6089 /* Handle a "deprecated" attribute; arguments as in
6090    struct attribute_spec.handler.  */
6091
6092 static tree
6093 handle_deprecated_attribute (tree *node, tree name,
6094                              tree ARG_UNUSED (args), int flags,
6095                              bool *no_add_attrs)
6096 {
6097   tree type = NULL_TREE;
6098   int warn = 0;
6099   tree what = NULL_TREE;
6100
6101   if (DECL_P (*node))
6102     {
6103       tree decl = *node;
6104       type = TREE_TYPE (decl);
6105
6106       if (TREE_CODE (decl) == TYPE_DECL
6107           || TREE_CODE (decl) == PARM_DECL
6108           || TREE_CODE (decl) == VAR_DECL
6109           || TREE_CODE (decl) == FUNCTION_DECL
6110           || TREE_CODE (decl) == FIELD_DECL)
6111         TREE_DEPRECATED (decl) = 1;
6112       else
6113         warn = 1;
6114     }
6115   else if (TYPE_P (*node))
6116     {
6117       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6118         *node = build_variant_type_copy (*node);
6119       TREE_DEPRECATED (*node) = 1;
6120       type = *node;
6121     }
6122   else
6123     warn = 1;
6124
6125   if (warn)
6126     {
6127       *no_add_attrs = true;
6128       if (type && TYPE_NAME (type))
6129         {
6130           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6131             what = TYPE_NAME (*node);
6132           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6133                    && DECL_NAME (TYPE_NAME (type)))
6134             what = DECL_NAME (TYPE_NAME (type));
6135         }
6136       if (what)
6137         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6138       else
6139         warning (OPT_Wattributes, "%qE attribute ignored", name);
6140     }
6141
6142   return NULL_TREE;
6143 }
6144
6145 /* Handle a "vector_size" attribute; arguments as in
6146    struct attribute_spec.handler.  */
6147
6148 static tree
6149 handle_vector_size_attribute (tree *node, tree name, tree args,
6150                               int ARG_UNUSED (flags),
6151                               bool *no_add_attrs)
6152 {
6153   unsigned HOST_WIDE_INT vecsize, nunits;
6154   enum machine_mode orig_mode;
6155   tree type = *node, new_type, size;
6156
6157   *no_add_attrs = true;
6158
6159   size = TREE_VALUE (args);
6160
6161   if (!host_integerp (size, 1))
6162     {
6163       warning (OPT_Wattributes, "%qE attribute ignored", name);
6164       return NULL_TREE;
6165     }
6166
6167   /* Get the vector size (in bytes).  */
6168   vecsize = tree_low_cst (size, 1);
6169
6170   /* We need to provide for vector pointers, vector arrays, and
6171      functions returning vectors.  For example:
6172
6173        __attribute__((vector_size(16))) short *foo;
6174
6175      In this case, the mode is SI, but the type being modified is
6176      HI, so we need to look further.  */
6177
6178   while (POINTER_TYPE_P (type)
6179          || TREE_CODE (type) == FUNCTION_TYPE
6180          || TREE_CODE (type) == METHOD_TYPE
6181          || TREE_CODE (type) == ARRAY_TYPE
6182          || TREE_CODE (type) == OFFSET_TYPE)
6183     type = TREE_TYPE (type);
6184
6185   /* Get the mode of the type being modified.  */
6186   orig_mode = TYPE_MODE (type);
6187
6188   if ((!INTEGRAL_TYPE_P (type)
6189        && !SCALAR_FLOAT_TYPE_P (type)
6190        && !FIXED_POINT_TYPE_P (type))
6191       || (!SCALAR_FLOAT_MODE_P (orig_mode)
6192           && GET_MODE_CLASS (orig_mode) != MODE_INT
6193           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6194       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
6195     {
6196       error ("invalid vector type for attribute %qE", name);
6197       return NULL_TREE;
6198     }
6199
6200   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6201     {
6202       error ("vector size not an integral multiple of component size");
6203       return NULL;
6204     }
6205
6206   if (vecsize == 0)
6207     {
6208       error ("zero vector size");
6209       return NULL;
6210     }
6211
6212   /* Calculate how many units fit in the vector.  */
6213   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6214   if (nunits & (nunits - 1))
6215     {
6216       error ("number of components of the vector not a power of two");
6217       return NULL_TREE;
6218     }
6219
6220   new_type = build_vector_type (type, nunits);
6221
6222   /* Build back pointers if needed.  */
6223   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6224
6225   return NULL_TREE;
6226 }
6227
6228 /* Handle the "nonnull" attribute.  */
6229 static tree
6230 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6231                           tree args, int ARG_UNUSED (flags),
6232                           bool *no_add_attrs)
6233 {
6234   tree type = *node;
6235   unsigned HOST_WIDE_INT attr_arg_num;
6236
6237   /* If no arguments are specified, all pointer arguments should be
6238      non-null.  Verify a full prototype is given so that the arguments
6239      will have the correct types when we actually check them later.  */
6240   if (!args)
6241     {
6242       if (!TYPE_ARG_TYPES (type))
6243         {
6244           error ("nonnull attribute without arguments on a non-prototype");
6245           *no_add_attrs = true;
6246         }
6247       return NULL_TREE;
6248     }
6249
6250   /* Argument list specified.  Verify that each argument number references
6251      a pointer argument.  */
6252   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6253     {
6254       tree argument;
6255       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6256
6257       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6258         {
6259           error ("nonnull argument has invalid operand number (argument %lu)",
6260                  (unsigned long) attr_arg_num);
6261           *no_add_attrs = true;
6262           return NULL_TREE;
6263         }
6264
6265       argument = TYPE_ARG_TYPES (type);
6266       if (argument)
6267         {
6268           for (ck_num = 1; ; ck_num++)
6269             {
6270               if (!argument || ck_num == arg_num)
6271                 break;
6272               argument = TREE_CHAIN (argument);
6273             }
6274
6275           if (!argument
6276               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6277             {
6278               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6279                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
6280               *no_add_attrs = true;
6281               return NULL_TREE;
6282             }
6283
6284           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6285             {
6286               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6287                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
6288               *no_add_attrs = true;
6289               return NULL_TREE;
6290             }
6291         }
6292     }
6293
6294   return NULL_TREE;
6295 }
6296
6297 /* Check the argument list of a function call for null in argument slots
6298    that are marked as requiring a non-null pointer argument.  The NARGS
6299    arguments are passed in the array ARGARRAY.
6300 */
6301
6302 static void
6303 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6304 {
6305   tree a, args;
6306   int i;
6307
6308   for (a = attrs; a; a = TREE_CHAIN (a))
6309     {
6310       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6311         {
6312           args = TREE_VALUE (a);
6313
6314           /* Walk the argument list.  If we encounter an argument number we
6315              should check for non-null, do it.  If the attribute has no args,
6316              then every pointer argument is checked (in which case the check
6317              for pointer type is done in check_nonnull_arg).  */
6318           for (i = 0; i < nargs; i++)
6319             {
6320               if (!args || nonnull_check_p (args, i + 1))
6321                 check_function_arguments_recurse (check_nonnull_arg, NULL,
6322                                                   argarray[i],
6323                                                   i + 1);
6324             }
6325         }
6326     }
6327 }
6328
6329 /* Check that the Nth argument of a function call (counting backwards
6330    from the end) is a (pointer)0.  The NARGS arguments are passed in the
6331    array ARGARRAY.  */
6332
6333 static void
6334 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6335 {
6336   tree attr = lookup_attribute ("sentinel", attrs);
6337
6338   if (attr)
6339     {
6340       int len = 0;
6341       int pos = 0;
6342       tree sentinel;
6343
6344       /* Skip over the named arguments.  */
6345       while (typelist && len < nargs)
6346         {
6347           typelist = TREE_CHAIN (typelist);
6348           len++;
6349         }
6350
6351       if (TREE_VALUE (attr))
6352         {
6353           tree p = TREE_VALUE (TREE_VALUE (attr));
6354           pos = TREE_INT_CST_LOW (p);
6355         }
6356
6357       /* The sentinel must be one of the varargs, i.e.
6358          in position >= the number of fixed arguments.  */
6359       if ((nargs - 1 - pos) < len)
6360         {
6361           warning (OPT_Wformat,
6362                    "not enough variable arguments to fit a sentinel");
6363           return;
6364         }
6365
6366       /* Validate the sentinel.  */
6367       sentinel = argarray[nargs - 1 - pos];
6368       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6369            || !integer_zerop (sentinel))
6370           /* Although __null (in C++) is only an integer we allow it
6371              nevertheless, as we are guaranteed that it's exactly
6372              as wide as a pointer, and we don't want to force
6373              users to cast the NULL they have written there.
6374              We warn with -Wstrict-null-sentinel, though.  */
6375           && (warn_strict_null_sentinel || null_node != sentinel))
6376         warning (OPT_Wformat, "missing sentinel in function call");
6377     }
6378 }
6379
6380 /* Helper for check_function_nonnull; given a list of operands which
6381    must be non-null in ARGS, determine if operand PARAM_NUM should be
6382    checked.  */
6383
6384 static bool
6385 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6386 {
6387   unsigned HOST_WIDE_INT arg_num = 0;
6388
6389   for (; args; args = TREE_CHAIN (args))
6390     {
6391       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6392
6393       gcc_assert (found);
6394
6395       if (arg_num == param_num)
6396         return true;
6397     }
6398   return false;
6399 }
6400
6401 /* Check that the function argument PARAM (which is operand number
6402    PARAM_NUM) is non-null.  This is called by check_function_nonnull
6403    via check_function_arguments_recurse.  */
6404
6405 static void
6406 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6407                    unsigned HOST_WIDE_INT param_num)
6408 {
6409   /* Just skip checking the argument if it's not a pointer.  This can
6410      happen if the "nonnull" attribute was given without an operand
6411      list (which means to check every pointer argument).  */
6412
6413   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6414     return;
6415
6416   if (integer_zerop (param))
6417     warning (OPT_Wnonnull, "null argument where non-null required "
6418              "(argument %lu)", (unsigned long) param_num);
6419 }
6420
6421 /* Helper for nonnull attribute handling; fetch the operand number
6422    from the attribute argument list.  */
6423
6424 static bool
6425 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6426 {
6427   /* Verify the arg number is a constant.  */
6428   if (TREE_CODE (arg_num_expr) != INTEGER_CST
6429       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6430     return false;
6431
6432   *valp = TREE_INT_CST_LOW (arg_num_expr);
6433   return true;
6434 }
6435
6436 /* Handle a "nothrow" attribute; arguments as in
6437    struct attribute_spec.handler.  */
6438
6439 static tree
6440 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6441                           int ARG_UNUSED (flags), bool *no_add_attrs)
6442 {
6443   if (TREE_CODE (*node) == FUNCTION_DECL)
6444     TREE_NOTHROW (*node) = 1;
6445   /* ??? TODO: Support types.  */
6446   else
6447     {
6448       warning (OPT_Wattributes, "%qE attribute ignored", name);
6449       *no_add_attrs = true;
6450     }
6451
6452   return NULL_TREE;
6453 }
6454
6455 /* Handle a "cleanup" attribute; arguments as in
6456    struct attribute_spec.handler.  */
6457
6458 static tree
6459 handle_cleanup_attribute (tree *node, tree name, tree args,
6460                           int ARG_UNUSED (flags), bool *no_add_attrs)
6461 {
6462   tree decl = *node;
6463   tree cleanup_id, cleanup_decl;
6464
6465   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6466      for global destructors in C++.  This requires infrastructure that
6467      we don't have generically at the moment.  It's also not a feature
6468      we'd be missing too much, since we do have attribute constructor.  */
6469   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6470     {
6471       warning (OPT_Wattributes, "%qE attribute ignored", name);
6472       *no_add_attrs = true;
6473       return NULL_TREE;
6474     }
6475
6476   /* Verify that the argument is a function in scope.  */
6477   /* ??? We could support pointers to functions here as well, if
6478      that was considered desirable.  */
6479   cleanup_id = TREE_VALUE (args);
6480   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6481     {
6482       error ("cleanup argument not an identifier");
6483       *no_add_attrs = true;
6484       return NULL_TREE;
6485     }
6486   cleanup_decl = lookup_name (cleanup_id);
6487   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6488     {
6489       error ("cleanup argument not a function");
6490       *no_add_attrs = true;
6491       return NULL_TREE;
6492     }
6493
6494   /* That the function has proper type is checked with the
6495      eventual call to build_function_call.  */
6496
6497   return NULL_TREE;
6498 }
6499
6500 /* Handle a "warn_unused_result" attribute.  No special handling.  */
6501
6502 static tree
6503 handle_warn_unused_result_attribute (tree *node, tree name,
6504                                tree ARG_UNUSED (args),
6505                                int ARG_UNUSED (flags), bool *no_add_attrs)
6506 {
6507   /* Ignore the attribute for functions not returning any value.  */
6508   if (VOID_TYPE_P (TREE_TYPE (*node)))
6509     {
6510       warning (OPT_Wattributes, "%qE attribute ignored", name);
6511       *no_add_attrs = true;
6512     }
6513
6514   return NULL_TREE;
6515 }
6516
6517 /* Handle a "sentinel" attribute.  */
6518
6519 static tree
6520 handle_sentinel_attribute (tree *node, tree name, tree args,
6521                            int ARG_UNUSED (flags), bool *no_add_attrs)
6522 {
6523   tree params = TYPE_ARG_TYPES (*node);
6524
6525   if (!params)
6526     {
6527       warning (OPT_Wattributes,
6528                "%qE attribute requires prototypes with named arguments", name);
6529       *no_add_attrs = true;
6530     }
6531   else
6532     {
6533       while (TREE_CHAIN (params))
6534         params = TREE_CHAIN (params);
6535
6536       if (VOID_TYPE_P (TREE_VALUE (params)))
6537         {
6538           warning (OPT_Wattributes,
6539                    "%qE attribute only applies to variadic functions", name);
6540           *no_add_attrs = true;
6541         }
6542     }
6543
6544   if (args)
6545     {
6546       tree position = TREE_VALUE (args);
6547
6548       if (TREE_CODE (position) != INTEGER_CST)
6549         {
6550           warning (OPT_Wattributes,
6551                    "requested position is not an integer constant");
6552           *no_add_attrs = true;
6553         }
6554       else
6555         {
6556           if (tree_int_cst_lt (position, integer_zero_node))
6557             {
6558               warning (OPT_Wattributes,
6559                        "requested position is less than zero");
6560               *no_add_attrs = true;
6561             }
6562         }
6563     }
6564
6565   return NULL_TREE;
6566 }
6567
6568 /* Handle a "type_generic" attribute.  */
6569
6570 static tree
6571 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6572                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6573                                bool * ARG_UNUSED (no_add_attrs))
6574 {
6575   tree params;
6576
6577   /* Ensure we have a function type.  */
6578   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6579
6580   params = TYPE_ARG_TYPES (*node);
6581   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6582     params = TREE_CHAIN (params);
6583
6584   /* Ensure we have a variadic function.  */
6585   gcc_assert (!params);
6586
6587   return NULL_TREE;
6588 }
6589 \f
6590 /* Check for valid arguments being passed to a function.
6591    ATTRS is a list of attributes.  There are NARGS arguments in the array
6592    ARGARRAY.  TYPELIST is the list of argument types for the function.
6593  */
6594 void
6595 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
6596 {
6597   /* Check for null being passed in a pointer argument that must be
6598      non-null.  We also need to do this if format checking is enabled.  */
6599
6600   if (warn_nonnull)
6601     check_function_nonnull (attrs, nargs, argarray);
6602
6603   /* Check for errors in format strings.  */
6604
6605   if (warn_format || warn_missing_format_attribute)
6606     check_function_format (attrs, nargs, argarray);
6607
6608   if (warn_format)
6609     check_function_sentinel (attrs, nargs, argarray, typelist);
6610 }
6611
6612 /* Generic argument checking recursion routine.  PARAM is the argument to
6613    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
6614    once the argument is resolved.  CTX is context for the callback.  */
6615 void
6616 check_function_arguments_recurse (void (*callback)
6617                                   (void *, tree, unsigned HOST_WIDE_INT),
6618                                   void *ctx, tree param,
6619                                   unsigned HOST_WIDE_INT param_num)
6620 {
6621   if (CONVERT_EXPR_P (param)
6622       && (TYPE_PRECISION (TREE_TYPE (param))
6623           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6624     {
6625       /* Strip coercion.  */
6626       check_function_arguments_recurse (callback, ctx,
6627                                         TREE_OPERAND (param, 0), param_num);
6628       return;
6629     }
6630
6631   if (TREE_CODE (param) == CALL_EXPR)
6632     {
6633       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6634       tree attrs;
6635       bool found_format_arg = false;
6636
6637       /* See if this is a call to a known internationalization function
6638          that modifies a format arg.  Such a function may have multiple
6639          format_arg attributes (for example, ngettext).  */
6640
6641       for (attrs = TYPE_ATTRIBUTES (type);
6642            attrs;
6643            attrs = TREE_CHAIN (attrs))
6644         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6645           {
6646             tree inner_arg;
6647             tree format_num_expr;
6648             int format_num;
6649             int i;
6650             call_expr_arg_iterator iter;
6651
6652             /* Extract the argument number, which was previously checked
6653                to be valid.  */
6654             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6655
6656             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6657                         && !TREE_INT_CST_HIGH (format_num_expr));
6658
6659             format_num = TREE_INT_CST_LOW (format_num_expr);
6660
6661             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6662                  inner_arg != 0;
6663                  inner_arg = next_call_expr_arg (&iter), i++)
6664               if (i == format_num)
6665                 {
6666                   check_function_arguments_recurse (callback, ctx,
6667                                                     inner_arg, param_num);
6668                   found_format_arg = true;
6669                   break;
6670                 }
6671           }
6672
6673       /* If we found a format_arg attribute and did a recursive check,
6674          we are done with checking this argument.  Otherwise, we continue
6675          and this will be considered a non-literal.  */
6676       if (found_format_arg)
6677         return;
6678     }
6679
6680   if (TREE_CODE (param) == COND_EXPR)
6681     {
6682       /* Check both halves of the conditional expression.  */
6683       check_function_arguments_recurse (callback, ctx,
6684                                         TREE_OPERAND (param, 1), param_num);
6685       check_function_arguments_recurse (callback, ctx,
6686                                         TREE_OPERAND (param, 2), param_num);
6687       return;
6688     }
6689
6690   (*callback) (ctx, param, param_num);
6691 }
6692
6693 /* Checks the number of arguments NARGS against the required number
6694    REQUIRED and issues an error if there is a mismatch.  Returns true
6695    if the number of arguments is correct, otherwise false.  */
6696
6697 static bool
6698 validate_nargs (tree fndecl, int nargs, int required)
6699 {
6700   if (nargs < required)
6701     {
6702       error ("not enough arguments to function %qE", fndecl);
6703       return false;
6704     }
6705   else if (nargs > required)
6706     {
6707       error ("too many arguments to function %qE", fndecl);
6708       return false;
6709     }
6710   return true;
6711 }
6712
6713 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
6714    Returns false if there was an error, otherwise true.  */
6715
6716 bool
6717 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
6718 {
6719   if (!DECL_BUILT_IN (fndecl)
6720       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
6721     return true;
6722
6723   switch (DECL_FUNCTION_CODE (fndecl))
6724     {
6725     case BUILT_IN_CONSTANT_P:
6726       return validate_nargs (fndecl, nargs, 1);
6727
6728     case BUILT_IN_ISFINITE:
6729     case BUILT_IN_ISINF:
6730     case BUILT_IN_ISINF_SIGN:
6731     case BUILT_IN_ISNAN:
6732     case BUILT_IN_ISNORMAL:
6733       if (validate_nargs (fndecl, nargs, 1))
6734         {
6735           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
6736             {
6737               error ("non-floating-point argument in call to "
6738                      "function %qE", fndecl);
6739               return false;
6740             }
6741           return true;
6742         }
6743       return false;
6744
6745     case BUILT_IN_ISGREATER:
6746     case BUILT_IN_ISGREATEREQUAL:
6747     case BUILT_IN_ISLESS:
6748     case BUILT_IN_ISLESSEQUAL:
6749     case BUILT_IN_ISLESSGREATER:
6750     case BUILT_IN_ISUNORDERED:
6751       if (validate_nargs (fndecl, nargs, 2))
6752         {
6753           enum tree_code code0, code1;
6754           code0 = TREE_CODE (TREE_TYPE (args[0]));
6755           code1 = TREE_CODE (TREE_TYPE (args[1]));
6756           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
6757                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
6758                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
6759             {
6760               error ("non-floating-point arguments in call to "
6761                      "function %qE", fndecl);
6762               return false;
6763             }
6764           return true;
6765         }
6766       return false;
6767
6768     case BUILT_IN_FPCLASSIFY:
6769       if (validate_nargs (fndecl, nargs, 6))
6770         {
6771           unsigned i;
6772
6773           for (i=0; i<5; i++)
6774             if (TREE_CODE (args[i]) != INTEGER_CST)
6775               {
6776                 error ("non-const integer argument %u in call to function %qE",
6777                        i+1, fndecl);
6778                 return false;
6779               }
6780
6781           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
6782             {
6783               error ("non-floating-point argument in call to function %qE",
6784                      fndecl);
6785               return false;
6786             }
6787           return true;
6788         }
6789       return false;
6790
6791     default:
6792       return true;
6793     }
6794 }
6795
6796 /* Function to help qsort sort FIELD_DECLs by name order.  */
6797
6798 int
6799 field_decl_cmp (const void *x_p, const void *y_p)
6800 {
6801   const tree *const x = (const tree *const) x_p;
6802   const tree *const y = (const tree *const) y_p;
6803
6804   if (DECL_NAME (*x) == DECL_NAME (*y))
6805     /* A nontype is "greater" than a type.  */
6806     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6807   if (DECL_NAME (*x) == NULL_TREE)
6808     return -1;
6809   if (DECL_NAME (*y) == NULL_TREE)
6810     return 1;
6811   if (DECL_NAME (*x) < DECL_NAME (*y))
6812     return -1;
6813   return 1;
6814 }
6815
6816 static struct {
6817   gt_pointer_operator new_value;
6818   void *cookie;
6819 } resort_data;
6820
6821 /* This routine compares two fields like field_decl_cmp but using the
6822 pointer operator in resort_data.  */
6823
6824 static int
6825 resort_field_decl_cmp (const void *x_p, const void *y_p)
6826 {
6827   const tree *const x = (const tree *const) x_p;
6828   const tree *const y = (const tree *const) y_p;
6829
6830   if (DECL_NAME (*x) == DECL_NAME (*y))
6831     /* A nontype is "greater" than a type.  */
6832     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6833   if (DECL_NAME (*x) == NULL_TREE)
6834     return -1;
6835   if (DECL_NAME (*y) == NULL_TREE)
6836     return 1;
6837   {
6838     tree d1 = DECL_NAME (*x);
6839     tree d2 = DECL_NAME (*y);
6840     resort_data.new_value (&d1, resort_data.cookie);
6841     resort_data.new_value (&d2, resort_data.cookie);
6842     if (d1 < d2)
6843       return -1;
6844   }
6845   return 1;
6846 }
6847
6848 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
6849
6850 void
6851 resort_sorted_fields (void *obj,
6852                       void * ARG_UNUSED (orig_obj),
6853                       gt_pointer_operator new_value,
6854                       void *cookie)
6855 {
6856   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6857   resort_data.new_value = new_value;
6858   resort_data.cookie = cookie;
6859   qsort (&sf->elts[0], sf->len, sizeof (tree),
6860          resort_field_decl_cmp);
6861 }
6862
6863 /* Subroutine of c_parse_error.
6864    Return the result of concatenating LHS and RHS. RHS is really
6865    a string literal, its first character is indicated by RHS_START and
6866    RHS_SIZE is its length (including the terminating NUL character).
6867
6868    The caller is responsible for deleting the returned pointer.  */
6869
6870 static char *
6871 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6872 {
6873   const int lhs_size = strlen (lhs);
6874   char *result = XNEWVEC (char, lhs_size + rhs_size);
6875   strncpy (result, lhs, lhs_size);
6876   strncpy (result + lhs_size, rhs_start, rhs_size);
6877   return result;
6878 }
6879
6880 /* Issue the error given by GMSGID, indicating that it occurred before
6881    TOKEN, which had the associated VALUE.  */
6882
6883 void
6884 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6885 {
6886 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6887
6888   char *message = NULL;
6889
6890   if (token == CPP_EOF)
6891     message = catenate_messages (gmsgid, " at end of input");
6892   else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
6893            || token == CPP_CHAR32)
6894     {
6895       unsigned int val = TREE_INT_CST_LOW (value);
6896       const char *prefix;
6897
6898       switch (token)
6899         {
6900         default:
6901           prefix = "";
6902           break;
6903         case CPP_WCHAR:
6904           prefix = "L";
6905           break;
6906         case CPP_CHAR16:
6907           prefix = "u";
6908           break;
6909         case CPP_CHAR32:
6910           prefix = "U";
6911           break;
6912         }
6913
6914       if (val <= UCHAR_MAX && ISGRAPH (val))
6915         message = catenate_messages (gmsgid, " before %s'%c'");
6916       else
6917         message = catenate_messages (gmsgid, " before %s'\\x%x'");
6918
6919       error (message, prefix, val);
6920       free (message);
6921       message = NULL;
6922     }
6923   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
6924            || token == CPP_STRING32)
6925     message = catenate_messages (gmsgid, " before string constant");
6926   else if (token == CPP_NUMBER)
6927     message = catenate_messages (gmsgid, " before numeric constant");
6928   else if (token == CPP_NAME)
6929     {
6930       message = catenate_messages (gmsgid, " before %qE");
6931       error (message, value);
6932       free (message);
6933       message = NULL;
6934     }
6935   else if (token == CPP_PRAGMA)
6936     message = catenate_messages (gmsgid, " before %<#pragma%>");
6937   else if (token == CPP_PRAGMA_EOL)
6938     message = catenate_messages (gmsgid, " before end of line");
6939   else if (token < N_TTYPES)
6940     {
6941       message = catenate_messages (gmsgid, " before %qs token");
6942       error (message, cpp_type2name (token));
6943       free (message);
6944       message = NULL;
6945     }
6946   else
6947     error (gmsgid);
6948
6949   if (message)
6950     {
6951       error (message);
6952       free (message);
6953     }
6954 #undef catenate_messages
6955 }
6956
6957 /* Walk a gimplified function and warn for functions whose return value is
6958    ignored and attribute((warn_unused_result)) is set.  This is done before
6959    inlining, so we don't have to worry about that.  */
6960
6961 void
6962 c_warn_unused_result (tree *top_p)
6963 {
6964   tree t = *top_p;
6965   tree_stmt_iterator i;
6966   tree fdecl, ftype;
6967
6968   switch (TREE_CODE (t))
6969     {
6970     case STATEMENT_LIST:
6971       for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6972         c_warn_unused_result (tsi_stmt_ptr (i));
6973       break;
6974
6975     case COND_EXPR:
6976       c_warn_unused_result (&COND_EXPR_THEN (t));
6977       c_warn_unused_result (&COND_EXPR_ELSE (t));
6978       break;
6979     case BIND_EXPR:
6980       c_warn_unused_result (&BIND_EXPR_BODY (t));
6981       break;
6982     case TRY_FINALLY_EXPR:
6983     case TRY_CATCH_EXPR:
6984       c_warn_unused_result (&TREE_OPERAND (t, 0));
6985       c_warn_unused_result (&TREE_OPERAND (t, 1));
6986       break;
6987     case CATCH_EXPR:
6988       c_warn_unused_result (&CATCH_BODY (t));
6989       break;
6990     case EH_FILTER_EXPR:
6991       c_warn_unused_result (&EH_FILTER_FAILURE (t));
6992       break;
6993
6994     case CALL_EXPR:
6995       if (TREE_USED (t))
6996         break;
6997
6998       /* This is a naked call, as opposed to a CALL_EXPR nested inside
6999          a MODIFY_EXPR.  All calls whose value is ignored should be
7000          represented like this.  Look for the attribute.  */
7001       fdecl = get_callee_fndecl (t);
7002       if (fdecl)
7003         ftype = TREE_TYPE (fdecl);
7004       else
7005         {
7006           ftype = TREE_TYPE (CALL_EXPR_FN (t));
7007           /* Look past pointer-to-function to the function type itself.  */
7008           ftype = TREE_TYPE (ftype);
7009         }
7010
7011       if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7012         {
7013           if (fdecl)
7014             warning (0, "%Hignoring return value of %qD, "
7015                      "declared with attribute warn_unused_result",
7016                      EXPR_LOCUS (t), fdecl);
7017           else
7018             warning (0, "%Hignoring return value of function "
7019                      "declared with attribute warn_unused_result",
7020                      EXPR_LOCUS (t));
7021         }
7022       break;
7023
7024     default:
7025       /* Not a container, not a call, or a call whose value is used.  */
7026       break;
7027     }
7028 }
7029
7030 /* Convert a character from the host to the target execution character
7031    set.  cpplib handles this, mostly.  */
7032
7033 HOST_WIDE_INT
7034 c_common_to_target_charset (HOST_WIDE_INT c)
7035 {
7036   /* Character constants in GCC proper are sign-extended under -fsigned-char,
7037      zero-extended under -fno-signed-char.  cpplib insists that characters
7038      and character constants are always unsigned.  Hence we must convert
7039      back and forth.  */
7040   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7041
7042   uc = cpp_host_to_exec_charset (parse_in, uc);
7043
7044   if (flag_signed_char)
7045     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7046                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7047   else
7048     return uc;
7049 }
7050
7051 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
7052    component references, with STOP_REF, or alternatively an INDIRECT_REF of
7053    NULL, at the bottom; much like the traditional rendering of offsetof as a
7054    macro.  Returns the folded and properly cast result.  */
7055
7056 static tree
7057 fold_offsetof_1 (tree expr, tree stop_ref)
7058 {
7059   enum tree_code code = PLUS_EXPR;
7060   tree base, off, t;
7061
7062   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7063     return size_zero_node;
7064
7065   switch (TREE_CODE (expr))
7066     {
7067     case ERROR_MARK:
7068       return expr;
7069
7070     case VAR_DECL:
7071       error ("cannot apply %<offsetof%> to static data member %qD", expr);
7072       return error_mark_node;
7073
7074     case CALL_EXPR:
7075       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7076       return error_mark_node;
7077
7078     case INTEGER_CST:
7079       gcc_assert (integer_zerop (expr));
7080       return size_zero_node;
7081
7082     case NOP_EXPR:
7083     case INDIRECT_REF:
7084       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7085       gcc_assert (base == error_mark_node || base == size_zero_node);
7086       return base;
7087
7088     case COMPONENT_REF:
7089       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7090       if (base == error_mark_node)
7091         return base;
7092
7093       t = TREE_OPERAND (expr, 1);
7094       if (DECL_C_BIT_FIELD (t))
7095         {
7096           error ("attempt to take address of bit-field structure "
7097                  "member %qD", t);
7098           return error_mark_node;
7099         }
7100       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7101                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7102                                   / BITS_PER_UNIT));
7103       break;
7104
7105     case ARRAY_REF:
7106       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7107       if (base == error_mark_node)
7108         return base;
7109
7110       t = TREE_OPERAND (expr, 1);
7111       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7112         {
7113           code = MINUS_EXPR;
7114           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7115         }
7116       t = convert (sizetype, t);
7117       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7118       break;
7119
7120     case COMPOUND_EXPR:
7121       /* Handle static members of volatile structs.  */
7122       t = TREE_OPERAND (expr, 1);
7123       gcc_assert (TREE_CODE (t) == VAR_DECL);
7124       return fold_offsetof_1 (t, stop_ref);
7125
7126     default:
7127       gcc_unreachable ();
7128     }
7129
7130   return size_binop (code, base, off);
7131 }
7132
7133 tree
7134 fold_offsetof (tree expr, tree stop_ref)
7135 {
7136   /* Convert back from the internal sizetype to size_t.  */
7137   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7138 }
7139
7140 /* Print an error message for an invalid lvalue.  USE says
7141    how the lvalue is being used and so selects the error message.  */
7142
7143 void
7144 lvalue_error (enum lvalue_use use)
7145 {
7146   switch (use)
7147     {
7148     case lv_assign:
7149       error ("lvalue required as left operand of assignment");
7150       break;
7151     case lv_increment:
7152       error ("lvalue required as increment operand");
7153       break;
7154     case lv_decrement:
7155       error ("lvalue required as decrement operand");
7156       break;
7157     case lv_addressof:
7158       error ("lvalue required as unary %<&%> operand");
7159       break;
7160     case lv_asm:
7161       error ("lvalue required in asm statement");
7162       break;
7163     default:
7164       gcc_unreachable ();
7165     }
7166 }
7167 \f
7168 /* *PTYPE is an incomplete array.  Complete it with a domain based on
7169    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7170    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7171    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
7172
7173 int
7174 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7175 {
7176   tree maxindex, type, main_type, elt, unqual_elt;
7177   int failure = 0, quals;
7178   hashval_t hashcode = 0;
7179
7180   maxindex = size_zero_node;
7181   if (initial_value)
7182     {
7183       if (TREE_CODE (initial_value) == STRING_CST)
7184         {
7185           int eltsize
7186             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7187           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7188         }
7189       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7190         {
7191           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7192
7193           if (VEC_empty (constructor_elt, v))
7194             {
7195               if (pedantic)
7196                 failure = 3;
7197               maxindex = integer_minus_one_node;
7198             }
7199           else
7200             {
7201               tree curindex;
7202               unsigned HOST_WIDE_INT cnt;
7203               constructor_elt *ce;
7204
7205               if (VEC_index (constructor_elt, v, 0)->index)
7206                 maxindex = fold_convert (sizetype,
7207                                          VEC_index (constructor_elt,
7208                                                     v, 0)->index);
7209               curindex = maxindex;
7210
7211               for (cnt = 1;
7212                    VEC_iterate (constructor_elt, v, cnt, ce);
7213                    cnt++)
7214                 {
7215                   if (ce->index)
7216                     curindex = fold_convert (sizetype, ce->index);
7217                   else
7218                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7219
7220                   if (tree_int_cst_lt (maxindex, curindex))
7221                     maxindex = curindex;
7222                 }
7223             }
7224         }
7225       else
7226         {
7227           /* Make an error message unless that happened already.  */
7228           if (initial_value != error_mark_node)
7229             failure = 1;
7230         }
7231     }
7232   else
7233     {
7234       failure = 2;
7235       if (!do_default)
7236         return failure;
7237     }
7238
7239   type = *ptype;
7240   elt = TREE_TYPE (type);
7241   quals = TYPE_QUALS (strip_array_types (elt));
7242   if (quals == 0)
7243     unqual_elt = elt;
7244   else
7245     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7246
7247   /* Using build_distinct_type_copy and modifying things afterward instead
7248      of using build_array_type to create a new type preserves all of the
7249      TYPE_LANG_FLAG_? bits that the front end may have set.  */
7250   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7251   TREE_TYPE (main_type) = unqual_elt;
7252   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7253   layout_type (main_type);
7254
7255   /* Make sure we have the canonical MAIN_TYPE. */
7256   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7257   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7258                                     hashcode);
7259   main_type = type_hash_canon (hashcode, main_type);
7260
7261   /* Fix the canonical type.  */
7262   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7263       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7264     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7265   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7266            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7267                != TYPE_DOMAIN (main_type)))
7268     TYPE_CANONICAL (main_type)
7269       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7270                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7271   else
7272     TYPE_CANONICAL (main_type) = main_type;
7273
7274   if (quals == 0)
7275     type = main_type;
7276   else
7277     type = c_build_qualified_type (main_type, quals);
7278
7279   if (COMPLETE_TYPE_P (type)
7280       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7281       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7282     {
7283       error ("size of array is too large");
7284       /* If we proceed with the array type as it is, we'll eventually
7285          crash in tree_low_cst().  */
7286       type = error_mark_node;
7287     }
7288
7289   *ptype = type;
7290   return failure;
7291 }
7292
7293 \f
7294 /* Used to help initialize the builtin-types.def table.  When a type of
7295    the correct size doesn't exist, use error_mark_node instead of NULL.
7296    The later results in segfaults even when a decl using the type doesn't
7297    get invoked.  */
7298
7299 tree
7300 builtin_type_for_size (int size, bool unsignedp)
7301 {
7302   tree type = lang_hooks.types.type_for_size (size, unsignedp);
7303   return type ? type : error_mark_node;
7304 }
7305
7306 /* A helper function for resolve_overloaded_builtin in resolving the
7307    overloaded __sync_ builtins.  Returns a positive power of 2 if the
7308    first operand of PARAMS is a pointer to a supported data type.
7309    Returns 0 if an error is encountered.  */
7310
7311 static int
7312 sync_resolve_size (tree function, tree params)
7313 {
7314   tree type;
7315   int size;
7316
7317   if (params == NULL)
7318     {
7319       error ("too few arguments to function %qE", function);
7320       return 0;
7321     }
7322
7323   type = TREE_TYPE (TREE_VALUE (params));
7324   if (TREE_CODE (type) != POINTER_TYPE)
7325     goto incompatible;
7326
7327   type = TREE_TYPE (type);
7328   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7329     goto incompatible;
7330
7331   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7332   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7333     return size;
7334
7335  incompatible:
7336   error ("incompatible type for argument %d of %qE", 1, function);
7337   return 0;
7338 }
7339
7340 /* A helper function for resolve_overloaded_builtin.  Adds casts to
7341    PARAMS to make arguments match up with those of FUNCTION.  Drops
7342    the variadic arguments at the end.  Returns false if some error
7343    was encountered; true on success.  */
7344
7345 static bool
7346 sync_resolve_params (tree orig_function, tree function, tree params)
7347 {
7348   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7349   tree ptype;
7350   int number;
7351
7352   /* We've declared the implementation functions to use "volatile void *"
7353      as the pointer parameter, so we shouldn't get any complaints from the
7354      call to check_function_arguments what ever type the user used.  */
7355   arg_types = TREE_CHAIN (arg_types);
7356   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7357   number = 2;
7358
7359   /* For the rest of the values, we need to cast these to FTYPE, so that we
7360      don't get warnings for passing pointer types, etc.  */
7361   while (arg_types != void_list_node)
7362     {
7363       tree val;
7364
7365       params = TREE_CHAIN (params);
7366       if (params == NULL)
7367         {
7368           error ("too few arguments to function %qE", orig_function);
7369           return false;
7370         }
7371
7372       /* ??? Ideally for the first conversion we'd use convert_for_assignment
7373          so that we get warnings for anything that doesn't match the pointer
7374          type.  This isn't portable across the C and C++ front ends atm.  */
7375       val = TREE_VALUE (params);
7376       val = convert (ptype, val);
7377       val = convert (TREE_VALUE (arg_types), val);
7378       TREE_VALUE (params) = val;
7379
7380       arg_types = TREE_CHAIN (arg_types);
7381       number++;
7382     }
7383
7384   /* The definition of these primitives is variadic, with the remaining
7385      being "an optional list of variables protected by the memory barrier".
7386      No clue what that's supposed to mean, precisely, but we consider all
7387      call-clobbered variables to be protected so we're safe.  */
7388   TREE_CHAIN (params) = NULL;
7389
7390   return true;
7391 }
7392
7393 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
7394    RESULT to make it match the type of the first pointer argument in
7395    PARAMS.  */
7396
7397 static tree
7398 sync_resolve_return (tree params, tree result)
7399 {
7400   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7401   ptype = TYPE_MAIN_VARIANT (ptype);
7402   return convert (ptype, result);
7403 }
7404
7405 /* Some builtin functions are placeholders for other expressions.  This
7406    function should be called immediately after parsing the call expression
7407    before surrounding code has committed to the type of the expression.
7408
7409    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7410    PARAMS is the argument list for the call.  The return value is non-null
7411    when expansion is complete, and null if normal processing should
7412    continue.  */
7413
7414 tree
7415 resolve_overloaded_builtin (tree function, tree params)
7416 {
7417   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7418   switch (DECL_BUILT_IN_CLASS (function))
7419     {
7420     case BUILT_IN_NORMAL:
7421       break;
7422     case BUILT_IN_MD:
7423       if (targetm.resolve_overloaded_builtin)
7424         return targetm.resolve_overloaded_builtin (function, params);
7425       else
7426         return NULL_TREE;
7427     default:
7428       return NULL_TREE;
7429     }
7430
7431   /* Handle BUILT_IN_NORMAL here.  */
7432   switch (orig_code)
7433     {
7434     case BUILT_IN_FETCH_AND_ADD_N:
7435     case BUILT_IN_FETCH_AND_SUB_N:
7436     case BUILT_IN_FETCH_AND_OR_N:
7437     case BUILT_IN_FETCH_AND_AND_N:
7438     case BUILT_IN_FETCH_AND_XOR_N:
7439     case BUILT_IN_FETCH_AND_NAND_N:
7440     case BUILT_IN_ADD_AND_FETCH_N:
7441     case BUILT_IN_SUB_AND_FETCH_N:
7442     case BUILT_IN_OR_AND_FETCH_N:
7443     case BUILT_IN_AND_AND_FETCH_N:
7444     case BUILT_IN_XOR_AND_FETCH_N:
7445     case BUILT_IN_NAND_AND_FETCH_N:
7446     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
7447     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
7448     case BUILT_IN_LOCK_TEST_AND_SET_N:
7449     case BUILT_IN_LOCK_RELEASE_N:
7450       {
7451         int n = sync_resolve_size (function, params);
7452         tree new_function, result;
7453
7454         if (n == 0)
7455           return error_mark_node;
7456
7457         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
7458         if (!sync_resolve_params (function, new_function, params))
7459           return error_mark_node;
7460
7461         result = build_function_call (new_function, params);
7462         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
7463             && orig_code != BUILT_IN_LOCK_RELEASE_N)
7464           result = sync_resolve_return (params, result);
7465
7466         return result;
7467       }
7468
7469     default:
7470       return NULL_TREE;
7471     }
7472 }
7473
7474 /* Ignoring their sign, return true if two scalar types are the same.  */
7475 bool
7476 same_scalar_type_ignoring_signedness (tree t1, tree t2)
7477 {
7478   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
7479
7480   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
7481               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
7482                   || c2 == FIXED_POINT_TYPE));
7483
7484   /* Equality works here because c_common_signed_type uses
7485      TYPE_MAIN_VARIANT.  */
7486   return c_common_signed_type (t1)
7487     == c_common_signed_type (t2);
7488 }
7489
7490 /* Check for missing format attributes on function pointers.  LTYPE is
7491    the new type or left-hand side type.  RTYPE is the old type or
7492    right-hand side type.  Returns TRUE if LTYPE is missing the desired
7493    attribute.  */
7494
7495 bool
7496 check_missing_format_attribute (tree ltype, tree rtype)
7497 {
7498   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
7499   tree ra;
7500
7501   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
7502     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
7503       break;
7504   if (ra)
7505     {
7506       tree la;
7507       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
7508         if (is_attribute_p ("format", TREE_PURPOSE (la)))
7509           break;
7510       return !la;
7511     }
7512   else
7513     return false;
7514 }
7515
7516 /* Subscripting with type char is likely to lose on a machine where
7517    chars are signed.  So warn on any machine, but optionally.  Don't
7518    warn for unsigned char since that type is safe.  Don't warn for
7519    signed char because anyone who uses that must have done so
7520    deliberately. Furthermore, we reduce the false positive load by
7521    warning only for non-constant value of type char.  */
7522
7523 void
7524 warn_array_subscript_with_type_char (tree index)
7525 {
7526   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
7527       && TREE_CODE (index) != INTEGER_CST)
7528     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
7529 }
7530
7531 /* Implement -Wparentheses for the unexpected C precedence rules, to
7532    cover cases like x + y << z which readers are likely to
7533    misinterpret.  We have seen an expression in which CODE is a binary
7534    operator used to combine expressions headed by CODE_LEFT and
7535    CODE_RIGHT.  CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
7536    means that that side of the expression was not formed using a
7537    binary operator, or it was enclosed in parentheses.  */
7538
7539 void
7540 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
7541                         enum tree_code code_right)
7542 {
7543   if (!warn_parentheses)
7544     return;
7545
7546   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
7547     {
7548       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7549           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7550         warning (OPT_Wparentheses,
7551                  "suggest parentheses around + or - inside shift");
7552     }
7553
7554   if (code == TRUTH_ORIF_EXPR)
7555     {
7556       if (code_left == TRUTH_ANDIF_EXPR
7557           || code_right == TRUTH_ANDIF_EXPR)
7558         warning (OPT_Wparentheses,
7559                  "suggest parentheses around && within ||");
7560     }
7561
7562   if (code == BIT_IOR_EXPR)
7563     {
7564       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
7565           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7566           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
7567           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7568         warning (OPT_Wparentheses,
7569                  "suggest parentheses around arithmetic in operand of |");
7570       /* Check cases like x|y==z */
7571       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7572           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7573         warning (OPT_Wparentheses,
7574                  "suggest parentheses around comparison in operand of |");
7575     }
7576
7577   if (code == BIT_XOR_EXPR)
7578     {
7579       if (code_left == BIT_AND_EXPR
7580           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7581           || code_right == BIT_AND_EXPR
7582           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7583         warning (OPT_Wparentheses,
7584                  "suggest parentheses around arithmetic in operand of ^");
7585       /* Check cases like x^y==z */
7586       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7587           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7588         warning (OPT_Wparentheses,
7589                  "suggest parentheses around comparison in operand of ^");
7590     }
7591
7592   if (code == BIT_AND_EXPR)
7593     {
7594       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7595           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7596         warning (OPT_Wparentheses,
7597                  "suggest parentheses around + or - in operand of &");
7598       /* Check cases like x&y==z */
7599       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7600           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7601         warning (OPT_Wparentheses,
7602                  "suggest parentheses around comparison in operand of &");
7603     }
7604
7605   if (code == EQ_EXPR || code == NE_EXPR)
7606     {
7607       if (TREE_CODE_CLASS (code_left) == tcc_comparison
7608           || TREE_CODE_CLASS (code_right) == tcc_comparison)
7609         warning (OPT_Wparentheses,
7610                  "suggest parentheses around comparison in operand of %s",
7611                  code == EQ_EXPR ? "==" : "!=");
7612     }
7613   else if (TREE_CODE_CLASS (code) == tcc_comparison)
7614     {
7615       if ((TREE_CODE_CLASS (code_left) == tcc_comparison
7616            && code_left != NE_EXPR && code_left != EQ_EXPR)
7617           || (TREE_CODE_CLASS (code_right) == tcc_comparison
7618               && code_right != NE_EXPR && code_right != EQ_EXPR))
7619         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
7620                  "have their mathematical meaning");
7621     }
7622 }
7623
7624 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
7625
7626 void
7627 warn_for_unused_label (tree label)
7628 {
7629   if (!TREE_USED (label))
7630     {
7631       if (DECL_INITIAL (label))
7632         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
7633       else
7634         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
7635     }
7636 }
7637
7638 #ifndef TARGET_HAS_TARGETCM
7639 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
7640 #endif
7641
7642 /* Warn for division by zero according to the value of DIVISOR.  */
7643
7644 void
7645 warn_for_div_by_zero (tree divisor)
7646 {
7647   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
7648      about division by zero.  Do not issue a warning if DIVISOR has a
7649      floating-point type, since we consider 0.0/0.0 a valid way of
7650      generating a NaN.  */
7651   if (skip_evaluation == 0
7652       && (integer_zerop (divisor) || fixed_zerop (divisor)))
7653     warning (OPT_Wdiv_by_zero, "division by zero");
7654 }
7655
7656 #include "gt-c-common.h"