gcc/c-common.c

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