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 (location_t location, enum tree_code resultcode,
3771                  tree ptrop, tree intop)
3772 {
3773   tree size_exp, ret;
3774
3775   /* The result is a pointer of the same type that is being added.  */
3776   tree result_type = TREE_TYPE (ptrop);
3777
3778   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3779     {
3780       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3781                "pointer of type %<void *%> used in arithmetic");
3782       size_exp = integer_one_node;
3783     }
3784   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3785     {
3786       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3787                "pointer to a function used in arithmetic");
3788       size_exp = integer_one_node;
3789     }
3790   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3791     {
3792       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3793                "pointer to member function used in arithmetic");
3794       size_exp = integer_one_node;
3795     }
3796   else
3797     size_exp = size_in_bytes (TREE_TYPE (result_type));
3798
3799   /* We are manipulating pointer values, so we don't need to warn
3800      about relying on undefined signed overflow.  We disable the
3801      warning here because we use integer types so fold won't know that
3802      they are really pointers.  */
3803   fold_defer_overflow_warnings ();
3804
3805   /* If what we are about to multiply by the size of the elements
3806      contains a constant term, apply distributive law
3807      and multiply that constant term separately.
3808      This helps produce common subexpressions.  */
3809   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3810       && !TREE_CONSTANT (intop)
3811       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3812       && TREE_CONSTANT (size_exp)
3813       /* If the constant comes from pointer subtraction,
3814          skip this optimization--it would cause an error.  */
3815       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3816       /* If the constant is unsigned, and smaller than the pointer size,
3817          then we must skip this optimization.  This is because it could cause
3818          an overflow error if the constant is negative but INTOP is not.  */
3819       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3820           || (TYPE_PRECISION (TREE_TYPE (intop))
3821               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3822     {
3823       enum tree_code subcode = resultcode;
3824       tree int_type = TREE_TYPE (intop);
3825       if (TREE_CODE (intop) == MINUS_EXPR)
3826         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3827       /* Convert both subexpression types to the type of intop,
3828          because weird cases involving pointer arithmetic
3829          can result in a sum or difference with different type args.  */
3830       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3831                                subcode, ptrop,
3832                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3833       intop = convert (int_type, TREE_OPERAND (intop, 0));
3834     }
3835
3836   /* Convert the integer argument to a type the same size as sizetype
3837      so the multiply won't overflow spuriously.  */
3838   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3839       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3840     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3841                                              TYPE_UNSIGNED (sizetype)), intop);
3842
3843   /* Replace the integer argument with a suitable product by the object size.
3844      Do this multiplication as signed, then convert to the appropriate
3845      type for the pointer operation.  */
3846   intop = convert (sizetype,
3847                    build_binary_op (EXPR_LOCATION (intop),
3848                                     MULT_EXPR, intop,
3849                                     convert (TREE_TYPE (intop), size_exp), 1));
3850
3851   /* Create the sum or difference.  */
3852   if (resultcode == MINUS_EXPR)
3853     intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3854
3855   if (TREE_CODE (intop) == INTEGER_CST)
3856     {
3857       tree offset_node;
3858       tree string_cst = string_constant (ptrop, &offset_node);
3859
3860       if (string_cst != 0
3861           && !(offset_node && TREE_CODE (offset_node) != INTEGER_CST))
3862         {
3863           HOST_WIDE_INT max = TREE_STRING_LENGTH (string_cst);
3864           HOST_WIDE_INT offset;
3865           if (offset_node == 0)
3866             offset = 0;
3867           else if (! host_integerp (offset_node, 0))
3868             offset = -1;
3869           else
3870             offset = tree_low_cst (offset_node, 0);
3871
3872           offset = offset + tree_low_cst (intop, 0);
3873           if (offset < 0 || offset > max)
3874             warning_at (location, 0,
3875                         "offset %<%wd%> outside bounds of constant string",
3876                         tree_low_cst (intop, 0));
3877         }
3878     }
3879
3880   ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3881
3882   fold_undefer_and_ignore_overflow_warnings ();
3883
3884   return ret;
3885 }
3886 \f
3887 /* Wrap a SAVE_EXPR around EXPR, if appropriate.  Like save_expr, but
3888    for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3889    around the SAVE_EXPR if needed so that c_fully_fold does not need
3890    to look inside SAVE_EXPRs.  */
3891
3892 tree
3893 c_save_expr (tree expr)
3894 {
3895   bool maybe_const = true;
3896   if (c_dialect_cxx ())
3897     return save_expr (expr);
3898   expr = c_fully_fold (expr, false, &maybe_const);
3899   expr = save_expr (expr);
3900   if (!maybe_const)
3901     {
3902       expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3903       C_MAYBE_CONST_EXPR_NON_CONST (expr) = 1;
3904     }
3905   return expr;
3906 }
3907
3908 /* Return whether EXPR is a declaration whose address can never be
3909    NULL.  */
3910
3911 bool
3912 decl_with_nonnull_addr_p (const_tree expr)
3913 {
3914   return (DECL_P (expr)
3915           && (TREE_CODE (expr) == PARM_DECL
3916               || TREE_CODE (expr) == LABEL_DECL
3917               || !DECL_WEAK (expr)));
3918 }
3919
3920 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3921    or for an `if' or `while' statement or ?..: exp.  It should already
3922    have been validated to be of suitable type; otherwise, a bad
3923    diagnostic may result.
3924
3925    The EXPR is located at LOCATION.
3926
3927    This preparation consists of taking the ordinary
3928    representation of an expression expr and producing a valid tree
3929    boolean expression describing whether expr is nonzero.  We could
3930    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3931    but we optimize comparisons, &&, ||, and !.
3932
3933    The resulting type should always be `truthvalue_type_node'.  */
3934
3935 tree
3936 c_common_truthvalue_conversion (location_t location, tree expr)
3937 {
3938   switch (TREE_CODE (expr))
3939     {
3940     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3941     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3942     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3943     case ORDERED_EXPR: case UNORDERED_EXPR:
3944       if (TREE_TYPE (expr) == truthvalue_type_node)
3945         return expr;
3946       return build2 (TREE_CODE (expr), truthvalue_type_node,
3947                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3948
3949     case TRUTH_ANDIF_EXPR:
3950     case TRUTH_ORIF_EXPR:
3951     case TRUTH_AND_EXPR:
3952     case TRUTH_OR_EXPR:
3953     case TRUTH_XOR_EXPR:
3954       if (TREE_TYPE (expr) == truthvalue_type_node)
3955         return expr;
3956       return build2 (TREE_CODE (expr), truthvalue_type_node,
3957                  c_common_truthvalue_conversion (location,
3958                                                  TREE_OPERAND (expr, 0)),
3959                  c_common_truthvalue_conversion (location,
3960                                                  TREE_OPERAND (expr, 1)));
3961
3962     case TRUTH_NOT_EXPR:
3963       if (TREE_TYPE (expr) == truthvalue_type_node)
3964         return expr;
3965       return build1 (TREE_CODE (expr), truthvalue_type_node,
3966                  c_common_truthvalue_conversion (location,
3967                                                  TREE_OPERAND (expr, 0)));
3968
3969     case ERROR_MARK:
3970       return expr;
3971
3972     case INTEGER_CST:
3973       return integer_zerop (expr) ? truthvalue_false_node
3974                                   : truthvalue_true_node;
3975
3976     case REAL_CST:
3977       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3978              ? truthvalue_true_node
3979              : truthvalue_false_node;
3980
3981     case FIXED_CST:
3982       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3983                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3984              ? truthvalue_true_node
3985              : truthvalue_false_node;
3986
3987     case FUNCTION_DECL:
3988       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3989       /* Fall through.  */
3990
3991     case ADDR_EXPR:
3992       {
3993         tree inner = TREE_OPERAND (expr, 0);
3994         if (decl_with_nonnull_addr_p (inner))
3995           {
3996             /* Common Ada/Pascal programmer's mistake.  */
3997             warning_at (location,
3998                         OPT_Waddress,
3999                         "the address of %qD will always evaluate as %<true%>",
4000                         inner);
4001             return truthvalue_true_node;
4002           }
4003
4004         /* If we still have a decl, it is possible for its address to
4005            be NULL, so we cannot optimize.  */
4006         if (DECL_P (inner))
4007           {
4008             gcc_assert (DECL_WEAK (inner));
4009             break;
4010           }
4011
4012         if (TREE_SIDE_EFFECTS (inner))
4013           return build2 (COMPOUND_EXPR, truthvalue_type_node,
4014                          inner, truthvalue_true_node);
4015         else
4016           return truthvalue_true_node;
4017       }
4018
4019     case COMPLEX_EXPR:
4020       return build_binary_op (EXPR_LOCATION (expr),
4021                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4022                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4023                 c_common_truthvalue_conversion (location,
4024                                                 TREE_OPERAND (expr, 0)),
4025                 c_common_truthvalue_conversion (location,
4026                                                 TREE_OPERAND (expr, 1)),
4027                               0);
4028
4029     case NEGATE_EXPR:
4030     case ABS_EXPR:
4031     case FLOAT_EXPR:
4032     case EXCESS_PRECISION_EXPR:
4033       /* These don't change whether an object is nonzero or zero.  */
4034       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4035
4036     case LROTATE_EXPR:
4037     case RROTATE_EXPR:
4038       /* These don't change whether an object is zero or nonzero, but
4039          we can't ignore them if their second arg has side-effects.  */
4040       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4041         return build2 (COMPOUND_EXPR, truthvalue_type_node,
4042                        TREE_OPERAND (expr, 1),
4043                        c_common_truthvalue_conversion
4044                         (location, TREE_OPERAND (expr, 0)));
4045       else
4046         return c_common_truthvalue_conversion (location,
4047                                                TREE_OPERAND (expr, 0));
4048
4049     case COND_EXPR:
4050       /* Distribute the conversion into the arms of a COND_EXPR.  */
4051       if (c_dialect_cxx ())
4052         return fold_build3 (COND_EXPR, truthvalue_type_node,
4053                             TREE_OPERAND (expr, 0),
4054                             c_common_truthvalue_conversion (location,
4055                                                             TREE_OPERAND (expr,
4056                                                                           1)),
4057                             c_common_truthvalue_conversion (location,
4058                                                             TREE_OPERAND (expr,
4059                                                                           2)));
4060       else
4061         /* Folding will happen later for C.  */
4062         return build3 (COND_EXPR, truthvalue_type_node,
4063                        TREE_OPERAND (expr, 0),
4064                        c_common_truthvalue_conversion (location,
4065                                                        TREE_OPERAND (expr, 1)),
4066                        c_common_truthvalue_conversion (location,
4067                                                        TREE_OPERAND (expr, 2)));
4068
4069     CASE_CONVERT:
4070       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4071          since that affects how `default_conversion' will behave.  */
4072       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4073           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4074         break;
4075       /* If this is widening the argument, we can ignore it.  */
4076       if (TYPE_PRECISION (TREE_TYPE (expr))
4077           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4078         return c_common_truthvalue_conversion (location,
4079                                                TREE_OPERAND (expr, 0));
4080       break;
4081
4082     case MODIFY_EXPR:
4083       if (!TREE_NO_WARNING (expr)
4084           && warn_parentheses)
4085         {
4086           warning (OPT_Wparentheses,
4087                    "suggest parentheses around assignment used as truth value");
4088           TREE_NO_WARNING (expr) = 1;
4089         }
4090       break;
4091
4092     default:
4093       break;
4094     }
4095
4096   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4097     {
4098       tree t = c_save_expr (expr);
4099       return (build_binary_op
4100               (EXPR_LOCATION (expr),
4101                (TREE_SIDE_EFFECTS (expr)
4102                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4103         c_common_truthvalue_conversion
4104                (location,
4105                 build_unary_op (location, REALPART_EXPR, t, 0)),
4106         c_common_truthvalue_conversion
4107                (location,
4108                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4109                0));
4110     }
4111
4112   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4113     {
4114       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4115                                           FCONST0 (TYPE_MODE
4116                                                    (TREE_TYPE (expr))));
4117       return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
4118     }
4119
4120   return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
4121 }
4122 \f
4123 static void def_builtin_1  (enum built_in_function fncode,
4124                             const char *name,
4125                             enum built_in_class fnclass,
4126                             tree fntype, tree libtype,
4127                             bool both_p, bool fallback_p, bool nonansi_p,
4128                             tree fnattrs, bool implicit_p);
4129
4130
4131 /* Apply the TYPE_QUALS to the new DECL.  */
4132
4133 void
4134 c_apply_type_quals_to_decl (int type_quals, tree decl)
4135 {
4136   tree type = TREE_TYPE (decl);
4137
4138   if (type == error_mark_node)
4139     return;
4140
4141   if (((type_quals & TYPE_QUAL_CONST)
4142        || (type && TREE_CODE (type) == REFERENCE_TYPE))
4143       /* An object declared 'const' is only readonly after it is
4144          initialized.  We don't have any way of expressing this currently,
4145          so we need to be conservative and unset TREE_READONLY for types
4146          with constructors.  Otherwise aliasing code will ignore stores in
4147          an inline constructor.  */
4148       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4149     TREE_READONLY (decl) = 1;
4150   if (type_quals & TYPE_QUAL_VOLATILE)
4151     {
4152       TREE_SIDE_EFFECTS (decl) = 1;
4153       TREE_THIS_VOLATILE (decl) = 1;
4154     }
4155   if (type_quals & TYPE_QUAL_RESTRICT)
4156     {
4157       while (type && TREE_CODE (type) == ARRAY_TYPE)
4158         /* Allow 'restrict' on arrays of pointers.
4159            FIXME currently we just ignore it.  */
4160         type = TREE_TYPE (type);
4161       if (!type
4162           || !POINTER_TYPE_P (type)
4163           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4164         error ("invalid use of %<restrict%>");
4165       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
4166         /* Indicate we need to make a unique alias set for this pointer.
4167            We can't do it here because it might be pointing to an
4168            incomplete type.  */
4169         DECL_POINTER_ALIAS_SET (decl) = -2;
4170     }
4171 }
4172
4173 /* Hash function for the problem of multiple type definitions in
4174    different files.  This must hash all types that will compare
4175    equal via comptypes to the same value.  In practice it hashes
4176    on some of the simple stuff and leaves the details to comptypes.  */
4177
4178 static hashval_t
4179 c_type_hash (const void *p)
4180 {
4181   int i = 0;
4182   int shift, size;
4183   const_tree const t = (const_tree) p;
4184   tree t2;
4185   switch (TREE_CODE (t))
4186     {
4187     /* For pointers, hash on pointee type plus some swizzling.  */
4188     case POINTER_TYPE:
4189       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4190     /* Hash on number of elements and total size.  */
4191     case ENUMERAL_TYPE:
4192       shift = 3;
4193       t2 = TYPE_VALUES (t);
4194       break;
4195     case RECORD_TYPE:
4196       shift = 0;
4197       t2 = TYPE_FIELDS (t);
4198       break;
4199     case QUAL_UNION_TYPE:
4200       shift = 1;
4201       t2 = TYPE_FIELDS (t);
4202       break;
4203     case UNION_TYPE:
4204       shift = 2;
4205       t2 = TYPE_FIELDS (t);
4206       break;
4207     default:
4208       gcc_unreachable ();
4209     }
4210   for (; t2; t2 = TREE_CHAIN (t2))
4211     i++;
4212   /* We might have a VLA here.  */
4213   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4214     size = 0;
4215   else
4216     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4217   return ((size << 24) | (i << shift));
4218 }
4219
4220 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4221
4222 /* Return the typed-based alias set for T, which may be an expression
4223    or a type.  Return -1 if we don't do anything special.  */
4224
4225 alias_set_type
4226 c_common_get_alias_set (tree t)
4227 {
4228   tree u;
4229   PTR *slot;
4230
4231   /* Permit type-punning when accessing a union, provided the access
4232      is directly through the union.  For example, this code does not
4233      permit taking the address of a union member and then storing
4234      through it.  Even the type-punning allowed here is a GCC
4235      extension, albeit a common and useful one; the C standard says
4236      that such accesses have implementation-defined behavior.  */
4237   for (u = t;
4238        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4239        u = TREE_OPERAND (u, 0))
4240     if (TREE_CODE (u) == COMPONENT_REF
4241         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4242       return 0;
4243
4244   /* That's all the expressions we handle specially.  */
4245   if (!TYPE_P (t))
4246     return -1;
4247
4248   /* The C standard guarantees that any object may be accessed via an
4249      lvalue that has character type.  */
4250   if (t == char_type_node
4251       || t == signed_char_type_node
4252       || t == unsigned_char_type_node)
4253     return 0;
4254
4255   /* The C standard specifically allows aliasing between signed and
4256      unsigned variants of the same type.  We treat the signed
4257      variant as canonical.  */
4258   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4259     {
4260       tree t1 = c_common_signed_type (t);
4261
4262       /* t1 == t can happen for boolean nodes which are always unsigned.  */
4263       if (t1 != t)
4264         return get_alias_set (t1);
4265     }
4266   else if (POINTER_TYPE_P (t))
4267     {
4268       tree t1;
4269
4270       /* Unfortunately, there is no canonical form of a pointer type.
4271          In particular, if we have `typedef int I', then `int *', and
4272          `I *' are different types.  So, we have to pick a canonical
4273          representative.  We do this below.
4274
4275          Technically, this approach is actually more conservative that
4276          it needs to be.  In particular, `const int *' and `int *'
4277          should be in different alias sets, according to the C and C++
4278          standard, since their types are not the same, and so,
4279          technically, an `int **' and `const int **' cannot point at
4280          the same thing.
4281
4282          But, the standard is wrong.  In particular, this code is
4283          legal C++:
4284
4285             int *ip;
4286             int **ipp = &ip;
4287             const int* const* cipp = ipp;
4288
4289          And, it doesn't make sense for that to be legal unless you
4290          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
4291          the pointed-to types.  This issue has been reported to the
4292          C++ committee.  */
4293       t1 = build_type_no_quals (t);
4294       if (t1 != t)
4295         return get_alias_set (t1);
4296     }
4297
4298   /* Handle the case of multiple type nodes referring to "the same" type,
4299      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
4300      C90 is handled.  (In C99 type compatibility is not transitive, which
4301      complicates things mightily. The alias set splay trees can theoretically
4302      represent this, but insertion is tricky when you consider all the
4303      different orders things might arrive in.) */
4304
4305   if (c_language != clk_c || flag_isoc99)
4306     return -1;
4307
4308   /* Save time if there's only one input file.  */
4309   if (num_in_fnames == 1)
4310     return -1;
4311
4312   /* Pointers need special handling if they point to any type that
4313      needs special handling (below).  */
4314   if (TREE_CODE (t) == POINTER_TYPE)
4315     {
4316       tree t2;
4317       /* Find bottom type under any nested POINTERs.  */
4318       for (t2 = TREE_TYPE (t);
4319            TREE_CODE (t2) == POINTER_TYPE;
4320            t2 = TREE_TYPE (t2))
4321         ;
4322       if (TREE_CODE (t2) != RECORD_TYPE
4323           && TREE_CODE (t2) != ENUMERAL_TYPE
4324           && TREE_CODE (t2) != QUAL_UNION_TYPE
4325           && TREE_CODE (t2) != UNION_TYPE)
4326         return -1;
4327       if (TYPE_SIZE (t2) == 0)
4328         return -1;
4329     }
4330   /* These are the only cases that need special handling.  */
4331   if (TREE_CODE (t) != RECORD_TYPE
4332       && TREE_CODE (t) != ENUMERAL_TYPE
4333       && TREE_CODE (t) != QUAL_UNION_TYPE
4334       && TREE_CODE (t) != UNION_TYPE
4335       && TREE_CODE (t) != POINTER_TYPE)
4336     return -1;
4337   /* Undefined? */
4338   if (TYPE_SIZE (t) == 0)
4339     return -1;
4340
4341   /* Look up t in hash table.  Only one of the compatible types within each
4342      alias set is recorded in the table.  */
4343   if (!type_hash_table)
4344     type_hash_table = htab_create_ggc (1021, c_type_hash,
4345             (htab_eq) lang_hooks.types_compatible_p,
4346             NULL);
4347   slot = htab_find_slot (type_hash_table, t, INSERT);
4348   if (*slot != NULL)
4349     {
4350       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4351       return TYPE_ALIAS_SET ((tree)*slot);
4352     }
4353   else
4354     /* Our caller will assign and record (in t) a new alias set; all we need
4355        to do is remember t in the hash table.  */
4356     *slot = t;
4357
4358   return -1;
4359 }
4360 \f
4361 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4362    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
4363    flag controls whether we should diagnose possibly ill-formed
4364    constructs or not.  */
4365
4366 tree
4367 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
4368 {
4369   const char *op_name;
4370   tree value = NULL;
4371   enum tree_code type_code = TREE_CODE (type);
4372
4373   op_name = is_sizeof ? "sizeof" : "__alignof__";
4374
4375   if (type_code == FUNCTION_TYPE)
4376     {
4377       if (is_sizeof)
4378         {
4379           if (complain && (pedantic || warn_pointer_arith))
4380             pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4381                      "invalid application of %<sizeof%> to a function type");
4382           else if (!complain)
4383             return error_mark_node;
4384           value = size_one_node;
4385         }
4386       else
4387         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4388     }
4389   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4390     {
4391       if (type_code == VOID_TYPE
4392           && complain && (pedantic || warn_pointer_arith))
4393         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4394                  "invalid application of %qs to a void type", op_name);
4395       else if (!complain)
4396         return error_mark_node;
4397       value = size_one_node;
4398     }
4399   else if (!COMPLETE_TYPE_P (type))
4400     {
4401       if (complain)
4402         error ("invalid application of %qs to incomplete type %qT ",
4403                op_name, type);
4404       value = size_zero_node;
4405     }
4406   else
4407     {
4408       if (is_sizeof)
4409         /* Convert in case a char is more than one unit.  */
4410         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4411                             size_int (TYPE_PRECISION (char_type_node)
4412                                       / BITS_PER_UNIT));
4413       else
4414         value = size_int (TYPE_ALIGN_UNIT (type));
4415     }
4416
4417   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4418      TYPE_IS_SIZETYPE means that certain things (like overflow) will
4419      never happen.  However, this node should really have type
4420      `size_t', which is just a typedef for an ordinary integer type.  */
4421   value = fold_convert (size_type_node, value);
4422   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4423
4424   return value;
4425 }
4426
4427 /* Implement the __alignof keyword: Return the minimum required
4428    alignment of EXPR, measured in bytes.  For VAR_DECLs,
4429    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4430    from an "aligned" __attribute__ specification).  */
4431
4432 tree
4433 c_alignof_expr (tree expr)
4434 {
4435   tree t;
4436
4437   if (VAR_OR_FUNCTION_DECL_P (expr))
4438     t = size_int (DECL_ALIGN_UNIT (expr));
4439
4440   else if (TREE_CODE (expr) == COMPONENT_REF
4441            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4442     {
4443       error ("%<__alignof%> applied to a bit-field");
4444       t = size_one_node;
4445     }
4446   else if (TREE_CODE (expr) == COMPONENT_REF
4447            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4448     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4449
4450   else if (TREE_CODE (expr) == INDIRECT_REF)
4451     {
4452       tree t = TREE_OPERAND (expr, 0);
4453       tree best = t;
4454       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4455
4456       while (CONVERT_EXPR_P (t)
4457              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4458         {
4459           int thisalign;
4460
4461           t = TREE_OPERAND (t, 0);
4462           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4463           if (thisalign > bestalign)
4464             best = t, bestalign = thisalign;
4465         }
4466       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
4467     }
4468   else
4469     return c_alignof (TREE_TYPE (expr));
4470
4471   return fold_convert (size_type_node, t);
4472 }
4473 \f
4474 /* Handle C and C++ default attributes.  */
4475
4476 enum built_in_attribute
4477 {
4478 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4479 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4480 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4481 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4482 #include "builtin-attrs.def"
4483 #undef DEF_ATTR_NULL_TREE
4484 #undef DEF_ATTR_INT
4485 #undef DEF_ATTR_IDENT
4486 #undef DEF_ATTR_TREE_LIST
4487   ATTR_LAST
4488 };
4489
4490 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4491
4492 static void c_init_attributes (void);
4493
4494 enum c_builtin_type
4495 {
4496 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4497 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4498 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4499 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4500 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4501 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4502 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4503 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4504 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4505 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4506 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4507 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4508 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4509 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4510 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4511   NAME,
4512 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4513 #include "builtin-types.def"
4514 #undef DEF_PRIMITIVE_TYPE
4515 #undef DEF_FUNCTION_TYPE_0
4516 #undef DEF_FUNCTION_TYPE_1
4517 #undef DEF_FUNCTION_TYPE_2
4518 #undef DEF_FUNCTION_TYPE_3
4519 #undef DEF_FUNCTION_TYPE_4
4520 #undef DEF_FUNCTION_TYPE_5
4521 #undef DEF_FUNCTION_TYPE_6
4522 #undef DEF_FUNCTION_TYPE_7
4523 #undef DEF_FUNCTION_TYPE_VAR_0
4524 #undef DEF_FUNCTION_TYPE_VAR_1
4525 #undef DEF_FUNCTION_TYPE_VAR_2
4526 #undef DEF_FUNCTION_TYPE_VAR_3
4527 #undef DEF_FUNCTION_TYPE_VAR_4
4528 #undef DEF_FUNCTION_TYPE_VAR_5
4529 #undef DEF_POINTER_TYPE
4530   BT_LAST
4531 };
4532
4533 typedef enum c_builtin_type builtin_type;
4534
4535 /* A temporary array for c_common_nodes_and_builtins.  Used in
4536    communication with def_fn_type.  */
4537 static tree builtin_types[(int) BT_LAST + 1];
4538
4539 /* A helper function for c_common_nodes_and_builtins.  Build function type
4540    for DEF with return type RET and N arguments.  If VAR is true, then the
4541    function should be variadic after those N arguments.
4542
4543    Takes special care not to ICE if any of the types involved are
4544    error_mark_node, which indicates that said type is not in fact available
4545    (see builtin_type_for_size).  In which case the function type as a whole
4546    should be error_mark_node.  */
4547
4548 static void
4549 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4550 {
4551   tree args = NULL, t;
4552   va_list list;
4553   int i;
4554
4555   va_start (list, n);
4556   for (i = 0; i < n; ++i)
4557     {
4558       builtin_type a = (builtin_type) va_arg (list, int);
4559       t = builtin_types[a];
4560       if (t == error_mark_node)
4561         goto egress;
4562       args = tree_cons (NULL_TREE, t, args);
4563     }
4564   va_end (list);
4565
4566   args = nreverse (args);
4567   if (!var)
4568     args = chainon (args, void_list_node);
4569
4570   t = builtin_types[ret];
4571   if (t == error_mark_node)
4572     goto egress;
4573   t = build_function_type (t, args);
4574
4575  egress:
4576   builtin_types[def] = t;
4577 }
4578
4579 /* Build builtin functions common to both C and C++ language
4580    frontends.  */
4581
4582 static void
4583 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4584 {
4585 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4586   builtin_types[ENUM] = VALUE;
4587 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4588   def_fn_type (ENUM, RETURN, 0, 0);
4589 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4590   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4591 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4592   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4593 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4594   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4595 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4596   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4597 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4598   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4599 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4600                             ARG6)                                       \
4601   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4602 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4603                             ARG6, ARG7)                                 \
4604   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4605 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4606   def_fn_type (ENUM, RETURN, 1, 0);
4607 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4608   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4609 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4610   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4611 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4612   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4613 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4614   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4615 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4616   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4617 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4618   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4619
4620 #include "builtin-types.def"
4621
4622 #undef DEF_PRIMITIVE_TYPE
4623 #undef DEF_FUNCTION_TYPE_1
4624 #undef DEF_FUNCTION_TYPE_2
4625 #undef DEF_FUNCTION_TYPE_3
4626 #undef DEF_FUNCTION_TYPE_4
4627 #undef DEF_FUNCTION_TYPE_5
4628 #undef DEF_FUNCTION_TYPE_6
4629 #undef DEF_FUNCTION_TYPE_VAR_0
4630 #undef DEF_FUNCTION_TYPE_VAR_1
4631 #undef DEF_FUNCTION_TYPE_VAR_2
4632 #undef DEF_FUNCTION_TYPE_VAR_3
4633 #undef DEF_FUNCTION_TYPE_VAR_4
4634 #undef DEF_FUNCTION_TYPE_VAR_5
4635 #undef DEF_POINTER_TYPE
4636   builtin_types[(int) BT_LAST] = NULL_TREE;
4637
4638   c_init_attributes ();
4639
4640 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4641                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4642   if (NAME && COND)                                                     \
4643     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4644                    builtin_types[(int) TYPE],                           \
4645                    builtin_types[(int) LIBTYPE],                        \
4646                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4647                    built_in_attributes[(int) ATTRS], IMPLICIT);
4648 #include "builtins.def"
4649 #undef DEF_BUILTIN
4650
4651   targetm.init_builtins ();
4652
4653   build_common_builtin_nodes ();
4654
4655   if (flag_mudflap)
4656     mudflap_init ();
4657 }
4658
4659 /* Like get_identifier, but avoid warnings about null arguments when
4660    the argument may be NULL for targets where GCC lacks stdint.h type
4661    information.  */
4662
4663 static inline tree
4664 c_get_ident (const char *id)
4665 {
4666   return get_identifier (id);
4667 }
4668
4669 /* Build tree nodes and builtin functions common to both C and C++ language
4670    frontends.  */
4671
4672 void
4673 c_common_nodes_and_builtins (void)
4674 {
4675   int char16_type_size;
4676   int char32_type_size;
4677   int wchar_type_size;
4678   tree array_domain_type;
4679   tree va_list_ref_type_node;
4680   tree va_list_arg_type_node;
4681
4682   /* Define `int' and `char' first so that dbx will output them first.  */
4683   record_builtin_type (RID_INT, NULL, integer_type_node);
4684   record_builtin_type (RID_CHAR, "char", char_type_node);
4685
4686   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4687      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4688      but not C.  Are the conditionals here needed?  */
4689   if (c_dialect_cxx ())
4690     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4691   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4692   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4693   record_builtin_type (RID_MAX, "long unsigned int",
4694                        long_unsigned_type_node);
4695   if (c_dialect_cxx ())
4696     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4697   record_builtin_type (RID_MAX, "long long int",
4698                        long_long_integer_type_node);
4699   record_builtin_type (RID_MAX, "long long unsigned int",
4700                        long_long_unsigned_type_node);
4701   if (c_dialect_cxx ())
4702     record_builtin_type (RID_MAX, "long long unsigned",
4703                          long_long_unsigned_type_node);
4704   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4705   record_builtin_type (RID_MAX, "short unsigned int",
4706                        short_unsigned_type_node);
4707   if (c_dialect_cxx ())
4708     record_builtin_type (RID_MAX, "unsigned short",
4709                          short_unsigned_type_node);
4710
4711   /* Define both `signed char' and `unsigned char'.  */
4712   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4713   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4714
4715   /* These are types that c_common_type_for_size and
4716      c_common_type_for_mode use.  */
4717   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4718                                          intQI_type_node));
4719   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4720                                          intHI_type_node));
4721   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4722                                          intSI_type_node));
4723   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4724                                          intDI_type_node));
4725 #if HOST_BITS_PER_WIDE_INT >= 64
4726   if (targetm.scalar_mode_supported_p (TImode))
4727     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4728                                            get_identifier ("__int128_t"),
4729                                            intTI_type_node));
4730 #endif
4731   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4732                                          unsigned_intQI_type_node));
4733   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4734                                          unsigned_intHI_type_node));
4735   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4736                                          unsigned_intSI_type_node));
4737   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4738                                          unsigned_intDI_type_node));
4739 #if HOST_BITS_PER_WIDE_INT >= 64
4740   if (targetm.scalar_mode_supported_p (TImode))
4741     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4742                                            get_identifier ("__uint128_t"),
4743                                            unsigned_intTI_type_node));
4744 #endif
4745
4746   /* Create the widest literal types.  */
4747   widest_integer_literal_type_node
4748     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4749   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4750                                          widest_integer_literal_type_node));
4751
4752   widest_unsigned_literal_type_node
4753     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4754   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4755                                          widest_unsigned_literal_type_node));
4756
4757   /* `unsigned long' is the standard type for sizeof.
4758      Note that stddef.h uses `unsigned long',
4759      and this must agree, even if long and int are the same size.  */
4760   size_type_node =
4761     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4762   signed_size_type_node = c_common_signed_type (size_type_node);
4763   set_sizetype (size_type_node);
4764
4765   pid_type_node =
4766     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4767
4768   build_common_tree_nodes_2 (flag_short_double);
4769
4770   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4771   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4772   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4773
4774   /* Only supported decimal floating point extension if the target
4775      actually supports underlying modes. */
4776   if (targetm.scalar_mode_supported_p (SDmode)
4777       && targetm.scalar_mode_supported_p (DDmode)
4778       && targetm.scalar_mode_supported_p (TDmode))
4779     {
4780       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4781       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4782       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4783     }
4784
4785   if (targetm.fixed_point_supported_p ())
4786     {
4787       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4788       record_builtin_type (RID_FRACT, NULL, fract_type_node);
4789       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4790       record_builtin_type (RID_MAX, "long long _Fract",
4791                            long_long_fract_type_node);
4792       record_builtin_type (RID_MAX, "unsigned short _Fract",
4793                            unsigned_short_fract_type_node);
4794       record_builtin_type (RID_MAX, "unsigned _Fract",
4795                            unsigned_fract_type_node);
4796       record_builtin_type (RID_MAX, "unsigned long _Fract",
4797                            unsigned_long_fract_type_node);
4798       record_builtin_type (RID_MAX, "unsigned long long _Fract",
4799                            unsigned_long_long_fract_type_node);
4800       record_builtin_type (RID_MAX, "_Sat short _Fract",
4801                            sat_short_fract_type_node);
4802       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4803       record_builtin_type (RID_MAX, "_Sat long _Fract",
4804                            sat_long_fract_type_node);
4805       record_builtin_type (RID_MAX, "_Sat long long _Fract",
4806                            sat_long_long_fract_type_node);
4807       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4808                            sat_unsigned_short_fract_type_node);
4809       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4810                            sat_unsigned_fract_type_node);
4811       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4812                            sat_unsigned_long_fract_type_node);
4813       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4814                            sat_unsigned_long_long_fract_type_node);
4815       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4816       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4817       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4818       record_builtin_type (RID_MAX, "long long _Accum",
4819                            long_long_accum_type_node);
4820       record_builtin_type (RID_MAX, "unsigned short _Accum",
4821                            unsigned_short_accum_type_node);
4822       record_builtin_type (RID_MAX, "unsigned _Accum",
4823                            unsigned_accum_type_node);
4824       record_builtin_type (RID_MAX, "unsigned long _Accum",
4825                            unsigned_long_accum_type_node);
4826       record_builtin_type (RID_MAX, "unsigned long long _Accum",
4827                            unsigned_long_long_accum_type_node);
4828       record_builtin_type (RID_MAX, "_Sat short _Accum",
4829                            sat_short_accum_type_node);
4830       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4831       record_builtin_type (RID_MAX, "_Sat long _Accum",
4832                            sat_long_accum_type_node);
4833       record_builtin_type (RID_MAX, "_Sat long long _Accum",
4834                           sat_long_long_accum_type_node);
4835       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4836                            sat_unsigned_short_accum_type_node);
4837       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4838                            sat_unsigned_accum_type_node);
4839       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4840                            sat_unsigned_long_accum_type_node);
4841       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4842                            sat_unsigned_long_long_accum_type_node);
4843
4844     }
4845
4846   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4847                                          get_identifier ("complex int"),
4848                                          complex_integer_type_node));
4849   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4850                                          get_identifier ("complex float"),
4851                                          complex_float_type_node));
4852   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4853                                          get_identifier ("complex double"),
4854                                          complex_double_type_node));
4855   lang_hooks.decls.pushdecl
4856     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4857                  complex_long_double_type_node));
4858
4859   if (c_dialect_cxx ())
4860     /* For C++, make fileptr_type_node a distinct void * type until
4861        FILE type is defined.  */
4862     fileptr_type_node = build_variant_type_copy (ptr_type_node);
4863
4864   record_builtin_type (RID_VOID, NULL, void_type_node);
4865
4866   /* Set the TYPE_NAME for any variants that were built before
4867      record_builtin_type gave names to the built-in types. */
4868   {
4869     tree void_name = TYPE_NAME (void_type_node);
4870     TYPE_NAME (void_type_node) = NULL_TREE;
4871     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4872       = void_name;
4873     TYPE_NAME (void_type_node) = void_name;
4874   }
4875
4876   /* This node must not be shared.  */
4877   void_zero_node = make_node (INTEGER_CST);
4878   TREE_TYPE (void_zero_node) = void_type_node;
4879
4880   void_list_node = build_void_list_node ();
4881
4882   /* Make a type to be the domain of a few array types
4883      whose domains don't really matter.
4884      200 is small enough that it always fits in size_t
4885      and large enough that it can hold most function names for the
4886      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
4887   array_domain_type = build_index_type (size_int (200));
4888
4889   /* Make a type for arrays of characters.
4890      With luck nothing will ever really depend on the length of this
4891      array type.  */
4892   char_array_type_node
4893     = build_array_type (char_type_node, array_domain_type);
4894
4895   /* Likewise for arrays of ints.  */
4896   int_array_type_node
4897     = build_array_type (integer_type_node, array_domain_type);
4898
4899   string_type_node = build_pointer_type (char_type_node);
4900   const_string_type_node
4901     = build_pointer_type (build_qualified_type
4902                           (char_type_node, TYPE_QUAL_CONST));
4903
4904   /* This is special for C++ so functions can be overloaded.  */
4905   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4906   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4907   wchar_type_size = TYPE_PRECISION (wchar_type_node);
4908   underlying_wchar_type_node = wchar_type_node;
4909   if (c_dialect_cxx ())
4910     {
4911       if (TYPE_UNSIGNED (wchar_type_node))
4912         wchar_type_node = make_unsigned_type (wchar_type_size);
4913       else
4914         wchar_type_node = make_signed_type (wchar_type_size);
4915       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4916     }
4917
4918   /* This is for wide string constants.  */
4919   wchar_array_type_node
4920     = build_array_type (wchar_type_node, array_domain_type);
4921
4922   /* Define 'char16_t'.  */
4923   char16_type_node = get_identifier (CHAR16_TYPE);
4924   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4925   char16_type_size = TYPE_PRECISION (char16_type_node);
4926   if (c_dialect_cxx ())
4927     {
4928       char16_type_node = make_unsigned_type (char16_type_size);
4929
4930       if (cxx_dialect == cxx0x)
4931         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4932     }
4933
4934   /* This is for UTF-16 string constants.  */
4935   char16_array_type_node
4936     = build_array_type (char16_type_node, array_domain_type);
4937
4938   /* Define 'char32_t'.  */
4939   char32_type_node = get_identifier (CHAR32_TYPE);
4940   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4941   char32_type_size = TYPE_PRECISION (char32_type_node);
4942   if (c_dialect_cxx ())
4943     {
4944       char32_type_node = make_unsigned_type (char32_type_size);
4945
4946       if (cxx_dialect == cxx0x)
4947         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4948     }
4949
4950   /* This is for UTF-32 string constants.  */
4951   char32_array_type_node
4952     = build_array_type (char32_type_node, array_domain_type);
4953
4954   wint_type_node =
4955     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4956
4957   intmax_type_node =
4958     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4959   uintmax_type_node =
4960     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4961
4962   if (SIG_ATOMIC_TYPE)
4963     sig_atomic_type_node =
4964       TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4965   if (INT8_TYPE)
4966     int8_type_node =
4967       TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4968   if (INT16_TYPE)
4969     int16_type_node =
4970       TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4971   if (INT32_TYPE)
4972     int32_type_node =
4973       TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4974   if (INT64_TYPE)
4975     int64_type_node =
4976       TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4977   if (UINT8_TYPE)
4978     uint8_type_node =
4979       TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4980   if (UINT16_TYPE)
4981     uint16_type_node =
4982       TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4983   if (UINT32_TYPE)
4984     c_uint32_type_node =
4985       TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4986   if (UINT64_TYPE)
4987     c_uint64_type_node =
4988       TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4989   if (INT_LEAST8_TYPE)
4990     int_least8_type_node =
4991       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4992   if (INT_LEAST16_TYPE)
4993     int_least16_type_node =
4994       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4995   if (INT_LEAST32_TYPE)
4996     int_least32_type_node =
4997       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4998   if (INT_LEAST64_TYPE)
4999     int_least64_type_node =
5000       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
5001   if (UINT_LEAST8_TYPE)
5002     uint_least8_type_node =
5003       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
5004   if (UINT_LEAST16_TYPE)
5005     uint_least16_type_node =
5006       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
5007   if (UINT_LEAST32_TYPE)
5008     uint_least32_type_node =
5009       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
5010   if (UINT_LEAST64_TYPE)
5011     uint_least64_type_node =
5012       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
5013   if (INT_FAST8_TYPE)
5014     int_fast8_type_node =
5015       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
5016   if (INT_FAST16_TYPE)
5017     int_fast16_type_node =
5018       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
5019   if (INT_FAST32_TYPE)
5020     int_fast32_type_node =
5021       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
5022   if (INT_FAST64_TYPE)
5023     int_fast64_type_node =
5024       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5025   if (UINT_FAST8_TYPE)
5026     uint_fast8_type_node =
5027       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5028   if (UINT_FAST16_TYPE)
5029     uint_fast16_type_node =
5030       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5031   if (UINT_FAST32_TYPE)
5032     uint_fast32_type_node =
5033       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5034   if (UINT_FAST64_TYPE)
5035     uint_fast64_type_node =
5036       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5037   if (INTPTR_TYPE)
5038     intptr_type_node =
5039       TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5040   if (UINTPTR_TYPE)
5041     uintptr_type_node =
5042       TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5043
5044   default_function_type = build_function_type (integer_type_node, NULL_TREE);
5045   ptrdiff_type_node
5046     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5047   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5048
5049   lang_hooks.decls.pushdecl
5050     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
5051                  va_list_type_node));
5052 #ifdef TARGET_ENUM_VA_LIST
5053   {
5054     int l;
5055     const char *pname;
5056     tree ptype;
5057     for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
5058       {
5059         lang_hooks.decls.pushdecl
5060           (build_decl (TYPE_DECL, get_identifier (pname),
5061                        ptype));
5062
5063       }
5064   }
5065 #endif
5066
5067   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5068     {
5069       va_list_arg_type_node = va_list_ref_type_node =
5070         build_pointer_type (TREE_TYPE (va_list_type_node));
5071     }
5072   else
5073     {
5074       va_list_arg_type_node = va_list_type_node;
5075       va_list_ref_type_node = build_reference_type (va_list_type_node);
5076     }
5077
5078   if (!flag_preprocess_only)
5079     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5080
5081   main_identifier_node = get_identifier ("main");
5082
5083   /* Create the built-in __null node.  It is important that this is
5084      not shared.  */
5085   null_node = make_node (INTEGER_CST);
5086   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5087
5088   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
5089   memset (builtin_types, 0, sizeof (builtin_types));
5090 }
5091
5092 /* Look up the function in built_in_decls that corresponds to DECL
5093    and set ASMSPEC as its user assembler name.  DECL must be a
5094    function decl that declares a builtin.  */
5095
5096 void
5097 set_builtin_user_assembler_name (tree decl, const char *asmspec)
5098 {
5099   tree builtin;
5100   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5101               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
5102               && asmspec != 0);
5103
5104   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
5105   set_user_assembler_name (builtin, asmspec);
5106   switch (DECL_FUNCTION_CODE (decl))
5107     {
5108     case BUILT_IN_MEMCPY:
5109       init_block_move_fn (asmspec);
5110       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
5111       break;
5112     case BUILT_IN_MEMSET:
5113       init_block_clear_fn (asmspec);
5114       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
5115       break;
5116     case BUILT_IN_MEMMOVE:
5117       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
5118       break;
5119     case BUILT_IN_MEMCMP:
5120       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
5121       break;
5122     case BUILT_IN_ABORT:
5123       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
5124       break;
5125     default:
5126       break;
5127     }
5128 }
5129
5130 /* The number of named compound-literals generated thus far.  */
5131 static GTY(()) int compound_literal_number;
5132
5133 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
5134
5135 void
5136 set_compound_literal_name (tree decl)
5137 {
5138   char *name;
5139   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5140                            compound_literal_number);
5141   compound_literal_number++;
5142   DECL_NAME (decl) = get_identifier (name);
5143 }
5144
5145 tree
5146 build_va_arg (tree expr, tree type)
5147 {
5148   return build1 (VA_ARG_EXPR, type, expr);
5149 }
5150
5151
5152 /* Linked list of disabled built-in functions.  */
5153
5154 typedef struct disabled_builtin
5155 {
5156   const char *name;
5157   struct disabled_builtin *next;
5158 } disabled_builtin;
5159 static disabled_builtin *disabled_builtins = NULL;
5160
5161 static bool builtin_function_disabled_p (const char *);
5162
5163 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
5164    begins with "__builtin_", give an error.  */
5165
5166 void
5167 disable_builtin_function (const char *name)
5168 {
5169   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5170     error ("cannot disable built-in function %qs", name);
5171   else
5172     {
5173       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5174       new_disabled_builtin->name = name;
5175       new_disabled_builtin->next = disabled_builtins;
5176       disabled_builtins = new_disabled_builtin;
5177     }
5178 }
5179
5180
5181 /* Return true if the built-in function NAME has been disabled, false
5182    otherwise.  */
5183
5184 static bool
5185 builtin_function_disabled_p (const char *name)
5186 {
5187   disabled_builtin *p;
5188   for (p = disabled_builtins; p != NULL; p = p->next)
5189     {
5190       if (strcmp (name, p->name) == 0)
5191         return true;
5192     }
5193   return false;
5194 }
5195
5196
5197 /* Worker for DEF_BUILTIN.
5198    Possibly define a builtin function with one or two names.
5199    Does not declare a non-__builtin_ function if flag_no_builtin, or if
5200    nonansi_p and flag_no_nonansi_builtin.  */
5201
5202 static void
5203 def_builtin_1 (enum built_in_function fncode,
5204                const char *name,
5205                enum built_in_class fnclass,
5206                tree fntype, tree libtype,
5207                bool both_p, bool fallback_p, bool nonansi_p,
5208                tree fnattrs, bool implicit_p)
5209 {
5210   tree decl;
5211   const char *libname;
5212
5213   if (fntype == error_mark_node)
5214     return;
5215
5216   gcc_assert ((!both_p && !fallback_p)
5217               || !strncmp (name, "__builtin_",
5218                            strlen ("__builtin_")));
5219
5220   libname = name + strlen ("__builtin_");
5221   decl = add_builtin_function (name, fntype, fncode, fnclass,
5222                                (fallback_p ? libname : NULL),
5223                                fnattrs);
5224   if (both_p
5225       && !flag_no_builtin && !builtin_function_disabled_p (libname)
5226       && !(nonansi_p && flag_no_nonansi_builtin))
5227     add_builtin_function (libname, libtype, fncode, fnclass,
5228                           NULL, fnattrs);
5229
5230   built_in_decls[(int) fncode] = decl;
5231   if (implicit_p)
5232     implicit_built_in_decls[(int) fncode] = decl;
5233 }
5234 \f
5235 /* Nonzero if the type T promotes to int.  This is (nearly) the
5236    integral promotions defined in ISO C99 6.3.1.1/2.  */
5237
5238 bool
5239 c_promoting_integer_type_p (const_tree t)
5240 {
5241   switch (TREE_CODE (t))
5242     {
5243     case INTEGER_TYPE:
5244       return (TYPE_MAIN_VARIANT (t) == char_type_node
5245               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5246               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5247               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5248               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5249               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5250
5251     case ENUMERAL_TYPE:
5252       /* ??? Technically all enumerations not larger than an int
5253          promote to an int.  But this is used along code paths
5254          that only want to notice a size change.  */
5255       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5256
5257     case BOOLEAN_TYPE:
5258       return 1;
5259
5260     default:
5261       return 0;
5262     }
5263 }
5264
5265 /* Return 1 if PARMS specifies a fixed number of parameters
5266    and none of their types is affected by default promotions.  */
5267
5268 int
5269 self_promoting_args_p (const_tree parms)
5270 {
5271   const_tree t;
5272   for (t = parms; t; t = TREE_CHAIN (t))
5273     {
5274       tree type = TREE_VALUE (t);
5275
5276       if (type == error_mark_node)
5277         continue;
5278
5279       if (TREE_CHAIN (t) == 0 && type != void_type_node)
5280         return 0;
5281
5282       if (type == 0)
5283         return 0;
5284
5285       if (TYPE_MAIN_VARIANT (type) == float_type_node)
5286         return 0;
5287
5288       if (c_promoting_integer_type_p (type))
5289         return 0;
5290     }
5291   return 1;
5292 }
5293
5294 /* Recursively remove any '*' or '&' operator from TYPE.  */
5295 tree
5296 strip_pointer_operator (tree t)
5297 {
5298   while (POINTER_TYPE_P (t))
5299     t = TREE_TYPE (t);
5300   return t;
5301 }
5302
5303 /* Recursively remove pointer or array type from TYPE. */
5304 tree
5305 strip_pointer_or_array_types (tree t)
5306 {
5307   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5308     t = TREE_TYPE (t);
5309   return t;
5310 }
5311
5312 /* Used to compare case labels.  K1 and K2 are actually tree nodes
5313    representing case labels, or NULL_TREE for a `default' label.
5314    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5315    K2, and 0 if K1 and K2 are equal.  */
5316
5317 int
5318 case_compare (splay_tree_key k1, splay_tree_key k2)
5319 {
5320   /* Consider a NULL key (such as arises with a `default' label) to be
5321      smaller than anything else.  */
5322   if (!k1)
5323     return k2 ? -1 : 0;
5324   else if (!k2)
5325     return k1 ? 1 : 0;
5326
5327   return tree_int_cst_compare ((tree) k1, (tree) k2);
5328 }
5329
5330 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
5331    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5332    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
5333    case label was declared using the usual C/C++ syntax, rather than
5334    the GNU case range extension.  CASES is a tree containing all the
5335    case ranges processed so far; COND is the condition for the
5336    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
5337    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
5338
5339 tree
5340 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
5341                   tree low_value, tree high_value)
5342 {
5343   tree type;
5344   tree label;
5345   tree case_label;
5346   splay_tree_node node;
5347
5348   /* Create the LABEL_DECL itself.  */
5349   label = create_artificial_label ();
5350
5351   /* If there was an error processing the switch condition, bail now
5352      before we get more confused.  */
5353   if (!cond || cond == error_mark_node)
5354     goto error_out;
5355
5356   if ((low_value && TREE_TYPE (low_value)
5357        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5358       || (high_value && TREE_TYPE (high_value)
5359           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5360     {
5361       error ("pointers are not permitted as case values");
5362       goto error_out;
5363     }
5364
5365   /* Case ranges are a GNU extension.  */
5366   if (high_value)
5367     pedwarn (input_location, OPT_pedantic,
5368              "range expressions in switch statements are non-standard");
5369
5370   type = TREE_TYPE (cond);
5371   if (low_value)
5372     {
5373       low_value = check_case_value (low_value);
5374       low_value = convert_and_check (type, low_value);
5375       if (low_value == error_mark_node)
5376         goto error_out;
5377     }
5378   if (high_value)
5379     {
5380       high_value = check_case_value (high_value);
5381       high_value = convert_and_check (type, high_value);
5382       if (high_value == error_mark_node)
5383         goto error_out;
5384     }
5385
5386   if (low_value && high_value)
5387     {
5388       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5389          really a case range, even though it was written that way.
5390          Remove the HIGH_VALUE to simplify later processing.  */
5391       if (tree_int_cst_equal (low_value, high_value))
5392         high_value = NULL_TREE;
5393       else if (!tree_int_cst_lt (low_value, high_value))
5394         warning (0, "empty range specified");
5395     }
5396
5397   /* See if the case is in range of the type of the original testing
5398      expression.  If both low_value and high_value are out of range,
5399      don't insert the case label and return NULL_TREE.  */
5400   if (low_value
5401       && !check_case_bounds (type, orig_type,
5402                              &low_value, high_value ? &high_value : NULL))
5403     return NULL_TREE;
5404
5405   /* Look up the LOW_VALUE in the table of case labels we already
5406      have.  */
5407   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5408   /* If there was not an exact match, check for overlapping ranges.
5409      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5410      that's a `default' label and the only overlap is an exact match.  */
5411   if (!node && (low_value || high_value))
5412     {
5413       splay_tree_node low_bound;
5414       splay_tree_node high_bound;
5415
5416       /* Even though there wasn't an exact match, there might be an
5417          overlap between this case range and another case range.
5418          Since we've (inductively) not allowed any overlapping case
5419          ranges, we simply need to find the greatest low case label
5420          that is smaller that LOW_VALUE, and the smallest low case
5421          label that is greater than LOW_VALUE.  If there is an overlap
5422          it will occur in one of these two ranges.  */
5423       low_bound = splay_tree_predecessor (cases,
5424                                           (splay_tree_key) low_value);
5425       high_bound = splay_tree_successor (cases,
5426                                          (splay_tree_key) low_value);
5427
5428       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5429          the LOW_VALUE, so there is no need to check unless the
5430          LOW_BOUND is in fact itself a case range.  */
5431       if (low_bound
5432           && CASE_HIGH ((tree) low_bound->value)
5433           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5434                                     low_value) >= 0)
5435         node = low_bound;
5436       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5437          range is bigger than the low end of the current range, so we
5438          are only interested if the current range is a real range, and
5439          not an ordinary case label.  */
5440       else if (high_bound
5441                && high_value
5442                && (tree_int_cst_compare ((tree) high_bound->key,
5443                                          high_value)
5444                    <= 0))
5445         node = high_bound;
5446     }
5447   /* If there was an overlap, issue an error.  */
5448   if (node)
5449     {
5450       tree duplicate = CASE_LABEL ((tree) node->value);
5451
5452       if (high_value)
5453         {
5454           error ("duplicate (or overlapping) case value");
5455           error ("%Jthis is the first entry overlapping that value", duplicate);
5456         }
5457       else if (low_value)
5458         {
5459           error ("duplicate case value") ;
5460           error ("%Jpreviously used here", duplicate);
5461         }
5462       else
5463         {
5464           error ("multiple default labels in one switch");
5465           error ("%Jthis is the first default label", duplicate);
5466         }
5467       goto error_out;
5468     }
5469
5470   /* Add a CASE_LABEL to the statement-tree.  */
5471   case_label = add_stmt (build_case_label (low_value, high_value, label));
5472   /* Register this case label in the splay tree.  */
5473   splay_tree_insert (cases,
5474                      (splay_tree_key) low_value,
5475                      (splay_tree_value) case_label);
5476
5477   return case_label;
5478
5479  error_out:
5480   /* Add a label so that the back-end doesn't think that the beginning of
5481      the switch is unreachable.  Note that we do not add a case label, as
5482      that just leads to duplicates and thence to failure later on.  */
5483   if (!cases->root)
5484     {
5485       tree t = create_artificial_label ();
5486       add_stmt (build_stmt (LABEL_EXPR, t));
5487     }
5488   return error_mark_node;
5489 }
5490
5491 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5492    Used to verify that case values match up with enumerator values.  */
5493
5494 static void
5495 match_case_to_enum_1 (tree key, tree type, tree label)
5496 {
5497   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5498
5499   /* ??? Not working too hard to print the double-word value.
5500      Should perhaps be done with %lwd in the diagnostic routines?  */
5501   if (TREE_INT_CST_HIGH (key) == 0)
5502     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5503               TREE_INT_CST_LOW (key));
5504   else if (!TYPE_UNSIGNED (type)
5505            && TREE_INT_CST_HIGH (key) == -1
5506            && TREE_INT_CST_LOW (key) != 0)
5507     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5508               -TREE_INT_CST_LOW (key));
5509   else
5510     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5511               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5512               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5513
5514   if (TYPE_NAME (type) == 0)
5515     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5516              "%Jcase value %qs not in enumerated type",
5517              CASE_LABEL (label), buf);
5518   else
5519     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5520              "%Jcase value %qs not in enumerated type %qT",
5521              CASE_LABEL (label), buf, type);
5522 }
5523
5524 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5525    Used to verify that case values match up with enumerator values.  */
5526
5527 static int
5528 match_case_to_enum (splay_tree_node node, void *data)
5529 {
5530   tree label = (tree) node->value;
5531   tree type = (tree) data;
5532
5533   /* Skip default case.  */
5534   if (!CASE_LOW (label))
5535     return 0;
5536
5537   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5538      when we did our enum->case scan.  Reset our scratch bit after.  */
5539   if (!CASE_LOW_SEEN (label))
5540     match_case_to_enum_1 (CASE_LOW (label), type, label);
5541   else
5542     CASE_LOW_SEEN (label) = 0;
5543
5544   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
5545      not set, that means that CASE_HIGH did not appear when we did our
5546      enum->case scan.  Reset our scratch bit after.  */
5547   if (CASE_HIGH (label))
5548     {
5549       if (!CASE_HIGH_SEEN (label))
5550         match_case_to_enum_1 (CASE_HIGH (label), type, label);
5551       else
5552         CASE_HIGH_SEEN (label) = 0;
5553     }
5554
5555   return 0;
5556 }
5557
5558 /* Handle -Wswitch*.  Called from the front end after parsing the
5559    switch construct.  */
5560 /* ??? Should probably be somewhere generic, since other languages
5561    besides C and C++ would want this.  At the moment, however, C/C++
5562    are the only tree-ssa languages that support enumerations at all,
5563    so the point is moot.  */
5564
5565 void
5566 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5567                       tree type, tree cond)
5568 {
5569   splay_tree_node default_node;
5570   splay_tree_node node;
5571   tree chain;
5572   int saved_warn_switch;
5573
5574   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5575     return;
5576
5577   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5578   if (!default_node)
5579     warning (OPT_Wswitch_default, "%Hswitch missing default case",
5580              &switch_location);
5581
5582   /* From here on, we only care about about enumerated types.  */
5583   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5584     return;
5585
5586   /* If the switch expression was an enumerated type, check that
5587      exactly all enumeration literals are covered by the cases.
5588      The check is made when -Wswitch was specified and there is no
5589      default case, or when -Wswitch-enum was specified.  */
5590
5591   if (!warn_switch_enum
5592       && !(warn_switch && !default_node))
5593     return;
5594
5595   /* Clearing COND if it is not an integer constant simplifies
5596      the tests inside the loop below.  */
5597   if (TREE_CODE (cond) != INTEGER_CST)
5598     cond = NULL_TREE;
5599
5600   /* The time complexity here is O(N*lg(N)) worst case, but for the
5601       common case of monotonically increasing enumerators, it is
5602       O(N), since the nature of the splay tree will keep the next
5603       element adjacent to the root at all times.  */
5604
5605   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5606     {
5607       tree value = TREE_VALUE (chain);
5608       if (TREE_CODE (value) == CONST_DECL)
5609         value = DECL_INITIAL (value);
5610       node = splay_tree_lookup (cases, (splay_tree_key) value);
5611       if (node)
5612         {
5613           /* Mark the CASE_LOW part of the case entry as seen.  */
5614           tree label = (tree) node->value;
5615           CASE_LOW_SEEN (label) = 1;
5616           continue;
5617         }
5618
5619       /* Even though there wasn't an exact match, there might be a
5620          case range which includes the enumerator's value.  */
5621       node = splay_tree_predecessor (cases, (splay_tree_key) value);
5622       if (node && CASE_HIGH ((tree) node->value))
5623         {
5624           tree label = (tree) node->value;
5625           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5626           if (cmp >= 0)
5627             {
5628               /* If we match the upper bound exactly, mark the CASE_HIGH
5629                  part of the case entry as seen.  */
5630               if (cmp == 0)
5631                 CASE_HIGH_SEEN (label) = 1;
5632               continue;
5633             }
5634         }
5635
5636       /* We've now determined that this enumerated literal isn't
5637          handled by the case labels of the switch statement.  */
5638
5639       /* If the switch expression is a constant, we only really care
5640          about whether that constant is handled by the switch.  */
5641       if (cond && tree_int_cst_compare (cond, value))
5642         continue;
5643
5644       /* If there is a default_node, the only relevant option is
5645          Wswitch-enum. Otherwise, if both are enabled then we prefer
5646          to warn using -Wswitch because -Wswitch is enabled by -Wall
5647          while -Wswitch-enum is explicit.  */
5648       warning ((default_node || !warn_switch)
5649                ? OPT_Wswitch_enum : OPT_Wswitch,
5650                "%Henumeration value %qE not handled in switch",
5651                &switch_location, TREE_PURPOSE (chain));
5652     }
5653
5654   /* Warn if there are case expressions that don't correspond to
5655      enumerators.  This can occur since C and C++ don't enforce
5656      type-checking of assignments to enumeration variables.
5657
5658      The time complexity here is now always O(N) worst case, since
5659      we should have marked both the lower bound and upper bound of
5660      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5661      above.  This scan also resets those fields.  */
5662
5663   /* If there is a default_node, the only relevant option is
5664      Wswitch-enum. Otherwise, if both are enabled then we prefer
5665      to warn using -Wswitch because -Wswitch is enabled by -Wall
5666      while -Wswitch-enum is explicit.  */
5667   saved_warn_switch = warn_switch;
5668   if (default_node)
5669     warn_switch = 0;
5670   splay_tree_foreach (cases, match_case_to_enum, type);
5671   warn_switch = saved_warn_switch;
5672
5673 }
5674
5675 /* Finish an expression taking the address of LABEL (an
5676    IDENTIFIER_NODE).  Returns an expression for the address.
5677
5678    LOC is the location for the expression returned.  */
5679
5680 tree
5681 finish_label_address_expr (tree label, location_t loc)
5682 {
5683   tree result;
5684
5685   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5686
5687   if (label == error_mark_node)
5688     return error_mark_node;
5689
5690   label = lookup_label (label);
5691   if (label == NULL_TREE)
5692     result = null_pointer_node;
5693   else
5694     {
5695       TREE_USED (label) = 1;
5696       result = build1 (ADDR_EXPR, ptr_type_node, label);
5697       /* The current function in not necessarily uninlinable.
5698          Computed gotos are incompatible with inlining, but the value
5699          here could be used only in a diagnostic, for example.  */
5700       protected_set_expr_location (result, loc);
5701     }
5702
5703   return result;
5704 }
5705 \f
5706
5707 /* Given a boolean expression ARG, return a tree representing an increment
5708    or decrement (as indicated by CODE) of ARG.  The front end must check for
5709    invalid cases (e.g., decrement in C++).  */
5710 tree
5711 boolean_increment (enum tree_code code, tree arg)
5712 {
5713   tree val;
5714   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5715
5716   arg = stabilize_reference (arg);
5717   switch (code)
5718     {
5719     case PREINCREMENT_EXPR:
5720       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5721       break;
5722     case POSTINCREMENT_EXPR:
5723       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5724       arg = save_expr (arg);
5725       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5726       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5727       break;
5728     case PREDECREMENT_EXPR:
5729       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5730                     invert_truthvalue (arg));
5731       break;
5732     case POSTDECREMENT_EXPR:
5733       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5734                     invert_truthvalue (arg));
5735       arg = save_expr (arg);
5736       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5737       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5738       break;
5739     default:
5740       gcc_unreachable ();
5741     }
5742   TREE_SIDE_EFFECTS (val) = 1;
5743   return val;
5744 }
5745 \f
5746 /* Built-in macros for stddef.h and stdint.h, that require macros
5747    defined in this file.  */
5748 void
5749 c_stddef_cpp_builtins(void)
5750 {
5751   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5752   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5753   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5754   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5755   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5756   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5757   builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5758   builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5759   if (SIG_ATOMIC_TYPE)
5760     builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5761   if (INT8_TYPE)
5762     builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5763   if (INT16_TYPE)
5764     builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5765   if (INT32_TYPE)
5766     builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5767   if (INT64_TYPE)
5768     builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5769   if (UINT8_TYPE)
5770     builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5771   if (UINT16_TYPE)
5772     builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5773   if (UINT32_TYPE)
5774     builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5775   if (UINT64_TYPE)
5776     builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5777   if (INT_LEAST8_TYPE)
5778     builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5779   if (INT_LEAST16_TYPE)
5780     builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5781   if (INT_LEAST32_TYPE)
5782     builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5783   if (INT_LEAST64_TYPE)
5784     builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5785   if (UINT_LEAST8_TYPE)
5786     builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5787   if (UINT_LEAST16_TYPE)
5788     builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5789   if (UINT_LEAST32_TYPE)
5790     builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5791   if (UINT_LEAST64_TYPE)
5792     builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5793   if (INT_FAST8_TYPE)
5794     builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5795   if (INT_FAST16_TYPE)
5796     builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5797   if (INT_FAST32_TYPE)
5798     builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5799   if (INT_FAST64_TYPE)
5800     builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5801   if (UINT_FAST8_TYPE)
5802     builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5803   if (UINT_FAST16_TYPE)
5804     builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5805   if (UINT_FAST32_TYPE)
5806     builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5807   if (UINT_FAST64_TYPE)
5808     builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5809   if (INTPTR_TYPE)
5810     builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5811   if (UINTPTR_TYPE)
5812     builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5813 }
5814
5815 static void
5816 c_init_attributes (void)
5817 {
5818   /* Fill in the built_in_attributes array.  */
5819 #define DEF_ATTR_NULL_TREE(ENUM)                                \
5820   built_in_attributes[(int) ENUM] = NULL_TREE;
5821 #define DEF_ATTR_INT(ENUM, VALUE)                               \
5822   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5823 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
5824   built_in_attributes[(int) ENUM] = get_identifier (STRING);
5825 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5826   built_in_attributes[(int) ENUM]                       \
5827     = tree_cons (built_in_attributes[(int) PURPOSE],    \
5828                  built_in_attributes[(int) VALUE],      \
5829                  built_in_attributes[(int) CHAIN]);
5830 #include "builtin-attrs.def"
5831 #undef DEF_ATTR_NULL_TREE
5832 #undef DEF_ATTR_INT
5833 #undef DEF_ATTR_IDENT
5834 #undef DEF_ATTR_TREE_LIST
5835 }
5836
5837 /* Attribute handlers common to C front ends.  */
5838
5839 /* Handle a "packed" attribute; arguments as in
5840    struct attribute_spec.handler.  */
5841
5842 static tree
5843 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5844                          int flags, bool *no_add_attrs)
5845 {
5846   if (TYPE_P (*node))
5847     {
5848       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5849         *node = build_variant_type_copy (*node);
5850       TYPE_PACKED (*node) = 1;
5851     }
5852   else if (TREE_CODE (*node) == FIELD_DECL)
5853     {
5854       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5855           /* Still pack bitfields.  */
5856           && ! DECL_INITIAL (*node))
5857         warning (OPT_Wattributes,
5858                  "%qE attribute ignored for field of type %qT",
5859                  name, TREE_TYPE (*node));
5860       else
5861         DECL_PACKED (*node) = 1;
5862     }
5863   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5864      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5865      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5866      that changes what the typedef is typing.  */
5867   else
5868     {
5869       warning (OPT_Wattributes, "%qE attribute ignored", name);
5870       *no_add_attrs = true;
5871     }
5872
5873   return NULL_TREE;
5874 }
5875
5876 /* Handle a "nocommon" attribute; arguments as in
5877    struct attribute_spec.handler.  */
5878
5879 static tree
5880 handle_nocommon_attribute (tree *node, tree name,
5881                            tree ARG_UNUSED (args),
5882                            int ARG_UNUSED (flags), bool *no_add_attrs)
5883 {
5884   if (TREE_CODE (*node) == VAR_DECL)
5885     DECL_COMMON (*node) = 0;
5886   else
5887     {
5888       warning (OPT_Wattributes, "%qE attribute ignored", name);
5889       *no_add_attrs = true;
5890     }
5891
5892   return NULL_TREE;
5893 }
5894
5895 /* Handle a "common" attribute; arguments as in
5896    struct attribute_spec.handler.  */
5897
5898 static tree
5899 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5900                          int ARG_UNUSED (flags), bool *no_add_attrs)
5901 {
5902   if (TREE_CODE (*node) == VAR_DECL)
5903     DECL_COMMON (*node) = 1;
5904   else
5905     {
5906       warning (OPT_Wattributes, "%qE attribute ignored", name);
5907       *no_add_attrs = true;
5908     }
5909
5910   return NULL_TREE;
5911 }
5912
5913 /* Handle a "noreturn" attribute; arguments as in
5914    struct attribute_spec.handler.  */
5915
5916 static tree
5917 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5918                            int ARG_UNUSED (flags), bool *no_add_attrs)
5919 {
5920   tree type = TREE_TYPE (*node);
5921
5922   /* See FIXME comment in c_common_attribute_table.  */
5923   if (TREE_CODE (*node) == FUNCTION_DECL)
5924     TREE_THIS_VOLATILE (*node) = 1;
5925   else if (TREE_CODE (type) == POINTER_TYPE
5926            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5927     TREE_TYPE (*node)
5928       = build_pointer_type
5929         (build_type_variant (TREE_TYPE (type),
5930                              TYPE_READONLY (TREE_TYPE (type)), 1));
5931   else
5932     {
5933       warning (OPT_Wattributes, "%qE attribute ignored", name);
5934       *no_add_attrs = true;
5935     }
5936
5937   return NULL_TREE;
5938 }
5939
5940 /* Handle a "hot" and attribute; arguments as in
5941    struct attribute_spec.handler.  */
5942
5943 static tree
5944 handle_hot_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 ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5950         {
5951           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5952                    name, "cold");
5953           *no_add_attrs = true;
5954         }
5955       /* Most of the rest of the hot 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 /* Handle a "cold" and attribute; arguments as in
5967    struct attribute_spec.handler.  */
5968
5969 static tree
5970 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5971                        int ARG_UNUSED (flags), bool *no_add_attrs)
5972 {
5973   if (TREE_CODE (*node) == FUNCTION_DECL)
5974     {
5975       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5976         {
5977           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5978                    name, "hot");
5979           *no_add_attrs = true;
5980         }
5981       /* Most of the rest of the cold processing is done later with
5982          lookup_attribute.  */
5983     }
5984   else
5985     {
5986       warning (OPT_Wattributes, "%qE attribute ignored", name);
5987       *no_add_attrs = true;
5988     }
5989
5990   return NULL_TREE;
5991 }
5992
5993 /* Handle a "noinline" attribute; arguments as in
5994    struct attribute_spec.handler.  */
5995
5996 static tree
5997 handle_noinline_attribute (tree *node, tree name,
5998                            tree ARG_UNUSED (args),
5999                            int ARG_UNUSED (flags), bool *no_add_attrs)
6000 {
6001   if (TREE_CODE (*node) == FUNCTION_DECL)
6002     DECL_UNINLINABLE (*node) = 1;
6003   else
6004     {
6005       warning (OPT_Wattributes, "%qE attribute ignored", name);
6006       *no_add_attrs = true;
6007     }
6008
6009   return NULL_TREE;
6010 }
6011
6012 /* Handle a "always_inline" attribute; arguments as in
6013    struct attribute_spec.handler.  */
6014
6015 static tree
6016 handle_always_inline_attribute (tree *node, tree name,
6017                                 tree ARG_UNUSED (args),
6018                                 int ARG_UNUSED (flags),
6019                                 bool *no_add_attrs)
6020 {
6021   if (TREE_CODE (*node) == FUNCTION_DECL)
6022     {
6023       /* Set the attribute and mark it for disregarding inline
6024          limits.  */
6025       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6026     }
6027   else
6028     {
6029       warning (OPT_Wattributes, "%qE attribute ignored", name);
6030       *no_add_attrs = true;
6031     }
6032
6033   return NULL_TREE;
6034 }
6035
6036 /* Handle a "gnu_inline" attribute; arguments as in
6037    struct attribute_spec.handler.  */
6038
6039 static tree
6040 handle_gnu_inline_attribute (tree *node, tree name,
6041                              tree ARG_UNUSED (args),
6042                              int ARG_UNUSED (flags),
6043                              bool *no_add_attrs)
6044 {
6045   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6046     {
6047       /* Do nothing else, just set the attribute.  We'll get at
6048          it later with lookup_attribute.  */
6049     }
6050   else
6051     {
6052       warning (OPT_Wattributes, "%qE attribute ignored", name);
6053       *no_add_attrs = true;
6054     }
6055
6056   return NULL_TREE;
6057 }
6058
6059 /* Handle an "artificial" attribute; arguments as in
6060    struct attribute_spec.handler.  */
6061
6062 static tree
6063 handle_artificial_attribute (tree *node, tree name,
6064                              tree ARG_UNUSED (args),
6065                              int ARG_UNUSED (flags),
6066                              bool *no_add_attrs)
6067 {
6068   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6069     {
6070       /* Do nothing else, just set the attribute.  We'll get at
6071          it later with lookup_attribute.  */
6072     }
6073   else
6074     {
6075       warning (OPT_Wattributes, "%qE attribute ignored", name);
6076       *no_add_attrs = true;
6077     }
6078
6079   return NULL_TREE;
6080 }
6081
6082 /* Handle a "flatten" attribute; arguments as in
6083    struct attribute_spec.handler.  */
6084
6085 static tree
6086 handle_flatten_attribute (tree *node, tree name,
6087                           tree args ATTRIBUTE_UNUSED,
6088                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6089 {
6090   if (TREE_CODE (*node) == FUNCTION_DECL)
6091     /* Do nothing else, just set the attribute.  We'll get at
6092        it later with lookup_attribute.  */
6093     ;
6094   else
6095     {
6096       warning (OPT_Wattributes, "%qE attribute ignored", name);
6097       *no_add_attrs = true;
6098     }
6099
6100   return NULL_TREE;
6101 }
6102
6103 /* Handle a "warning" or "error" attribute; arguments as in
6104    struct attribute_spec.handler.  */
6105
6106 static tree
6107 handle_error_attribute (tree *node, tree name, tree args,
6108                         int ARG_UNUSED (flags), bool *no_add_attrs)
6109 {
6110   if (TREE_CODE (*node) == FUNCTION_DECL
6111       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6112     /* Do nothing else, just set the attribute.  We'll get at
6113        it later with lookup_attribute.  */
6114     ;
6115   else
6116     {
6117       warning (OPT_Wattributes, "%qE attribute ignored", name);
6118       *no_add_attrs = true;
6119     }
6120
6121   return NULL_TREE;
6122 }
6123
6124 /* Handle a "used" attribute; arguments as in
6125    struct attribute_spec.handler.  */
6126
6127 static tree
6128 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6129                        int ARG_UNUSED (flags), bool *no_add_attrs)
6130 {
6131   tree node = *pnode;
6132
6133   if (TREE_CODE (node) == FUNCTION_DECL
6134       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6135     {
6136       TREE_USED (node) = 1;
6137       DECL_PRESERVE_P (node) = 1;
6138     }
6139   else
6140     {
6141       warning (OPT_Wattributes, "%qE attribute ignored", name);
6142       *no_add_attrs = true;
6143     }
6144
6145   return NULL_TREE;
6146 }
6147
6148 /* Handle a "unused" attribute; arguments as in
6149    struct attribute_spec.handler.  */
6150
6151 static tree
6152 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6153                          int flags, bool *no_add_attrs)
6154 {
6155   if (DECL_P (*node))
6156     {
6157       tree decl = *node;
6158
6159       if (TREE_CODE (decl) == PARM_DECL
6160           || TREE_CODE (decl) == VAR_DECL
6161           || TREE_CODE (decl) == FUNCTION_DECL
6162           || TREE_CODE (decl) == LABEL_DECL
6163           || TREE_CODE (decl) == TYPE_DECL)
6164         TREE_USED (decl) = 1;
6165       else
6166         {
6167           warning (OPT_Wattributes, "%qE attribute ignored", name);
6168           *no_add_attrs = true;
6169         }
6170     }
6171   else
6172     {
6173       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6174         *node = build_variant_type_copy (*node);
6175       TREE_USED (*node) = 1;
6176     }
6177
6178   return NULL_TREE;
6179 }
6180
6181 /* Handle a "externally_visible" attribute; arguments as in
6182    struct attribute_spec.handler.  */
6183
6184 static tree
6185 handle_externally_visible_attribute (tree *pnode, tree name,
6186                                      tree ARG_UNUSED (args),
6187                                      int ARG_UNUSED (flags),
6188                                      bool *no_add_attrs)
6189 {
6190   tree node = *pnode;
6191
6192   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6193     {
6194       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6195            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6196         {
6197           warning (OPT_Wattributes,
6198                    "%qE attribute have effect only on public objects", name);
6199           *no_add_attrs = true;
6200         }
6201     }
6202   else
6203     {
6204       warning (OPT_Wattributes, "%qE attribute ignored", name);
6205       *no_add_attrs = true;
6206     }
6207
6208   return NULL_TREE;
6209 }
6210
6211 /* Handle a "const" attribute; arguments as in
6212    struct attribute_spec.handler.  */
6213
6214 static tree
6215 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6216                         int ARG_UNUSED (flags), bool *no_add_attrs)
6217 {
6218   tree type = TREE_TYPE (*node);
6219
6220   /* See FIXME comment on noreturn in c_common_attribute_table.  */
6221   if (TREE_CODE (*node) == FUNCTION_DECL)
6222     TREE_READONLY (*node) = 1;
6223   else if (TREE_CODE (type) == POINTER_TYPE
6224            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6225     TREE_TYPE (*node)
6226       = build_pointer_type
6227         (build_type_variant (TREE_TYPE (type), 1,
6228                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
6229   else
6230     {
6231       warning (OPT_Wattributes, "%qE attribute ignored", name);
6232       *no_add_attrs = true;
6233     }
6234
6235   return NULL_TREE;
6236 }
6237
6238 /* Handle a "transparent_union" attribute; arguments as in
6239    struct attribute_spec.handler.  */
6240
6241 static tree
6242 handle_transparent_union_attribute (tree *node, tree name,
6243                                     tree ARG_UNUSED (args), int flags,
6244                                     bool *no_add_attrs)
6245 {
6246   tree type;
6247
6248   *no_add_attrs = true;
6249
6250   if (TREE_CODE (*node) == TYPE_DECL)
6251     node = &TREE_TYPE (*node);
6252   type = *node;
6253
6254   if (TREE_CODE (type) == UNION_TYPE)
6255     {
6256       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6257          the code in finish_struct.  */
6258       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6259         {
6260           if (TYPE_FIELDS (type) == NULL_TREE
6261               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6262             goto ignored;
6263
6264           /* A type variant isn't good enough, since we don't a cast
6265              to such a type removed as a no-op.  */
6266           *node = type = build_duplicate_type (type);
6267         }
6268
6269       TYPE_TRANSPARENT_UNION (type) = 1;
6270       return NULL_TREE;
6271     }
6272
6273  ignored:
6274   warning (OPT_Wattributes, "%qE attribute ignored", name);
6275   return NULL_TREE;
6276 }
6277
6278 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
6279    get the requested priority for a constructor or destructor,
6280    possibly issuing diagnostics for invalid or reserved
6281    priorities.  */
6282
6283 static priority_type
6284 get_priority (tree args, bool is_destructor)
6285 {
6286   HOST_WIDE_INT pri;
6287   tree arg;
6288
6289   if (!args)
6290     return DEFAULT_INIT_PRIORITY;
6291
6292   if (!SUPPORTS_INIT_PRIORITY)
6293     {
6294       if (is_destructor)
6295         error ("destructor priorities are not supported");
6296       else
6297         error ("constructor priorities are not supported");
6298       return DEFAULT_INIT_PRIORITY;
6299     }
6300
6301   arg = TREE_VALUE (args);
6302   if (!host_integerp (arg, /*pos=*/0)
6303       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6304     goto invalid;
6305
6306   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6307   if (pri < 0 || pri > MAX_INIT_PRIORITY)
6308     goto invalid;
6309
6310   if (pri <= MAX_RESERVED_INIT_PRIORITY)
6311     {
6312       if (is_destructor)
6313         warning (0,
6314                  "destructor priorities from 0 to %d are reserved "
6315                  "for the implementation",
6316                  MAX_RESERVED_INIT_PRIORITY);
6317       else
6318         warning (0,
6319                  "constructor priorities from 0 to %d are reserved "
6320                  "for the implementation",
6321                  MAX_RESERVED_INIT_PRIORITY);
6322     }
6323   return pri;
6324
6325  invalid:
6326   if (is_destructor)
6327     error ("destructor priorities must be integers from 0 to %d inclusive",
6328            MAX_INIT_PRIORITY);
6329   else
6330     error ("constructor priorities must be integers from 0 to %d inclusive",
6331            MAX_INIT_PRIORITY);
6332   return DEFAULT_INIT_PRIORITY;
6333 }
6334
6335 /* Handle a "constructor" attribute; arguments as in
6336    struct attribute_spec.handler.  */
6337
6338 static tree
6339 handle_constructor_attribute (tree *node, tree name, tree args,
6340                               int ARG_UNUSED (flags),
6341                               bool *no_add_attrs)
6342 {
6343   tree decl = *node;
6344   tree type = TREE_TYPE (decl);
6345
6346   if (TREE_CODE (decl) == FUNCTION_DECL
6347       && TREE_CODE (type) == FUNCTION_TYPE
6348       && decl_function_context (decl) == 0)
6349     {
6350       priority_type priority;
6351       DECL_STATIC_CONSTRUCTOR (decl) = 1;
6352       priority = get_priority (args, /*is_destructor=*/false);
6353       SET_DECL_INIT_PRIORITY (decl, priority);
6354       TREE_USED (decl) = 1;
6355     }
6356   else
6357     {
6358       warning (OPT_Wattributes, "%qE attribute ignored", name);
6359       *no_add_attrs = true;
6360     }
6361
6362   return NULL_TREE;
6363 }
6364
6365 /* Handle a "destructor" attribute; arguments as in
6366    struct attribute_spec.handler.  */
6367
6368 static tree
6369 handle_destructor_attribute (tree *node, tree name, tree args,
6370                              int ARG_UNUSED (flags),
6371                              bool *no_add_attrs)
6372 {
6373   tree decl = *node;
6374   tree type = TREE_TYPE (decl);
6375
6376   if (TREE_CODE (decl) == FUNCTION_DECL
6377       && TREE_CODE (type) == FUNCTION_TYPE
6378       && decl_function_context (decl) == 0)
6379     {
6380       priority_type priority;
6381       DECL_STATIC_DESTRUCTOR (decl) = 1;
6382       priority = get_priority (args, /*is_destructor=*/true);
6383       SET_DECL_FINI_PRIORITY (decl, priority);
6384       TREE_USED (decl) = 1;
6385     }
6386   else
6387     {
6388       warning (OPT_Wattributes, "%qE attribute ignored", name);
6389       *no_add_attrs = true;
6390     }
6391
6392   return NULL_TREE;
6393 }
6394
6395 /* Handle a "mode" attribute; arguments as in
6396    struct attribute_spec.handler.  */
6397
6398 static tree
6399 handle_mode_attribute (tree *node, tree name, tree args,
6400                        int ARG_UNUSED (flags), bool *no_add_attrs)
6401 {
6402   tree type = *node;
6403
6404   *no_add_attrs = true;
6405
6406   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
6407     warning (OPT_Wattributes, "%qE attribute ignored", name);
6408   else
6409     {
6410       int j;
6411       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
6412       int len = strlen (p);
6413       enum machine_mode mode = VOIDmode;
6414       tree typefm;
6415       bool valid_mode;
6416
6417       if (len > 4 && p[0] == '_' && p[1] == '_'
6418           && p[len - 1] == '_' && p[len - 2] == '_')
6419         {
6420           char *newp = (char *) alloca (len - 1);
6421
6422           strcpy (newp, &p[2]);
6423           newp[len - 4] = '\0';
6424           p = newp;
6425         }
6426
6427       /* Change this type to have a type with the specified mode.
6428          First check for the special modes.  */
6429       if (!strcmp (p, "byte"))
6430         mode = byte_mode;
6431       else if (!strcmp (p, "word"))
6432         mode = word_mode;
6433       else if (!strcmp (p, "pointer"))
6434         mode = ptr_mode;
6435       else if (!strcmp (p, "libgcc_cmp_return"))
6436         mode = targetm.libgcc_cmp_return_mode ();
6437       else if (!strcmp (p, "libgcc_shift_count"))
6438         mode = targetm.libgcc_shift_count_mode ();
6439       else if (!strcmp (p, "unwind_word"))
6440         mode = targetm.unwind_word_mode ();
6441       else
6442         for (j = 0; j < NUM_MACHINE_MODES; j++)
6443           if (!strcmp (p, GET_MODE_NAME (j)))
6444             {
6445               mode = (enum machine_mode) j;
6446               break;
6447             }
6448
6449       if (mode == VOIDmode)
6450         {
6451           error ("unknown machine mode %qs", p);
6452           return NULL_TREE;
6453         }
6454
6455       valid_mode = false;
6456       switch (GET_MODE_CLASS (mode))
6457         {
6458         case MODE_INT:
6459         case MODE_PARTIAL_INT:
6460         case MODE_FLOAT:
6461         case MODE_DECIMAL_FLOAT:
6462         case MODE_FRACT:
6463         case MODE_UFRACT:
6464         case MODE_ACCUM:
6465         case MODE_UACCUM:
6466           valid_mode = targetm.scalar_mode_supported_p (mode);
6467           break;
6468
6469         case MODE_COMPLEX_INT:
6470         case MODE_COMPLEX_FLOAT:
6471           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6472           break;
6473
6474         case MODE_VECTOR_INT:
6475         case MODE_VECTOR_FLOAT:
6476         case MODE_VECTOR_FRACT:
6477         case MODE_VECTOR_UFRACT:
6478         case MODE_VECTOR_ACCUM:
6479         case MODE_VECTOR_UACCUM:
6480           warning (OPT_Wattributes, "specifying vector types with "
6481                    "__attribute__ ((mode)) is deprecated");
6482           warning (OPT_Wattributes,
6483                    "use __attribute__ ((vector_size)) instead");
6484           valid_mode = vector_mode_valid_p (mode);
6485           break;
6486
6487         default:
6488           break;
6489         }
6490       if (!valid_mode)
6491         {
6492           error ("unable to emulate %qs", p);
6493           return NULL_TREE;
6494         }
6495
6496       if (POINTER_TYPE_P (type))
6497         {
6498           tree (*fn)(tree, enum machine_mode, bool);
6499
6500           if (!targetm.valid_pointer_mode (mode))
6501             {
6502               error ("invalid pointer mode %qs", p);
6503               return NULL_TREE;
6504             }
6505
6506           if (TREE_CODE (type) == POINTER_TYPE)
6507             fn = build_pointer_type_for_mode;
6508           else
6509             fn = build_reference_type_for_mode;
6510           typefm = fn (TREE_TYPE (type), mode, false);
6511         }
6512       else
6513         {
6514           /* For fixed-point modes, we need to test if the signness of type
6515              and the machine mode are consistent.  */
6516           if (ALL_FIXED_POINT_MODE_P (mode)
6517               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6518             {
6519               error ("signness of type and machine mode %qs don't match", p);
6520               return NULL_TREE;
6521             }
6522           /* For fixed-point modes, we need to pass saturating info.  */
6523           typefm = lang_hooks.types.type_for_mode (mode,
6524                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6525                                                       : TYPE_UNSIGNED (type));
6526         }
6527
6528       if (typefm == NULL_TREE)
6529         {
6530           error ("no data type for mode %qs", p);
6531           return NULL_TREE;
6532         }
6533       else if (TREE_CODE (type) == ENUMERAL_TYPE)
6534         {
6535           /* For enumeral types, copy the precision from the integer
6536              type returned above.  If not an INTEGER_TYPE, we can't use
6537              this mode for this type.  */
6538           if (TREE_CODE (typefm) != INTEGER_TYPE)
6539             {
6540               error ("cannot use mode %qs for enumeral types", p);
6541               return NULL_TREE;
6542             }
6543
6544           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6545             {
6546               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6547               typefm = type;
6548             }
6549           else
6550             {
6551               /* We cannot build a type variant, as there's code that assumes
6552                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
6553                  debug generators.  Instead, create a subrange type.  This
6554                  results in all of the enumeral values being emitted only once
6555                  in the original, and the subtype gets them by reference.  */
6556               if (TYPE_UNSIGNED (type))
6557                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6558               else
6559                 typefm = make_signed_type (TYPE_PRECISION (typefm));
6560               TREE_TYPE (typefm) = type;
6561             }
6562         }
6563       else if (VECTOR_MODE_P (mode)
6564                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6565                : TREE_CODE (type) != TREE_CODE (typefm))
6566         {
6567           error ("mode %qs applied to inappropriate type", p);
6568           return NULL_TREE;
6569         }
6570
6571       *node = typefm;
6572     }
6573
6574   return NULL_TREE;
6575 }
6576
6577 /* Handle a "section" attribute; arguments as in
6578    struct attribute_spec.handler.  */
6579
6580 static tree
6581 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6582                           int ARG_UNUSED (flags), bool *no_add_attrs)
6583 {
6584   tree decl = *node;
6585
6586   if (targetm.have_named_sections)
6587     {
6588       user_defined_section_attribute = true;
6589
6590       if ((TREE_CODE (decl) == FUNCTION_DECL
6591            || TREE_CODE (decl) == VAR_DECL)
6592           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6593         {
6594           if (TREE_CODE (decl) == VAR_DECL
6595               && current_function_decl != NULL_TREE
6596               && !TREE_STATIC (decl))
6597             {
6598               error ("%Jsection attribute cannot be specified for "
6599                      "local variables", decl);
6600               *no_add_attrs = true;
6601             }
6602
6603           /* The decl may have already been given a section attribute
6604              from a previous declaration.  Ensure they match.  */
6605           else if (DECL_SECTION_NAME (decl) != NULL_TREE
6606                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6607                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6608             {
6609               error ("section of %q+D conflicts with previous declaration",
6610                      *node);
6611               *no_add_attrs = true;
6612             }
6613           else if (TREE_CODE (decl) == VAR_DECL
6614                    && !targetm.have_tls && targetm.emutls.tmpl_section
6615                    && DECL_THREAD_LOCAL_P (decl))
6616             {
6617               error ("section of %q+D cannot be overridden", *node);
6618               *no_add_attrs = true;
6619             }
6620           else
6621             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6622         }
6623       else
6624         {
6625           error ("section attribute not allowed for %q+D", *node);
6626           *no_add_attrs = true;
6627         }
6628     }
6629   else
6630     {
6631       error ("%Jsection attributes are not supported for this target", *node);
6632       *no_add_attrs = true;
6633     }
6634
6635   return NULL_TREE;
6636 }
6637
6638 /* Handle a "aligned" attribute; arguments as in
6639    struct attribute_spec.handler.  */
6640
6641 static tree
6642 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6643                           int flags, bool *no_add_attrs)
6644 {
6645   tree decl = NULL_TREE;
6646   tree *type = NULL;
6647   int is_type = 0;
6648   tree align_expr = (args ? TREE_VALUE (args)
6649                      : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6650   int i;
6651
6652   if (DECL_P (*node))
6653     {
6654       decl = *node;
6655       type = &TREE_TYPE (decl);
6656       is_type = TREE_CODE (*node) == TYPE_DECL;
6657     }
6658   else if (TYPE_P (*node))
6659     type = node, is_type = 1;
6660
6661   if (TREE_CODE (align_expr) != INTEGER_CST)
6662     {
6663       error ("requested alignment is not a constant");
6664       *no_add_attrs = true;
6665     }
6666   else if ((i = tree_log2 (align_expr)) == -1)
6667     {
6668       error ("requested alignment is not a power of 2");
6669       *no_add_attrs = true;
6670     }
6671   else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6672     {
6673       error ("requested alignment is too large");
6674       *no_add_attrs = true;
6675     }
6676   else if (is_type)
6677     {
6678       /* If we have a TYPE_DECL, then copy the type, so that we
6679          don't accidentally modify a builtin type.  See pushdecl.  */
6680       if (decl && TREE_TYPE (decl) != error_mark_node
6681           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6682         {
6683           tree tt = TREE_TYPE (decl);
6684           *type = build_variant_type_copy (*type);
6685           DECL_ORIGINAL_TYPE (decl) = tt;
6686           TYPE_NAME (*type) = decl;
6687           TREE_USED (*type) = TREE_USED (decl);
6688           TREE_TYPE (decl) = *type;
6689         }
6690       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6691         *type = build_variant_type_copy (*type);
6692
6693       TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6694       TYPE_USER_ALIGN (*type) = 1;
6695     }
6696   else if (! VAR_OR_FUNCTION_DECL_P (decl)
6697            && TREE_CODE (decl) != FIELD_DECL)
6698     {
6699       error ("alignment may not be specified for %q+D", decl);
6700       *no_add_attrs = true;
6701     }
6702   else if (TREE_CODE (decl) == FUNCTION_DECL
6703            && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6704     {
6705       if (DECL_USER_ALIGN (decl))
6706         error ("alignment for %q+D was previously specified as %d "
6707                "and may not be decreased", decl,
6708                DECL_ALIGN (decl) / BITS_PER_UNIT);
6709       else
6710         error ("alignment for %q+D must be at least %d", decl,
6711                DECL_ALIGN (decl) / BITS_PER_UNIT);
6712       *no_add_attrs = true;
6713     }
6714   else
6715     {
6716       DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6717       DECL_USER_ALIGN (decl) = 1;
6718     }
6719
6720   return NULL_TREE;
6721 }
6722
6723 /* Handle a "weak" attribute; arguments as in
6724    struct attribute_spec.handler.  */
6725
6726 static tree
6727 handle_weak_attribute (tree *node, tree name,
6728                        tree ARG_UNUSED (args),
6729                        int ARG_UNUSED (flags),
6730                        bool * ARG_UNUSED (no_add_attrs))
6731 {
6732   if (TREE_CODE (*node) == FUNCTION_DECL
6733       && DECL_DECLARED_INLINE_P (*node))
6734     {
6735       error ("inline function %q+D cannot be declared weak", *node);
6736       *no_add_attrs = true;
6737     }
6738   else if (TREE_CODE (*node) == FUNCTION_DECL
6739            || TREE_CODE (*node) == VAR_DECL)
6740     declare_weak (*node);
6741   else
6742     warning (OPT_Wattributes, "%qE attribute ignored", name);
6743
6744   return NULL_TREE;
6745 }
6746
6747 /* Handle an "alias" attribute; arguments as in
6748    struct attribute_spec.handler.  */
6749
6750 static tree
6751 handle_alias_attribute (tree *node, tree name, tree args,
6752                         int ARG_UNUSED (flags), bool *no_add_attrs)
6753 {
6754   tree decl = *node;
6755
6756   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6757     {
6758       warning (OPT_Wattributes, "%qE attribute ignored", name);
6759       *no_add_attrs = true;
6760     }
6761   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6762       || (TREE_CODE (decl) != FUNCTION_DECL
6763           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6764       /* A static variable declaration is always a tentative definition,
6765          but the alias is a non-tentative definition which overrides.  */
6766       || (TREE_CODE (decl) != FUNCTION_DECL
6767           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6768     {
6769       error ("%q+D defined both normally and as an alias", decl);
6770       *no_add_attrs = true;
6771     }
6772
6773   /* Note that the very first time we process a nested declaration,
6774      decl_function_context will not be set.  Indeed, *would* never
6775      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6776      we do below.  After such frobbery, pushdecl would set the context.
6777      In any case, this is never what we want.  */
6778   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6779     {
6780       tree id;
6781
6782       id = TREE_VALUE (args);
6783       if (TREE_CODE (id) != STRING_CST)
6784         {
6785           error ("alias argument not a string");
6786           *no_add_attrs = true;
6787           return NULL_TREE;
6788         }
6789       id = get_identifier (TREE_STRING_POINTER (id));
6790       /* This counts as a use of the object pointed to.  */
6791       TREE_USED (id) = 1;
6792
6793       if (TREE_CODE (decl) == FUNCTION_DECL)
6794         DECL_INITIAL (decl) = error_mark_node;
6795       else
6796         {
6797           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6798             DECL_EXTERNAL (decl) = 1;
6799           else
6800             DECL_EXTERNAL (decl) = 0;
6801           TREE_STATIC (decl) = 1;
6802         }
6803     }
6804   else
6805     {
6806       warning (OPT_Wattributes, "%qE attribute ignored", name);
6807       *no_add_attrs = true;
6808     }
6809
6810   return NULL_TREE;
6811 }
6812
6813 /* Handle a "weakref" attribute; arguments as in struct
6814    attribute_spec.handler.  */
6815
6816 static tree
6817 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6818                           int flags, bool *no_add_attrs)
6819 {
6820   tree attr = NULL_TREE;
6821
6822   /* We must ignore the attribute when it is associated with
6823      local-scoped decls, since attribute alias is ignored and many
6824      such symbols do not even have a DECL_WEAK field.  */
6825   if (decl_function_context (*node)
6826       || current_function_decl
6827       || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6828     {
6829       warning (OPT_Wattributes, "%qE attribute ignored", name);
6830       *no_add_attrs = true;
6831       return NULL_TREE;
6832     }
6833
6834   /* The idea here is that `weakref("name")' mutates into `weakref,
6835      alias("name")', and weakref without arguments, in turn,
6836      implicitly adds weak. */
6837
6838   if (args)
6839     {
6840       attr = tree_cons (get_identifier ("alias"), args, attr);
6841       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6842
6843       *no_add_attrs = true;
6844
6845       decl_attributes (node, attr, flags);
6846     }
6847   else
6848     {
6849       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6850         error ("%Jweakref attribute must appear before alias attribute",
6851                *node);
6852
6853       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6854          and that isn't supported; and because it wants to add it to
6855          the list of weak decls, which isn't helpful.  */
6856       DECL_WEAK (*node) = 1;
6857     }
6858
6859   return NULL_TREE;
6860 }
6861
6862 /* Handle an "visibility" attribute; arguments as in
6863    struct attribute_spec.handler.  */
6864
6865 static tree
6866 handle_visibility_attribute (tree *node, tree name, tree args,
6867                              int ARG_UNUSED (flags),
6868                              bool *ARG_UNUSED (no_add_attrs))
6869 {
6870   tree decl = *node;
6871   tree id = TREE_VALUE (args);
6872   enum symbol_visibility vis;
6873
6874   if (TYPE_P (*node))
6875     {
6876       if (TREE_CODE (*node) == ENUMERAL_TYPE)
6877         /* OK */;
6878       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6879         {
6880           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6881                    name);
6882           return NULL_TREE;
6883         }
6884       else if (TYPE_FIELDS (*node))
6885         {
6886           error ("%qE attribute ignored because %qT is already defined",
6887                  name, *node);
6888           return NULL_TREE;
6889         }
6890     }
6891   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6892     {
6893       warning (OPT_Wattributes, "%qE attribute ignored", name);
6894       return NULL_TREE;
6895     }
6896
6897   if (TREE_CODE (id) != STRING_CST)
6898     {
6899       error ("visibility argument not a string");
6900       return NULL_TREE;
6901     }
6902
6903   /*  If this is a type, set the visibility on the type decl.  */
6904   if (TYPE_P (decl))
6905     {
6906       decl = TYPE_NAME (decl);
6907       if (!decl)
6908         return NULL_TREE;
6909       if (TREE_CODE (decl) == IDENTIFIER_NODE)
6910         {
6911            warning (OPT_Wattributes, "%qE attribute ignored on types",
6912                     name);
6913            return NULL_TREE;
6914         }
6915     }
6916
6917   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6918     vis = VISIBILITY_DEFAULT;
6919   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6920     vis = VISIBILITY_INTERNAL;
6921   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6922     vis = VISIBILITY_HIDDEN;
6923   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6924     vis = VISIBILITY_PROTECTED;
6925   else
6926     {
6927       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6928       vis = VISIBILITY_DEFAULT;
6929     }
6930
6931   if (DECL_VISIBILITY_SPECIFIED (decl)
6932       && vis != DECL_VISIBILITY (decl))
6933     {
6934       tree attributes = (TYPE_P (*node)
6935                          ? TYPE_ATTRIBUTES (*node)
6936                          : DECL_ATTRIBUTES (decl));
6937       if (lookup_attribute ("visibility", attributes))
6938         error ("%qD redeclared with different visibility", decl);
6939       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6940                && lookup_attribute ("dllimport", attributes))
6941         error ("%qD was declared %qs which implies default visibility",
6942                decl, "dllimport");
6943       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6944                && lookup_attribute ("dllexport", attributes))
6945         error ("%qD was declared %qs which implies default visibility",
6946                decl, "dllexport");
6947     }
6948
6949   DECL_VISIBILITY (decl) = vis;
6950   DECL_VISIBILITY_SPECIFIED (decl) = 1;
6951
6952   /* Go ahead and attach the attribute to the node as well.  This is needed
6953      so we can determine whether we have VISIBILITY_DEFAULT because the
6954      visibility was not specified, or because it was explicitly overridden
6955      from the containing scope.  */
6956
6957   return NULL_TREE;
6958 }
6959
6960 /* Determine the ELF symbol visibility for DECL, which is either a
6961    variable or a function.  It is an error to use this function if a
6962    definition of DECL is not available in this translation unit.
6963    Returns true if the final visibility has been determined by this
6964    function; false if the caller is free to make additional
6965    modifications.  */
6966
6967 bool
6968 c_determine_visibility (tree decl)
6969 {
6970   gcc_assert (TREE_CODE (decl) == VAR_DECL
6971               || TREE_CODE (decl) == FUNCTION_DECL);
6972
6973   /* If the user explicitly specified the visibility with an
6974      attribute, honor that.  DECL_VISIBILITY will have been set during
6975      the processing of the attribute.  We check for an explicit
6976      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6977      to distinguish the use of an attribute from the use of a "#pragma
6978      GCC visibility push(...)"; in the latter case we still want other
6979      considerations to be able to overrule the #pragma.  */
6980   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6981       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6982           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6983               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6984     return true;
6985
6986   /* Set default visibility to whatever the user supplied with
6987      visibility_specified depending on #pragma GCC visibility.  */
6988   if (!DECL_VISIBILITY_SPECIFIED (decl))
6989     {
6990       if (visibility_options.inpragma
6991           || DECL_VISIBILITY (decl) != default_visibility)
6992         {
6993           DECL_VISIBILITY (decl) = default_visibility;
6994           DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6995           /* If visibility changed and DECL already has DECL_RTL, ensure
6996              symbol flags are updated.  */
6997           if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6998                || TREE_CODE (decl) == FUNCTION_DECL)
6999               && DECL_RTL_SET_P (decl))
7000             make_decl_rtl (decl);
7001         }
7002     }
7003   return false;
7004 }
7005
7006 /* Handle an "tls_model" attribute; arguments as in
7007    struct attribute_spec.handler.  */
7008
7009 static tree
7010 handle_tls_model_attribute (tree *node, tree name, tree args,
7011                             int ARG_UNUSED (flags), bool *no_add_attrs)
7012 {
7013   tree id;
7014   tree decl = *node;
7015   enum tls_model kind;
7016
7017   *no_add_attrs = true;
7018
7019   if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7020     {
7021       warning (OPT_Wattributes, "%qE attribute ignored", name);
7022       return NULL_TREE;
7023     }
7024
7025   kind = DECL_TLS_MODEL (decl);
7026   id = TREE_VALUE (args);
7027   if (TREE_CODE (id) != STRING_CST)
7028     {
7029       error ("tls_model argument not a string");
7030       return NULL_TREE;
7031     }
7032
7033   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7034     kind = TLS_MODEL_LOCAL_EXEC;
7035   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7036     kind = TLS_MODEL_INITIAL_EXEC;
7037   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7038     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7039   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7040     kind = TLS_MODEL_GLOBAL_DYNAMIC;
7041   else
7042     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7043
7044   DECL_TLS_MODEL (decl) = kind;
7045   return NULL_TREE;
7046 }
7047
7048 /* Handle a "no_instrument_function" attribute; arguments as in
7049    struct attribute_spec.handler.  */
7050
7051 static tree
7052 handle_no_instrument_function_attribute (tree *node, tree name,
7053                                          tree ARG_UNUSED (args),
7054                                          int ARG_UNUSED (flags),
7055                                          bool *no_add_attrs)
7056 {
7057   tree decl = *node;
7058
7059   if (TREE_CODE (decl) != FUNCTION_DECL)
7060     {
7061       error ("%J%qE attribute applies only to functions", decl, name);
7062       *no_add_attrs = true;
7063     }
7064   else if (DECL_INITIAL (decl))
7065     {
7066       error ("%Jcan%'t set %qE attribute after definition", decl, name);
7067       *no_add_attrs = true;
7068     }
7069   else
7070     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7071
7072   return NULL_TREE;
7073 }
7074
7075 /* Handle a "malloc" attribute; arguments as in
7076    struct attribute_spec.handler.  */
7077
7078 static tree
7079 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7080                          int ARG_UNUSED (flags), bool *no_add_attrs)
7081 {
7082   if (TREE_CODE (*node) == FUNCTION_DECL
7083       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7084     DECL_IS_MALLOC (*node) = 1;
7085   else
7086     {
7087       warning (OPT_Wattributes, "%qE attribute ignored", name);
7088       *no_add_attrs = true;
7089     }
7090
7091   return NULL_TREE;
7092 }
7093
7094 /* Handle a "alloc_size" attribute; arguments as in
7095    struct attribute_spec.handler.  */
7096
7097 static tree
7098 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7099                              int ARG_UNUSED (flags), bool *no_add_attrs)
7100 {
7101   unsigned arg_count = type_num_arguments (*node);
7102   for (; args; args = TREE_CHAIN (args))
7103     {
7104       tree position = TREE_VALUE (args);
7105
7106       if (TREE_CODE (position) != INTEGER_CST
7107           || TREE_INT_CST_HIGH (position)
7108           || TREE_INT_CST_LOW (position) < 1
7109           || TREE_INT_CST_LOW (position) > arg_count )
7110         {
7111           warning (OPT_Wattributes,
7112                    "alloc_size parameter outside range");
7113           *no_add_attrs = true;
7114           return NULL_TREE;
7115         }
7116     }
7117   return NULL_TREE;
7118 }
7119
7120 /* Handle a "returns_twice" attribute; arguments as in
7121    struct attribute_spec.handler.  */
7122
7123 static tree
7124 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7125                          int ARG_UNUSED (flags), bool *no_add_attrs)
7126 {
7127   if (TREE_CODE (*node) == FUNCTION_DECL)
7128     DECL_IS_RETURNS_TWICE (*node) = 1;
7129   else
7130     {
7131       warning (OPT_Wattributes, "%qE attribute ignored", name);
7132       *no_add_attrs = true;
7133     }
7134
7135   return NULL_TREE;
7136 }
7137
7138 /* Handle a "no_limit_stack" attribute; arguments as in
7139    struct attribute_spec.handler.  */
7140
7141 static tree
7142 handle_no_limit_stack_attribute (tree *node, tree name,
7143                                  tree ARG_UNUSED (args),
7144                                  int ARG_UNUSED (flags),
7145                                  bool *no_add_attrs)
7146 {
7147   tree decl = *node;
7148
7149   if (TREE_CODE (decl) != FUNCTION_DECL)
7150     {
7151       error ("%J%qE attribute applies only to functions", decl, name);
7152       *no_add_attrs = true;
7153     }
7154   else if (DECL_INITIAL (decl))
7155     {
7156       error ("%Jcan%'t set %qE attribute after definition", decl, name);
7157       *no_add_attrs = true;
7158     }
7159   else
7160     DECL_NO_LIMIT_STACK (decl) = 1;
7161
7162   return NULL_TREE;
7163 }
7164
7165 /* Handle a "pure" attribute; arguments as in
7166    struct attribute_spec.handler.  */
7167
7168 static tree
7169 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7170                        int ARG_UNUSED (flags), bool *no_add_attrs)
7171 {
7172   if (TREE_CODE (*node) == FUNCTION_DECL)
7173     DECL_PURE_P (*node) = 1;
7174   /* ??? TODO: Support types.  */
7175   else
7176     {
7177       warning (OPT_Wattributes, "%qE attribute ignored", name);
7178       *no_add_attrs = true;
7179     }
7180
7181   return NULL_TREE;
7182 }
7183
7184 /* Handle a "no vops" attribute; arguments as in
7185    struct attribute_spec.handler.  */
7186
7187 static tree
7188 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7189                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7190                          bool *ARG_UNUSED (no_add_attrs))
7191 {
7192   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7193   DECL_IS_NOVOPS (*node) = 1;
7194   return NULL_TREE;
7195 }
7196
7197 /* Handle a "deprecated" attribute; arguments as in
7198    struct attribute_spec.handler.  */
7199
7200 static tree
7201 handle_deprecated_attribute (tree *node, tree name,
7202                              tree ARG_UNUSED (args), int flags,
7203                              bool *no_add_attrs)
7204 {
7205   tree type = NULL_TREE;
7206   int warn = 0;
7207   tree what = NULL_TREE;
7208
7209   if (DECL_P (*node))
7210     {
7211       tree decl = *node;
7212       type = TREE_TYPE (decl);
7213
7214       if (TREE_CODE (decl) == TYPE_DECL
7215           || TREE_CODE (decl) == PARM_DECL
7216           || TREE_CODE (decl) == VAR_DECL
7217           || TREE_CODE (decl) == FUNCTION_DECL
7218           || TREE_CODE (decl) == FIELD_DECL)
7219         TREE_DEPRECATED (decl) = 1;
7220       else
7221         warn = 1;
7222     }
7223   else if (TYPE_P (*node))
7224     {
7225       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7226         *node = build_variant_type_copy (*node);
7227       TREE_DEPRECATED (*node) = 1;
7228       type = *node;
7229     }
7230   else
7231     warn = 1;
7232
7233   if (warn)
7234     {
7235       *no_add_attrs = true;
7236       if (type && TYPE_NAME (type))
7237         {
7238           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7239             what = TYPE_NAME (*node);
7240           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7241                    && DECL_NAME (TYPE_NAME (type)))
7242             what = DECL_NAME (TYPE_NAME (type));
7243         }
7244       if (what)
7245         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7246       else
7247         warning (OPT_Wattributes, "%qE attribute ignored", name);
7248     }
7249
7250   return NULL_TREE;
7251 }
7252
7253 /* Handle a "vector_size" attribute; arguments as in
7254    struct attribute_spec.handler.  */
7255
7256 static tree
7257 handle_vector_size_attribute (tree *node, tree name, tree args,
7258                               int ARG_UNUSED (flags),
7259                               bool *no_add_attrs)
7260 {
7261   unsigned HOST_WIDE_INT vecsize, nunits;
7262   enum machine_mode orig_mode;
7263   tree type = *node, new_type, size;
7264
7265   *no_add_attrs = true;
7266
7267   size = TREE_VALUE (args);
7268
7269   if (!host_integerp (size, 1))
7270     {
7271       warning (OPT_Wattributes, "%qE attribute ignored", name);
7272       return NULL_TREE;
7273     }
7274
7275   /* Get the vector size (in bytes).  */
7276   vecsize = tree_low_cst (size, 1);
7277
7278   /* We need to provide for vector pointers, vector arrays, and
7279      functions returning vectors.  For example:
7280
7281        __attribute__((vector_size(16))) short *foo;
7282
7283      In this case, the mode is SI, but the type being modified is
7284      HI, so we need to look further.  */
7285
7286   while (POINTER_TYPE_P (type)
7287          || TREE_CODE (type) == FUNCTION_TYPE
7288          || TREE_CODE (type) == METHOD_TYPE
7289          || TREE_CODE (type) == ARRAY_TYPE
7290          || TREE_CODE (type) == OFFSET_TYPE)
7291     type = TREE_TYPE (type);
7292
7293   /* Get the mode of the type being modified.  */
7294   orig_mode = TYPE_MODE (type);
7295
7296   if ((!INTEGRAL_TYPE_P (type)
7297        && !SCALAR_FLOAT_TYPE_P (type)
7298        && !FIXED_POINT_TYPE_P (type))
7299       || (!SCALAR_FLOAT_MODE_P (orig_mode)
7300           && GET_MODE_CLASS (orig_mode) != MODE_INT
7301           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7302       || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7303       || TREE_CODE (type) == BOOLEAN_TYPE)
7304     {
7305       error ("invalid vector type for attribute %qE", name);
7306       return NULL_TREE;
7307     }
7308
7309   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7310     {
7311       error ("vector size not an integral multiple of component size");
7312       return NULL;
7313     }
7314
7315   if (vecsize == 0)
7316     {
7317       error ("zero vector size");
7318       return NULL;
7319     }
7320
7321   /* Calculate how many units fit in the vector.  */
7322   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7323   if (nunits & (nunits - 1))
7324     {
7325       error ("number of components of the vector not a power of two");
7326       return NULL_TREE;
7327     }
7328
7329   new_type = build_vector_type (type, nunits);
7330
7331   /* Build back pointers if needed.  */
7332   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7333
7334   return NULL_TREE;
7335 }
7336
7337 /* Handle the "nonnull" attribute.  */
7338 static tree
7339 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7340                           tree args, int ARG_UNUSED (flags),
7341                           bool *no_add_attrs)
7342 {
7343   tree type = *node;
7344   unsigned HOST_WIDE_INT attr_arg_num;
7345
7346   /* If no arguments are specified, all pointer arguments should be
7347      non-null.  Verify a full prototype is given so that the arguments
7348      will have the correct types when we actually check them later.  */
7349   if (!args)
7350     {
7351       if (!TYPE_ARG_TYPES (type))
7352         {
7353           error ("nonnull attribute without arguments on a non-prototype");
7354           *no_add_attrs = true;
7355         }
7356       return NULL_TREE;
7357     }
7358
7359   /* Argument list specified.  Verify that each argument number references
7360      a pointer argument.  */
7361   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7362     {
7363       tree argument;
7364       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7365
7366       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7367         {
7368           error ("nonnull argument has invalid operand number (argument %lu)",
7369                  (unsigned long) attr_arg_num);
7370           *no_add_attrs = true;
7371           return NULL_TREE;
7372         }
7373
7374       argument = TYPE_ARG_TYPES (type);
7375       if (argument)
7376         {
7377           for (ck_num = 1; ; ck_num++)
7378             {
7379               if (!argument || ck_num == arg_num)
7380                 break;
7381               argument = TREE_CHAIN (argument);
7382             }
7383
7384           if (!argument
7385               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7386             {
7387               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7388                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
7389               *no_add_attrs = true;
7390               return NULL_TREE;
7391             }
7392
7393           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7394             {
7395               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7396                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
7397               *no_add_attrs = true;
7398               return NULL_TREE;
7399             }
7400         }
7401     }
7402
7403   return NULL_TREE;
7404 }
7405
7406 /* Check the argument list of a function call for null in argument slots
7407    that are marked as requiring a non-null pointer argument.  The NARGS
7408    arguments are passed in the array ARGARRAY.
7409 */
7410
7411 static void
7412 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7413 {
7414   tree a, args;
7415   int i;
7416
7417   for (a = attrs; a; a = TREE_CHAIN (a))
7418     {
7419       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7420         {
7421           args = TREE_VALUE (a);
7422
7423           /* Walk the argument list.  If we encounter an argument number we
7424              should check for non-null, do it.  If the attribute has no args,
7425              then every pointer argument is checked (in which case the check
7426              for pointer type is done in check_nonnull_arg).  */
7427           for (i = 0; i < nargs; i++)
7428             {
7429               if (!args || nonnull_check_p (args, i + 1))
7430                 check_function_arguments_recurse (check_nonnull_arg, NULL,
7431                                                   argarray[i],
7432                                                   i + 1);
7433             }
7434         }
7435     }
7436 }
7437
7438 /* Check that the Nth argument of a function call (counting backwards
7439    from the end) is a (pointer)0.  The NARGS arguments are passed in the
7440    array ARGARRAY.  */
7441
7442 static void
7443 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7444 {
7445   tree attr = lookup_attribute ("sentinel", attrs);
7446
7447   if (attr)
7448     {
7449       int len = 0;
7450       int pos = 0;
7451       tree sentinel;
7452
7453       /* Skip over the named arguments.  */
7454       while (typelist && len < nargs)
7455         {
7456           typelist = TREE_CHAIN (typelist);
7457           len++;
7458         }
7459
7460       if (TREE_VALUE (attr))
7461         {
7462           tree p = TREE_VALUE (TREE_VALUE (attr));
7463           pos = TREE_INT_CST_LOW (p);
7464         }
7465
7466       /* The sentinel must be one of the varargs, i.e.
7467          in position >= the number of fixed arguments.  */
7468       if ((nargs - 1 - pos) < len)
7469         {
7470           warning (OPT_Wformat,
7471                    "not enough variable arguments to fit a sentinel");
7472           return;
7473         }
7474
7475       /* Validate the sentinel.  */
7476       sentinel = argarray[nargs - 1 - pos];
7477       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7478            || !integer_zerop (sentinel))
7479           /* Although __null (in C++) is only an integer we allow it
7480              nevertheless, as we are guaranteed that it's exactly
7481              as wide as a pointer, and we don't want to force
7482              users to cast the NULL they have written there.
7483              We warn with -Wstrict-null-sentinel, though.  */
7484           && (warn_strict_null_sentinel || null_node != sentinel))
7485         warning (OPT_Wformat, "missing sentinel in function call");
7486     }
7487 }
7488
7489 /* Helper for check_function_nonnull; given a list of operands which
7490    must be non-null in ARGS, determine if operand PARAM_NUM should be
7491    checked.  */
7492
7493 static bool
7494 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7495 {
7496   unsigned HOST_WIDE_INT arg_num = 0;
7497
7498   for (; args; args = TREE_CHAIN (args))
7499     {
7500       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7501
7502       gcc_assert (found);
7503
7504       if (arg_num == param_num)
7505         return true;
7506     }
7507   return false;
7508 }
7509
7510 /* Check that the function argument PARAM (which is operand number
7511    PARAM_NUM) is non-null.  This is called by check_function_nonnull
7512    via check_function_arguments_recurse.  */
7513
7514 static void
7515 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7516                    unsigned HOST_WIDE_INT param_num)
7517 {
7518   /* Just skip checking the argument if it's not a pointer.  This can
7519      happen if the "nonnull" attribute was given without an operand
7520      list (which means to check every pointer argument).  */
7521
7522   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7523     return;
7524
7525   if (integer_zerop (param))
7526     warning (OPT_Wnonnull, "null argument where non-null required "
7527              "(argument %lu)", (unsigned long) param_num);
7528 }
7529
7530 /* Helper for nonnull attribute handling; fetch the operand number
7531    from the attribute argument list.  */
7532
7533 static bool
7534 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7535 {
7536   /* Verify the arg number is a constant.  */
7537   if (TREE_CODE (arg_num_expr) != INTEGER_CST
7538       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7539     return false;
7540
7541   *valp = TREE_INT_CST_LOW (arg_num_expr);
7542   return true;
7543 }
7544
7545 /* Handle a "nothrow" attribute; arguments as in
7546    struct attribute_spec.handler.  */
7547
7548 static tree
7549 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7550                           int ARG_UNUSED (flags), bool *no_add_attrs)
7551 {
7552   if (TREE_CODE (*node) == FUNCTION_DECL)
7553     TREE_NOTHROW (*node) = 1;
7554   /* ??? TODO: Support types.  */
7555   else
7556     {
7557       warning (OPT_Wattributes, "%qE attribute ignored", name);
7558       *no_add_attrs = true;
7559     }
7560
7561   return NULL_TREE;
7562 }
7563
7564 /* Handle a "cleanup" attribute; arguments as in
7565    struct attribute_spec.handler.  */
7566
7567 static tree
7568 handle_cleanup_attribute (tree *node, tree name, tree args,
7569                           int ARG_UNUSED (flags), bool *no_add_attrs)
7570 {
7571   tree decl = *node;
7572   tree cleanup_id, cleanup_decl;
7573
7574   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7575      for global destructors in C++.  This requires infrastructure that
7576      we don't have generically at the moment.  It's also not a feature
7577      we'd be missing too much, since we do have attribute constructor.  */
7578   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7579     {
7580       warning (OPT_Wattributes, "%qE attribute ignored", name);
7581       *no_add_attrs = true;
7582       return NULL_TREE;
7583     }
7584
7585   /* Verify that the argument is a function in scope.  */
7586   /* ??? We could support pointers to functions here as well, if
7587      that was considered desirable.  */
7588   cleanup_id = TREE_VALUE (args);
7589   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7590     {
7591       error ("cleanup argument not an identifier");
7592       *no_add_attrs = true;
7593       return NULL_TREE;
7594     }
7595   cleanup_decl = lookup_name (cleanup_id);
7596   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7597     {
7598       error ("cleanup argument not a function");
7599       *no_add_attrs = true;
7600       return NULL_TREE;
7601     }
7602
7603   /* That the function has proper type is checked with the
7604      eventual call to build_function_call.  */
7605
7606   return NULL_TREE;
7607 }
7608
7609 /* Handle a "warn_unused_result" attribute.  No special handling.  */
7610
7611 static tree
7612 handle_warn_unused_result_attribute (tree *node, tree name,
7613                                tree ARG_UNUSED (args),
7614                                int ARG_UNUSED (flags), bool *no_add_attrs)
7615 {
7616   /* Ignore the attribute for functions not returning any value.  */
7617   if (VOID_TYPE_P (TREE_TYPE (*node)))
7618     {
7619       warning (OPT_Wattributes, "%qE attribute ignored", name);
7620       *no_add_attrs = true;
7621     }
7622
7623   return NULL_TREE;
7624 }
7625
7626 /* Handle a "sentinel" attribute.  */
7627
7628 static tree
7629 handle_sentinel_attribute (tree *node, tree name, tree args,
7630                            int ARG_UNUSED (flags), bool *no_add_attrs)
7631 {
7632   tree params = TYPE_ARG_TYPES (*node);
7633
7634   if (!params)
7635     {
7636       warning (OPT_Wattributes,
7637                "%qE attribute requires prototypes with named arguments", name);
7638       *no_add_attrs = true;
7639     }
7640   else
7641     {
7642       while (TREE_CHAIN (params))
7643         params = TREE_CHAIN (params);
7644
7645       if (VOID_TYPE_P (TREE_VALUE (params)))
7646         {
7647           warning (OPT_Wattributes,
7648                    "%qE attribute only applies to variadic functions", name);
7649           *no_add_attrs = true;
7650         }
7651     }
7652
7653   if (args)
7654     {
7655       tree position = TREE_VALUE (args);
7656
7657       if (TREE_CODE (position) != INTEGER_CST)
7658         {
7659           warning (OPT_Wattributes,
7660                    "requested position is not an integer constant");
7661           *no_add_attrs = true;
7662         }
7663       else
7664         {
7665           if (tree_int_cst_lt (position, integer_zero_node))
7666             {
7667               warning (OPT_Wattributes,
7668                        "requested position is less than zero");
7669               *no_add_attrs = true;
7670             }
7671         }
7672     }
7673
7674   return NULL_TREE;
7675 }
7676
7677 /* Handle a "type_generic" attribute.  */
7678
7679 static tree
7680 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7681                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7682                                bool * ARG_UNUSED (no_add_attrs))
7683 {
7684   tree params;
7685
7686   /* Ensure we have a function type.  */
7687   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7688
7689   params = TYPE_ARG_TYPES (*node);
7690   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7691     params = TREE_CHAIN (params);
7692
7693   /* Ensure we have a variadic function.  */
7694   gcc_assert (!params);
7695
7696   return NULL_TREE;
7697 }
7698
7699 /* Handle a "target" attribute.  */
7700
7701 static tree
7702 handle_target_attribute (tree *node, tree name, tree args, int flags,
7703                          bool *no_add_attrs)
7704 {
7705   /* Ensure we have a function type.  */
7706   if (TREE_CODE (*node) != FUNCTION_DECL)
7707     {
7708       warning (OPT_Wattributes, "%qE attribute ignored", name);
7709       *no_add_attrs = true;
7710     }
7711   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7712                                                       flags))
7713     *no_add_attrs = true;
7714
7715   return NULL_TREE;
7716 }
7717
7718 /* Arguments being collected for optimization.  */
7719 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
7720 DEF_VEC_P(const_char_p);
7721 DEF_VEC_ALLOC_P(const_char_p, gc);
7722 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7723
7724
7725 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7726    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
7727    false for #pragma GCC optimize.  */
7728
7729 bool
7730 parse_optimize_options (tree args, bool attr_p)
7731 {
7732   bool ret = true;
7733   unsigned opt_argc;
7734   unsigned i;
7735   int saved_flag_strict_aliasing;
7736   const char **opt_argv;
7737   tree ap;
7738
7739   /* Build up argv vector.  Just in case the string is stored away, use garbage
7740      collected strings.  */
7741   VEC_truncate (const_char_p, optimize_args, 0);
7742   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7743
7744   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7745     {
7746       tree value = TREE_VALUE (ap);
7747
7748       if (TREE_CODE (value) == INTEGER_CST)
7749         {
7750           char buffer[20];
7751           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7752           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7753         }
7754
7755       else if (TREE_CODE (value) == STRING_CST)
7756         {
7757           /* Split string into multiple substrings.  */
7758           size_t len = TREE_STRING_LENGTH (value);
7759           char *p = ASTRDUP (TREE_STRING_POINTER (value));
7760           char *end = p + len;
7761           char *comma;
7762           char *next_p = p;
7763
7764           while (next_p != NULL)
7765             {
7766               size_t len2;
7767               char *q, *r;
7768
7769               p = next_p;
7770               comma = strchr (p, ',');
7771               if (comma)
7772                 {
7773                   len2 = comma - p;
7774                   *comma = '\0';
7775                   next_p = comma+1;
7776                 }
7777               else
7778                 {
7779                   len2 = end - p;
7780                   next_p = NULL;
7781                 }
7782
7783               r = q = (char *) ggc_alloc (len2 + 3);
7784
7785               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7786                  options.  */
7787               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7788                 {
7789                   ret = false;
7790                   if (attr_p)
7791                     warning (OPT_Wattributes,
7792                              "Bad option %s to optimize attribute.", p);
7793                   else
7794                     warning (OPT_Wpragmas,
7795                              "Bad option %s to pragma attribute", p);
7796                   continue;
7797                 }
7798
7799               if (*p != '-')
7800                 {
7801                   *r++ = '-';
7802
7803                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7804                      itself is -Os, and any other switch begins with a -f.  */
7805                   if ((*p >= '0' && *p <= '9')
7806                       || (p[0] == 's' && p[1] == '\0'))
7807                     *r++ = 'O';
7808                   else if (*p != 'O')
7809                     *r++ = 'f';
7810                 }
7811
7812               memcpy (r, p, len2);
7813               r[len2] = '\0';
7814               VEC_safe_push (const_char_p, gc, optimize_args, q);
7815             }
7816
7817         }
7818     }
7819
7820   opt_argc = VEC_length (const_char_p, optimize_args);
7821   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7822
7823   for (i = 1; i < opt_argc; i++)
7824     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7825
7826   saved_flag_strict_aliasing = flag_strict_aliasing;
7827
7828   /* Now parse the options.  */
7829   decode_options (opt_argc, opt_argv);
7830
7831   /* Don't allow changing -fstrict-aliasing.  */
7832   flag_strict_aliasing = saved_flag_strict_aliasing;
7833
7834   VEC_truncate (const_char_p, optimize_args, 0);
7835   return ret;
7836 }
7837
7838 /* For handling "optimize" attribute. arguments as in
7839    struct attribute_spec.handler.  */
7840
7841 static tree
7842 handle_optimize_attribute (tree *node, tree name, tree args,
7843                            int ARG_UNUSED (flags), bool *no_add_attrs)
7844 {
7845   /* Ensure we have a function type.  */
7846   if (TREE_CODE (*node) != FUNCTION_DECL)
7847     {
7848       warning (OPT_Wattributes, "%qE attribute ignored", name);
7849       *no_add_attrs = true;
7850     }
7851   else
7852     {
7853       struct cl_optimization cur_opts;
7854       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7855
7856       /* Save current options.  */
7857       cl_optimization_save (&cur_opts);
7858
7859       /* If we previously had some optimization options, use them as the
7860          default.  */
7861       if (old_opts)
7862         cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7863
7864       /* Parse options, and update the vector.  */
7865       parse_optimize_options (args, true);
7866       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7867         = build_optimization_node ();
7868
7869       /* Restore current options.  */
7870       cl_optimization_restore (&cur_opts);
7871     }
7872
7873   return NULL_TREE;
7874 }
7875 \f
7876 /* Check for valid arguments being passed to a function.
7877    ATTRS is a list of attributes.  There are NARGS arguments in the array
7878    ARGARRAY.  TYPELIST is the list of argument types for the function.
7879  */
7880 void
7881 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7882 {
7883   /* Check for null being passed in a pointer argument that must be
7884      non-null.  We also need to do this if format checking is enabled.  */
7885
7886   if (warn_nonnull)
7887     check_function_nonnull (attrs, nargs, argarray);
7888
7889   /* Check for errors in format strings.  */
7890
7891   if (warn_format || warn_missing_format_attribute)
7892     check_function_format (attrs, nargs, argarray);
7893
7894   if (warn_format)
7895     check_function_sentinel (attrs, nargs, argarray, typelist);
7896 }
7897
7898 /* Generic argument checking recursion routine.  PARAM is the argument to
7899    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
7900    once the argument is resolved.  CTX is context for the callback.  */
7901 void
7902 check_function_arguments_recurse (void (*callback)
7903                                   (void *, tree, unsigned HOST_WIDE_INT),
7904                                   void *ctx, tree param,
7905                                   unsigned HOST_WIDE_INT param_num)
7906 {
7907   if (CONVERT_EXPR_P (param)
7908       && (TYPE_PRECISION (TREE_TYPE (param))
7909           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7910     {
7911       /* Strip coercion.  */
7912       check_function_arguments_recurse (callback, ctx,
7913                                         TREE_OPERAND (param, 0), param_num);
7914       return;
7915     }
7916
7917   if (TREE_CODE (param) == CALL_EXPR)
7918     {
7919       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7920       tree attrs;
7921       bool found_format_arg = false;
7922
7923       /* See if this is a call to a known internationalization function
7924          that modifies a format arg.  Such a function may have multiple
7925          format_arg attributes (for example, ngettext).  */
7926
7927       for (attrs = TYPE_ATTRIBUTES (type);
7928            attrs;
7929            attrs = TREE_CHAIN (attrs))
7930         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7931           {
7932             tree inner_arg;
7933             tree format_num_expr;
7934             int format_num;
7935             int i;
7936             call_expr_arg_iterator iter;
7937
7938             /* Extract the argument number, which was previously checked
7939                to be valid.  */
7940             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7941
7942             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7943                         && !TREE_INT_CST_HIGH (format_num_expr));
7944
7945             format_num = TREE_INT_CST_LOW (format_num_expr);
7946
7947             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7948                  inner_arg != 0;
7949                  inner_arg = next_call_expr_arg (&iter), i++)
7950               if (i == format_num)
7951                 {
7952                   check_function_arguments_recurse (callback, ctx,
7953                                                     inner_arg, param_num);
7954                   found_format_arg = true;
7955                   break;
7956                 }
7957           }
7958
7959       /* If we found a format_arg attribute and did a recursive check,
7960          we are done with checking this argument.  Otherwise, we continue
7961          and this will be considered a non-literal.  */
7962       if (found_format_arg)
7963         return;
7964     }
7965
7966   if (TREE_CODE (param) == COND_EXPR)
7967     {
7968       /* Check both halves of the conditional expression.  */
7969       check_function_arguments_recurse (callback, ctx,
7970                                         TREE_OPERAND (param, 1), param_num);
7971       check_function_arguments_recurse (callback, ctx,
7972                                         TREE_OPERAND (param, 2), param_num);
7973       return;
7974     }
7975
7976   (*callback) (ctx, param, param_num);
7977 }
7978
7979 /* Checks the number of arguments NARGS against the required number
7980    REQUIRED and issues an error if there is a mismatch.  Returns true
7981    if the number of arguments is correct, otherwise false.  */
7982
7983 static bool
7984 validate_nargs (tree fndecl, int nargs, int required)
7985 {
7986   if (nargs < required)
7987     {
7988       error ("not enough arguments to function %qE", fndecl);
7989       return false;
7990     }
7991   else if (nargs > required)
7992     {
7993       error ("too many arguments to function %qE", fndecl);
7994       return false;
7995     }
7996   return true;
7997 }
7998
7999 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8000    Returns false if there was an error, otherwise true.  */
8001
8002 bool
8003 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8004 {
8005   if (!DECL_BUILT_IN (fndecl)
8006       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8007     return true;
8008
8009   switch (DECL_FUNCTION_CODE (fndecl))
8010     {
8011     case BUILT_IN_CONSTANT_P:
8012       return validate_nargs (fndecl, nargs, 1);
8013
8014     case BUILT_IN_ISFINITE:
8015     case BUILT_IN_ISINF:
8016     case BUILT_IN_ISINF_SIGN:
8017     case BUILT_IN_ISNAN:
8018     case BUILT_IN_ISNORMAL:
8019       if (validate_nargs (fndecl, nargs, 1))
8020         {
8021           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8022             {
8023               error ("non-floating-point argument in call to "
8024                      "function %qE", fndecl);
8025               return false;
8026             }
8027           return true;
8028         }
8029       return false;
8030
8031     case BUILT_IN_ISGREATER:
8032     case BUILT_IN_ISGREATEREQUAL:
8033     case BUILT_IN_ISLESS:
8034     case BUILT_IN_ISLESSEQUAL:
8035     case BUILT_IN_ISLESSGREATER:
8036     case BUILT_IN_ISUNORDERED:
8037       if (validate_nargs (fndecl, nargs, 2))
8038         {
8039           enum tree_code code0, code1;
8040           code0 = TREE_CODE (TREE_TYPE (args[0]));
8041           code1 = TREE_CODE (TREE_TYPE (args[1]));
8042           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8043                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8044                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8045             {
8046               error ("non-floating-point arguments in call to "
8047                      "function %qE", fndecl);
8048               return false;
8049             }
8050           return true;
8051         }
8052       return false;
8053
8054     case BUILT_IN_FPCLASSIFY:
8055       if (validate_nargs (fndecl, nargs, 6))
8056         {
8057           unsigned i;
8058
8059           for (i=0; i<5; i++)
8060             if (TREE_CODE (args[i]) != INTEGER_CST)
8061               {
8062                 error ("non-const integer argument %u in call to function %qE",
8063                        i+1, fndecl);
8064                 return false;
8065               }
8066
8067           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8068             {
8069               error ("non-floating-point argument in call to function %qE",
8070                      fndecl);
8071               return false;
8072             }
8073           return true;
8074         }
8075       return false;
8076
8077     default:
8078       return true;
8079     }
8080 }
8081
8082 /* Function to help qsort sort FIELD_DECLs by name order.  */
8083
8084 int
8085 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   if (DECL_NAME (*x) < DECL_NAME (*y))
8098     return -1;
8099   return 1;
8100 }
8101
8102 static struct {
8103   gt_pointer_operator new_value;
8104   void *cookie;
8105 } resort_data;
8106
8107 /* This routine compares two fields like field_decl_cmp but using the
8108 pointer operator in resort_data.  */
8109
8110 static int
8111 resort_field_decl_cmp (const void *x_p, const void *y_p)
8112 {
8113   const tree *const x = (const tree *const) x_p;
8114   const tree *const y = (const tree *const) y_p;
8115
8116   if (DECL_NAME (*x) == DECL_NAME (*y))
8117     /* A nontype is "greater" than a type.  */
8118     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8119   if (DECL_NAME (*x) == NULL_TREE)
8120     return -1;
8121   if (DECL_NAME (*y) == NULL_TREE)
8122     return 1;
8123   {
8124     tree d1 = DECL_NAME (*x);
8125     tree d2 = DECL_NAME (*y);
8126     resort_data.new_value (&d1, resort_data.cookie);
8127     resort_data.new_value (&d2, resort_data.cookie);
8128     if (d1 < d2)
8129       return -1;
8130   }
8131   return 1;
8132 }
8133
8134 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
8135
8136 void
8137 resort_sorted_fields (void *obj,
8138                       void * ARG_UNUSED (orig_obj),
8139                       gt_pointer_operator new_value,
8140                       void *cookie)
8141 {
8142   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8143   resort_data.new_value = new_value;
8144   resort_data.cookie = cookie;
8145   qsort (&sf->elts[0], sf->len, sizeof (tree),
8146          resort_field_decl_cmp);
8147 }
8148
8149 /* Subroutine of c_parse_error.
8150    Return the result of concatenating LHS and RHS. RHS is really
8151    a string literal, its first character is indicated by RHS_START and
8152    RHS_SIZE is its length (including the terminating NUL character).
8153
8154    The caller is responsible for deleting the returned pointer.  */
8155
8156 static char *
8157 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8158 {
8159   const int lhs_size = strlen (lhs);
8160   char *result = XNEWVEC (char, lhs_size + rhs_size);
8161   strncpy (result, lhs, lhs_size);
8162   strncpy (result + lhs_size, rhs_start, rhs_size);
8163   return result;
8164 }
8165
8166 /* Issue the error given by GMSGID, indicating that it occurred before
8167    TOKEN, which had the associated VALUE.  */
8168
8169 void
8170 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
8171 {
8172 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8173
8174   char *message = NULL;
8175
8176   if (token == CPP_EOF)
8177     message = catenate_messages (gmsgid, " at end of input");
8178   else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
8179            || token == CPP_CHAR32)
8180     {
8181       unsigned int val = TREE_INT_CST_LOW (value);
8182       const char *prefix;
8183
8184       switch (token)
8185         {
8186         default:
8187           prefix = "";
8188           break;
8189         case CPP_WCHAR:
8190           prefix = "L";
8191           break;
8192         case CPP_CHAR16:
8193           prefix = "u";
8194           break;
8195         case CPP_CHAR32:
8196           prefix = "U";
8197           break;
8198         }
8199
8200       if (val <= UCHAR_MAX && ISGRAPH (val))
8201         message = catenate_messages (gmsgid, " before %s'%c'");
8202       else
8203         message = catenate_messages (gmsgid, " before %s'\\x%x'");
8204
8205       error (message, prefix, val);
8206       free (message);
8207       message = NULL;
8208     }
8209   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
8210            || token == CPP_STRING32)
8211     message = catenate_messages (gmsgid, " before string constant");
8212   else if (token == CPP_NUMBER)
8213     message = catenate_messages (gmsgid, " before numeric constant");
8214   else if (token == CPP_NAME)
8215     {
8216       message = catenate_messages (gmsgid, " before %qE");
8217       error (message, value);
8218       free (message);
8219       message = NULL;
8220     }
8221   else if (token == CPP_PRAGMA)
8222     message = catenate_messages (gmsgid, " before %<#pragma%>");
8223   else if (token == CPP_PRAGMA_EOL)
8224     message = catenate_messages (gmsgid, " before end of line");
8225   else if (token < N_TTYPES)
8226     {
8227       message = catenate_messages (gmsgid, " before %qs token");
8228       error (message, cpp_type2name (token));
8229       free (message);
8230       message = NULL;
8231     }
8232   else
8233     error (gmsgid);
8234
8235   if (message)
8236     {
8237       error (message);
8238       free (message);
8239     }
8240 #undef catenate_messages
8241 }
8242
8243 /* Callback from cpp_error for PFILE to print diagnostics from the
8244    preprocessor.  The diagnostic is of type LEVEL, at location
8245    LOCATION unless this is after lexing and the compiler's location
8246    should be used instead, with column number possibly overridden by
8247    COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8248    the arguments.  Returns true if a diagnostic was emitted, false
8249    otherwise.  */
8250
8251 bool
8252 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
8253              location_t location, unsigned int column_override,
8254              const char *msg, va_list *ap)
8255 {
8256   diagnostic_info diagnostic;
8257   diagnostic_t dlevel;
8258   int save_warn_system_headers = warn_system_headers;
8259   bool ret;
8260
8261   switch (level)
8262     {
8263     case CPP_DL_WARNING_SYSHDR:
8264       if (flag_no_output)
8265         return false;
8266       warn_system_headers = 1;
8267       /* Fall through.  */
8268     case CPP_DL_WARNING:
8269       if (flag_no_output)
8270         return false;
8271       dlevel = DK_WARNING;
8272       break;
8273     case CPP_DL_PEDWARN:
8274       if (flag_no_output && !flag_pedantic_errors)
8275         return false;
8276       dlevel = DK_PEDWARN;
8277       break;
8278     case CPP_DL_ERROR:
8279       dlevel = DK_ERROR;
8280       break;
8281     case CPP_DL_ICE:
8282       dlevel = DK_ICE;
8283       break;
8284     case CPP_DL_NOTE:
8285       dlevel = DK_NOTE;
8286       break;
8287     case CPP_DL_FATAL:
8288       dlevel = DK_FATAL;
8289       break;
8290     default:
8291       gcc_unreachable ();
8292     }
8293   if (done_lexing)
8294     location = input_location;
8295   diagnostic_set_info_translated (&diagnostic, msg, ap,
8296                                   location, dlevel);
8297   if (column_override)
8298     diagnostic_override_column (&diagnostic, column_override);
8299   ret = report_diagnostic (&diagnostic);
8300   if (level == CPP_DL_WARNING_SYSHDR)
8301     warn_system_headers = save_warn_system_headers;
8302   return ret;
8303 }
8304
8305 /* Walk a gimplified function and warn for functions whose return value is
8306    ignored and attribute((warn_unused_result)) is set.  This is done before
8307    inlining, so we don't have to worry about that.  */
8308
8309 void
8310 c_warn_unused_result (gimple_seq seq)
8311 {
8312   tree fdecl, ftype;
8313   gimple_stmt_iterator i;
8314
8315   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8316     {
8317       gimple g = gsi_stmt (i);
8318
8319       switch (gimple_code (g))
8320         {
8321         case GIMPLE_BIND:
8322           c_warn_unused_result (gimple_bind_body (g));
8323           break;
8324         case GIMPLE_TRY:
8325           c_warn_unused_result (gimple_try_eval (g));
8326           c_warn_unused_result (gimple_try_cleanup (g));
8327           break;
8328         case GIMPLE_CATCH:
8329           c_warn_unused_result (gimple_catch_handler (g));
8330           break;
8331         case GIMPLE_EH_FILTER:
8332           c_warn_unused_result (gimple_eh_filter_failure (g));
8333           break;
8334
8335         case GIMPLE_CALL:
8336           if (gimple_call_lhs (g))
8337             break;
8338
8339           /* This is a naked call, as opposed to a GIMPLE_CALL with an
8340              LHS.  All calls whose value is ignored should be
8341              represented like this.  Look for the attribute.  */
8342           fdecl = gimple_call_fndecl (g);
8343           ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
8344
8345           if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8346             {
8347               location_t loc = gimple_location (g);
8348
8349               if (fdecl)
8350                 warning (0, "%Hignoring return value of %qD, "
8351                          "declared with attribute warn_unused_result",
8352                          &loc, fdecl);
8353               else
8354                 warning (0, "%Hignoring return value of function "
8355                          "declared with attribute warn_unused_result",
8356                          &loc);
8357             }
8358           break;
8359
8360         default:
8361           /* Not a container, not a call, or a call whose value is used.  */
8362           break;
8363         }
8364     }
8365 }
8366
8367 /* Convert a character from the host to the target execution character
8368    set.  cpplib handles this, mostly.  */
8369
8370 HOST_WIDE_INT
8371 c_common_to_target_charset (HOST_WIDE_INT c)
8372 {
8373   /* Character constants in GCC proper are sign-extended under -fsigned-char,
8374      zero-extended under -fno-signed-char.  cpplib insists that characters
8375      and character constants are always unsigned.  Hence we must convert
8376      back and forth.  */
8377   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8378
8379   uc = cpp_host_to_exec_charset (parse_in, uc);
8380
8381   if (flag_signed_char)
8382     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8383                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8384   else
8385     return uc;
8386 }
8387
8388 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
8389    component references, with STOP_REF, or alternatively an INDIRECT_REF of
8390    NULL, at the bottom; much like the traditional rendering of offsetof as a
8391    macro.  Returns the folded and properly cast result.  */
8392
8393 static tree
8394 fold_offsetof_1 (tree expr, tree stop_ref)
8395 {
8396   enum tree_code code = PLUS_EXPR;
8397   tree base, off, t;
8398
8399   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8400     return size_zero_node;
8401
8402   switch (TREE_CODE (expr))
8403     {
8404     case ERROR_MARK:
8405       return expr;
8406
8407     case VAR_DECL:
8408       error ("cannot apply %<offsetof%> to static data member %qD", expr);
8409       return error_mark_node;
8410
8411     case CALL_EXPR:
8412     case TARGET_EXPR:
8413       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8414       return error_mark_node;
8415
8416     case INTEGER_CST:
8417       gcc_assert (integer_zerop (expr));
8418       return size_zero_node;
8419
8420     case NOP_EXPR:
8421     case INDIRECT_REF:
8422       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8423       gcc_assert (base == error_mark_node || base == size_zero_node);
8424       return base;
8425
8426     case COMPONENT_REF:
8427       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8428       if (base == error_mark_node)
8429         return base;
8430
8431       t = TREE_OPERAND (expr, 1);
8432       if (DECL_C_BIT_FIELD (t))
8433         {
8434           error ("attempt to take address of bit-field structure "
8435                  "member %qD", t);
8436           return error_mark_node;
8437         }
8438       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
8439                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
8440                                   / BITS_PER_UNIT));
8441       break;
8442
8443     case ARRAY_REF:
8444       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8445       if (base == error_mark_node)
8446         return base;
8447
8448       t = TREE_OPERAND (expr, 1);
8449       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8450         {
8451           code = MINUS_EXPR;
8452           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
8453         }
8454       t = convert (sizetype, t);
8455       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8456       break;
8457
8458     case COMPOUND_EXPR:
8459       /* Handle static members of volatile structs.  */
8460       t = TREE_OPERAND (expr, 1);
8461       gcc_assert (TREE_CODE (t) == VAR_DECL);
8462       return fold_offsetof_1 (t, stop_ref);
8463
8464     default:
8465       gcc_unreachable ();
8466     }
8467
8468   return size_binop (code, base, off);
8469 }
8470
8471 tree
8472 fold_offsetof (tree expr, tree stop_ref)
8473 {
8474   /* Convert back from the internal sizetype to size_t.  */
8475   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8476 }
8477
8478 /* Print an error message for an invalid lvalue.  USE says
8479    how the lvalue is being used and so selects the error message.  */
8480
8481 void
8482 lvalue_error (enum lvalue_use use)
8483 {
8484   switch (use)
8485     {
8486     case lv_assign:
8487       error ("lvalue required as left operand of assignment");
8488       break;
8489     case lv_increment:
8490       error ("lvalue required as increment operand");
8491       break;
8492     case lv_decrement:
8493       error ("lvalue required as decrement operand");
8494       break;
8495     case lv_addressof:
8496       error ("lvalue required as unary %<&%> operand");
8497       break;
8498     case lv_asm:
8499       error ("lvalue required in asm statement");
8500       break;
8501     default:
8502       gcc_unreachable ();
8503     }
8504 }
8505 \f
8506 /* *PTYPE is an incomplete array.  Complete it with a domain based on
8507    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8508    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8509    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
8510
8511 int
8512 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8513 {
8514   tree maxindex, type, main_type, elt, unqual_elt;
8515   int failure = 0, quals;
8516   hashval_t hashcode = 0;
8517
8518   maxindex = size_zero_node;
8519   if (initial_value)
8520     {
8521       if (TREE_CODE (initial_value) == STRING_CST)
8522         {
8523           int eltsize
8524             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8525           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8526         }
8527       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8528         {
8529           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8530
8531           if (VEC_empty (constructor_elt, v))
8532             {
8533               if (pedantic)
8534                 failure = 3;
8535               maxindex = integer_minus_one_node;
8536             }
8537           else
8538             {
8539               tree curindex;
8540               unsigned HOST_WIDE_INT cnt;
8541               constructor_elt *ce;
8542               bool fold_p = false;
8543
8544               if (VEC_index (constructor_elt, v, 0)->index)
8545                 maxindex = fold_convert (sizetype,
8546                                          VEC_index (constructor_elt,
8547                                                     v, 0)->index);
8548               curindex = maxindex;
8549
8550               for (cnt = 1;
8551                    VEC_iterate (constructor_elt, v, cnt, ce);
8552                    cnt++)
8553                 {
8554                   bool curfold_p = false;
8555                   if (ce->index)
8556                     curindex = ce->index, curfold_p = true;
8557                   else
8558                     {
8559                       if (fold_p)
8560                         curindex = fold_convert (sizetype, curindex);
8561                       curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
8562                     }
8563                   if (tree_int_cst_lt (maxindex, curindex))
8564                     maxindex = curindex, fold_p = curfold_p;
8565                 }
8566                if (fold_p)
8567                  maxindex = fold_convert (sizetype, maxindex);
8568             }
8569         }
8570       else
8571         {
8572           /* Make an error message unless that happened already.  */
8573           if (initial_value != error_mark_node)
8574             failure = 1;
8575         }
8576     }
8577   else
8578     {
8579       failure = 2;
8580       if (!do_default)
8581         return failure;
8582     }
8583
8584   type = *ptype;
8585   elt = TREE_TYPE (type);
8586   quals = TYPE_QUALS (strip_array_types (elt));
8587   if (quals == 0)
8588     unqual_elt = elt;
8589   else
8590     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
8591
8592   /* Using build_distinct_type_copy and modifying things afterward instead
8593      of using build_array_type to create a new type preserves all of the
8594      TYPE_LANG_FLAG_? bits that the front end may have set.  */
8595   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8596   TREE_TYPE (main_type) = unqual_elt;
8597   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8598   layout_type (main_type);
8599
8600   /* Make sure we have the canonical MAIN_TYPE. */
8601   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8602   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8603                                     hashcode);
8604   main_type = type_hash_canon (hashcode, main_type);
8605
8606   /* Fix the canonical type.  */
8607   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8608       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8609     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8610   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8611            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8612                != TYPE_DOMAIN (main_type)))
8613     TYPE_CANONICAL (main_type)
8614       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8615                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8616   else
8617     TYPE_CANONICAL (main_type) = main_type;
8618
8619   if (quals == 0)
8620     type = main_type;
8621   else
8622     type = c_build_qualified_type (main_type, quals);
8623
8624   if (COMPLETE_TYPE_P (type)
8625       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8626       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8627     {
8628       error ("size of array is too large");
8629       /* If we proceed with the array type as it is, we'll eventually
8630          crash in tree_low_cst().  */
8631       type = error_mark_node;
8632     }
8633
8634   *ptype = type;
8635   return failure;
8636 }
8637
8638 \f
8639 /* Used to help initialize the builtin-types.def table.  When a type of
8640    the correct size doesn't exist, use error_mark_node instead of NULL.
8641    The later results in segfaults even when a decl using the type doesn't
8642    get invoked.  */
8643
8644 tree
8645 builtin_type_for_size (int size, bool unsignedp)
8646 {
8647   tree type = lang_hooks.types.type_for_size (size, unsignedp);
8648   return type ? type : error_mark_node;
8649 }
8650
8651 /* A helper function for resolve_overloaded_builtin in resolving the
8652    overloaded __sync_ builtins.  Returns a positive power of 2 if the
8653    first operand of PARAMS is a pointer to a supported data type.
8654    Returns 0 if an error is encountered.  */
8655
8656 static int
8657 sync_resolve_size (tree function, VEC(tree,gc) *params)
8658 {
8659   tree type;
8660   int size;
8661
8662   if (VEC_empty (tree, params))
8663     {
8664       error ("too few arguments to function %qE", function);
8665       return 0;
8666     }
8667
8668   type = TREE_TYPE (VEC_index (tree, params, 0));
8669   if (TREE_CODE (type) != POINTER_TYPE)
8670     goto incompatible;
8671
8672   type = TREE_TYPE (type);
8673   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8674     goto incompatible;
8675
8676   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8677   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8678     return size;
8679
8680  incompatible:
8681   error ("incompatible type for argument %d of %qE", 1, function);
8682   return 0;
8683 }
8684
8685 /* A helper function for resolve_overloaded_builtin.  Adds casts to
8686    PARAMS to make arguments match up with those of FUNCTION.  Drops
8687    the variadic arguments at the end.  Returns false if some error
8688    was encountered; true on success.  */
8689
8690 static bool
8691 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8692 {
8693   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8694   tree ptype;
8695   int number;
8696   unsigned int parmnum;
8697
8698   /* We've declared the implementation functions to use "volatile void *"
8699      as the pointer parameter, so we shouldn't get any complaints from the
8700      call to check_function_arguments what ever type the user used.  */
8701   arg_types = TREE_CHAIN (arg_types);
8702   ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8703   number = 2;
8704
8705   /* For the rest of the values, we need to cast these to FTYPE, so that we
8706      don't get warnings for passing pointer types, etc.  */
8707   parmnum = 0;
8708   while (arg_types != void_list_node)
8709     {
8710       tree val;
8711
8712       ++parmnum;
8713       if (VEC_length (tree, params) <= parmnum)
8714         {
8715           error ("too few arguments to function %qE", orig_function);
8716           return false;
8717         }
8718
8719       /* ??? Ideally for the first conversion we'd use convert_for_assignment
8720          so that we get warnings for anything that doesn't match the pointer
8721          type.  This isn't portable across the C and C++ front ends atm.  */
8722       val = VEC_index (tree, params, parmnum);
8723       val = convert (ptype, val);
8724       val = convert (TREE_VALUE (arg_types), val);
8725       VEC_replace (tree, params, parmnum, val);
8726
8727       arg_types = TREE_CHAIN (arg_types);
8728       number++;
8729     }
8730
8731   /* The definition of these primitives is variadic, with the remaining
8732      being "an optional list of variables protected by the memory barrier".
8733      No clue what that's supposed to mean, precisely, but we consider all
8734      call-clobbered variables to be protected so we're safe.  */
8735   VEC_truncate (tree, params, parmnum + 1);
8736
8737   return true;
8738 }
8739
8740 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
8741    RESULT to make it match the type of the first pointer argument in
8742    PARAMS.  */
8743
8744 static tree
8745 sync_resolve_return (tree first_param, tree result)
8746 {
8747   tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8748   ptype = TYPE_MAIN_VARIANT (ptype);
8749   return convert (ptype, result);
8750 }
8751
8752 /* Some builtin functions are placeholders for other expressions.  This
8753    function should be called immediately after parsing the call expression
8754    before surrounding code has committed to the type of the expression.
8755
8756    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8757    PARAMS is the argument list for the call.  The return value is non-null
8758    when expansion is complete, and null if normal processing should
8759    continue.  */
8760
8761 tree
8762 resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
8763 {
8764   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8765   switch (DECL_BUILT_IN_CLASS (function))
8766     {
8767     case BUILT_IN_NORMAL:
8768       break;
8769     case BUILT_IN_MD:
8770       if (targetm.resolve_overloaded_builtin)
8771         return targetm.resolve_overloaded_builtin (function, params);
8772       else
8773         return NULL_TREE;
8774     default:
8775       return NULL_TREE;
8776     }
8777
8778   /* Handle BUILT_IN_NORMAL here.  */
8779   switch (orig_code)
8780     {
8781     case BUILT_IN_FETCH_AND_ADD_N:
8782     case BUILT_IN_FETCH_AND_SUB_N:
8783     case BUILT_IN_FETCH_AND_OR_N:
8784     case BUILT_IN_FETCH_AND_AND_N:
8785     case BUILT_IN_FETCH_AND_XOR_N:
8786     case BUILT_IN_FETCH_AND_NAND_N:
8787     case BUILT_IN_ADD_AND_FETCH_N:
8788     case BUILT_IN_SUB_AND_FETCH_N:
8789     case BUILT_IN_OR_AND_FETCH_N:
8790     case BUILT_IN_AND_AND_FETCH_N:
8791     case BUILT_IN_XOR_AND_FETCH_N:
8792     case BUILT_IN_NAND_AND_FETCH_N:
8793     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8794     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8795     case BUILT_IN_LOCK_TEST_AND_SET_N:
8796     case BUILT_IN_LOCK_RELEASE_N:
8797       {
8798         int n = sync_resolve_size (function, params);
8799         tree new_function, first_param, result;
8800
8801         if (n == 0)
8802           return error_mark_node;
8803
8804         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8805         if (!sync_resolve_params (function, new_function, params))
8806           return error_mark_node;
8807
8808         first_param = VEC_index (tree, params, 0);
8809         result = build_function_call_vec (new_function, params, NULL);
8810         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8811             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8812           result = sync_resolve_return (first_param, result);
8813
8814         return result;
8815       }
8816
8817     default:
8818       return NULL_TREE;
8819     }
8820 }
8821
8822 /* Ignoring their sign, return true if two scalar types are the same.  */
8823 bool
8824 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8825 {
8826   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8827
8828   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8829               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8830                   || c2 == FIXED_POINT_TYPE));
8831
8832   /* Equality works here because c_common_signed_type uses
8833      TYPE_MAIN_VARIANT.  */
8834   return c_common_signed_type (t1)
8835     == c_common_signed_type (t2);
8836 }
8837
8838 /* Check for missing format attributes on function pointers.  LTYPE is
8839    the new type or left-hand side type.  RTYPE is the old type or
8840    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8841    attribute.  */
8842
8843 bool
8844 check_missing_format_attribute (tree ltype, tree rtype)
8845 {
8846   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8847   tree ra;
8848
8849   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8850     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8851       break;
8852   if (ra)
8853     {
8854       tree la;
8855       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8856         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8857           break;
8858       return !la;
8859     }
8860   else
8861     return false;
8862 }
8863
8864 /* Subscripting with type char is likely to lose on a machine where
8865    chars are signed.  So warn on any machine, but optionally.  Don't
8866    warn for unsigned char since that type is safe.  Don't warn for
8867    signed char because anyone who uses that must have done so
8868    deliberately. Furthermore, we reduce the false positive load by
8869    warning only for non-constant value of type char.  */
8870
8871 void
8872 warn_array_subscript_with_type_char (tree index)
8873 {
8874   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8875       && TREE_CODE (index) != INTEGER_CST)
8876     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8877 }
8878
8879 /* Implement -Wparentheses for the unexpected C precedence rules, to
8880    cover cases like x + y << z which readers are likely to
8881    misinterpret.  We have seen an expression in which CODE is a binary
8882    operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8883    before folding had CODE_LEFT and CODE_RIGHT.  CODE_LEFT and
8884    CODE_RIGHT may be ERROR_MARK, which means that that side of the
8885    expression was not formed using a binary or unary operator, or it
8886    was enclosed in parentheses.  */
8887
8888 void
8889 warn_about_parentheses (enum tree_code code,
8890                         enum tree_code code_left, tree arg_left,
8891                         enum tree_code code_right, tree arg_right)
8892 {
8893   if (!warn_parentheses)
8894     return;
8895
8896   /* This macro tests that the expression ARG with original tree code
8897      CODE appears to be a boolean expression. or the result of folding a
8898      boolean expression.  */
8899 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG)                             \
8900         (truth_value_p (TREE_CODE (ARG))                                    \
8901          || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE                     \
8902          /* Folding may create 0 or 1 integers from other expressions.  */  \
8903          || ((CODE) != INTEGER_CST                                          \
8904              && (integer_onep (ARG) || integer_zerop (ARG))))
8905
8906   switch (code)
8907     {
8908     case LSHIFT_EXPR:
8909       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8910         warning (OPT_Wparentheses,
8911                  "suggest parentheses around %<+%> inside %<<<%>");
8912       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8913         warning (OPT_Wparentheses,
8914                  "suggest parentheses around %<-%> inside %<<<%>");
8915       return;
8916
8917     case RSHIFT_EXPR:
8918       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8919         warning (OPT_Wparentheses,
8920                  "suggest parentheses around %<+%> inside %<>>%>");
8921       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8922         warning (OPT_Wparentheses,
8923                  "suggest parentheses around %<-%> inside %<>>%>");
8924       return;
8925
8926     case TRUTH_ORIF_EXPR:
8927       if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8928         warning (OPT_Wparentheses,
8929                  "suggest parentheses around %<&&%> within %<||%>");
8930       return;
8931
8932     case BIT_IOR_EXPR:
8933       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8934           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8935           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8936           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8937         warning (OPT_Wparentheses,
8938                  "suggest parentheses around arithmetic in operand of %<|%>");
8939       /* Check cases like x|y==z */
8940       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8941                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8942         warning (OPT_Wparentheses,
8943                  "suggest parentheses around comparison in operand of %<|%>");
8944       /* Check cases like !x | y */
8945       else if (code_left == TRUTH_NOT_EXPR
8946                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8947         warning (OPT_Wparentheses, "suggest parentheses around operand of "
8948                  "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8949       return;
8950
8951     case BIT_XOR_EXPR:
8952       if (code_left == BIT_AND_EXPR
8953           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8954           || code_right == BIT_AND_EXPR
8955           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8956         warning (OPT_Wparentheses,
8957                  "suggest parentheses around arithmetic in operand of %<^%>");
8958       /* Check cases like x^y==z */
8959       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8960                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8961         warning (OPT_Wparentheses,
8962                  "suggest parentheses around comparison in operand of %<^%>");
8963       return;
8964
8965     case BIT_AND_EXPR:
8966       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8967         warning (OPT_Wparentheses,
8968                  "suggest parentheses around %<+%> in operand of %<&%>");
8969       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8970         warning (OPT_Wparentheses,
8971                  "suggest parentheses around %<-%> in operand of %<&%>");
8972       /* Check cases like x&y==z */
8973       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8974                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8975         warning (OPT_Wparentheses,
8976                  "suggest parentheses around comparison in operand of %<&%>");
8977       /* Check cases like !x & y */
8978       else if (code_left == TRUTH_NOT_EXPR
8979                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8980         warning (OPT_Wparentheses, "suggest parentheses around operand of "
8981                  "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8982       return;
8983
8984     case EQ_EXPR:
8985       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8986           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8987         warning (OPT_Wparentheses,
8988                  "suggest parentheses around comparison in operand of %<==%>");
8989       return;
8990     case NE_EXPR:
8991       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8992           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8993         warning (OPT_Wparentheses,
8994                  "suggest parentheses around comparison in operand of %<!=%>");
8995       return;
8996
8997     default:
8998       if (TREE_CODE_CLASS (code) == tcc_comparison
8999            && ((TREE_CODE_CLASS (code_left) == tcc_comparison
9000                 && code_left != NE_EXPR && code_left != EQ_EXPR
9001                 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
9002                || (TREE_CODE_CLASS (code_right) == tcc_comparison
9003                    && code_right != NE_EXPR && code_right != EQ_EXPR
9004                    && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9005         warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9006                  "have their mathematical meaning");
9007       return;
9008     }
9009 #undef NOT_A_BOOLEAN_EXPR_P
9010 }
9011
9012 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
9013
9014 void
9015 warn_for_unused_label (tree label)
9016 {
9017   if (!TREE_USED (label))
9018     {
9019       if (DECL_INITIAL (label))
9020         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9021       else
9022         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9023     }
9024 }
9025
9026 #ifndef TARGET_HAS_TARGETCM
9027 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9028 #endif
9029
9030 /* Warn for division by zero according to the value of DIVISOR.  LOC
9031    is the location of the division operator.  */
9032
9033 void
9034 warn_for_div_by_zero (location_t loc, tree divisor)
9035 {
9036   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9037      about division by zero.  Do not issue a warning if DIVISOR has a
9038      floating-point type, since we consider 0.0/0.0 a valid way of
9039      generating a NaN.  */
9040   if (skip_evaluation == 0
9041       && (integer_zerop (divisor) || fixed_zerop (divisor)))
9042     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9043 }
9044
9045 /* Subroutine of build_binary_op. Give warnings for comparisons
9046    between signed and unsigned quantities that may fail. Do the
9047    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9048    so that casts will be considered, but default promotions won't
9049    be.
9050
9051    LOCATION is the location of the comparison operator.
9052
9053    The arguments of this function map directly to local variables
9054    of build_binary_op.  */
9055
9056 void
9057 warn_for_sign_compare (location_t location,
9058                        tree orig_op0, tree orig_op1,
9059                        tree op0, tree op1,
9060                        tree result_type, enum tree_code resultcode)
9061 {
9062   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9063   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9064   int unsignedp0, unsignedp1;
9065
9066   /* In C++, check for comparison of different enum types.  */
9067   if (c_dialect_cxx()
9068       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9069       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9070       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9071          != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9072     {
9073       warning_at (location,
9074                   OPT_Wsign_compare, "comparison between types %qT and %qT",
9075                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9076     }
9077
9078   /* Do not warn if the comparison is being done in a signed type,
9079      since the signed type will only be chosen if it can represent
9080      all the values of the unsigned type.  */
9081   if (!TYPE_UNSIGNED (result_type))
9082     /* OK */;
9083   /* Do not warn if both operands are unsigned.  */
9084   else if (op0_signed == op1_signed)
9085     /* OK */;
9086   else
9087     {
9088       tree sop, uop, base_type;
9089       bool ovf;
9090
9091       if (op0_signed)
9092         sop = orig_op0, uop = orig_op1;
9093       else
9094         sop = orig_op1, uop = orig_op0;
9095
9096       STRIP_TYPE_NOPS (sop);
9097       STRIP_TYPE_NOPS (uop);
9098       base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9099                    ? TREE_TYPE (result_type) : result_type);
9100
9101       /* Do not warn if the signed quantity is an unsuffixed integer
9102          literal (or some static constant expression involving such
9103          literals or a conditional expression involving such literals)
9104          and it is non-negative.  */
9105       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9106         /* OK */;
9107       /* Do not warn if the comparison is an equality operation, the
9108          unsigned quantity is an integral constant, and it would fit
9109          in the result if the result were signed.  */
9110       else if (TREE_CODE (uop) == INTEGER_CST
9111                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9112                && int_fits_type_p (uop, c_common_signed_type (base_type)))
9113         /* OK */;
9114       /* In C, do not warn if the unsigned quantity is an enumeration
9115          constant and its maximum value would fit in the result if the
9116          result were signed.  */
9117       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9118                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9119                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9120                                    c_common_signed_type (base_type)))
9121         /* OK */;
9122       else
9123         warning_at (location,
9124                     OPT_Wsign_compare,
9125                     "comparison between signed and unsigned integer expressions");
9126     }
9127
9128   /* Warn if two unsigned values are being compared in a size larger
9129      than their original size, and one (and only one) is the result of
9130      a `~' operator.  This comparison will always fail.
9131
9132      Also warn if one operand is a constant, and the constant does not
9133      have all bits set that are set in the ~ operand when it is
9134      extended.  */
9135
9136   op0 = get_narrower (op0, &unsignedp0);
9137   op1 = get_narrower (op1, &unsignedp1);
9138
9139   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9140       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9141     {
9142       if (TREE_CODE (op0) == BIT_NOT_EXPR)
9143         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9144       if (TREE_CODE (op1) == BIT_NOT_EXPR)
9145         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9146
9147       if (host_integerp (op0, 0) || host_integerp (op1, 0))
9148         {
9149           tree primop;
9150           HOST_WIDE_INT constant, mask;
9151           int unsignedp;
9152           unsigned int bits;
9153
9154           if (host_integerp (op0, 0))
9155             {
9156               primop = op1;
9157               unsignedp = unsignedp1;
9158               constant = tree_low_cst (op0, 0);
9159             }
9160           else
9161             {
9162               primop = op0;
9163               unsignedp = unsignedp0;
9164               constant = tree_low_cst (op1, 0);
9165             }
9166
9167           bits = TYPE_PRECISION (TREE_TYPE (primop));
9168           if (bits < TYPE_PRECISION (result_type)
9169               && bits < HOST_BITS_PER_LONG && unsignedp)
9170             {
9171               mask = (~ (HOST_WIDE_INT) 0) << bits;
9172               if ((mask & constant) != mask)
9173                 {
9174                   if (constant == 0)
9175                     warning (OPT_Wsign_compare,
9176                              "promoted ~unsigned is always non-zero");
9177                   else
9178                     warning_at (location, OPT_Wsign_compare,
9179                                 "comparison of promoted ~unsigned with constant");
9180                 }
9181             }
9182         }
9183       else if (unsignedp0 && unsignedp1
9184                && (TYPE_PRECISION (TREE_TYPE (op0))
9185                    < TYPE_PRECISION (result_type))
9186                && (TYPE_PRECISION (TREE_TYPE (op1))
9187                    < TYPE_PRECISION (result_type)))
9188         warning_at (location, OPT_Wsign_compare,
9189                  "comparison of promoted ~unsigned with unsigned");
9190     }
9191 }
9192
9193 /* Setup a TYPE_DECL node as a typedef representation.
9194
9195    X is a TYPE_DECL for a typedef statement.  Create a brand new
9196    ..._TYPE node (which will be just a variant of the existing
9197    ..._TYPE node with identical properties) and then install X
9198    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9199
9200    The whole point here is to end up with a situation where each
9201    and every ..._TYPE node the compiler creates will be uniquely
9202    associated with AT MOST one node representing a typedef name.
9203    This way, even though the compiler substitutes corresponding
9204    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9205    early on, later parts of the compiler can always do the reverse
9206    translation and get back the corresponding typedef name.  For
9207    example, given:
9208
9209         typedef struct S MY_TYPE;
9210         MY_TYPE object;
9211
9212    Later parts of the compiler might only know that `object' was of
9213    type `struct S' if it were not for code just below.  With this
9214    code however, later parts of the compiler see something like:
9215
9216         struct S' == struct S
9217         typedef struct S' MY_TYPE;
9218         struct S' object;
9219
9220     And they can then deduce (from the node for type struct S') that
9221     the original object declaration was:
9222
9223                 MY_TYPE object;
9224
9225     Being able to do this is important for proper support of protoize,
9226     and also for generating precise symbolic debugging information
9227     which takes full account of the programmer's (typedef) vocabulary.
9228
9229     Obviously, we don't want to generate a duplicate ..._TYPE node if
9230     the TYPE_DECL node that we are now processing really represents a
9231     standard built-in type.  */
9232
9233 void
9234 set_underlying_type (tree x)
9235 {
9236   if (x == error_mark_node)
9237     return;
9238   if (DECL_IS_BUILTIN (x))
9239     {
9240       if (TYPE_NAME (TREE_TYPE (x)) == 0)
9241         TYPE_NAME (TREE_TYPE (x)) = x;
9242     }
9243   else if (TREE_TYPE (x) != error_mark_node
9244            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9245     {
9246       tree tt = TREE_TYPE (x);
9247       DECL_ORIGINAL_TYPE (x) = tt;
9248       tt = build_variant_type_copy (tt);
9249       TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9250       TYPE_NAME (tt) = x;
9251       TREE_USED (tt) = TREE_USED (x);
9252       TREE_TYPE (x) = tt;
9253     }
9254 }
9255
9256 /* Returns true if X is a typedef decl.  */
9257
9258 bool
9259 is_typedef_decl (tree x)
9260 {
9261   return (x && TREE_CODE (x) == TYPE_DECL
9262           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9263 }
9264
9265 #include "gt-c-common.h"