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