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