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