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