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