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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  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 "diagnostic.h"
  37 #include "tm_p.h"
  38 #include "obstack.h"
  39 #include "cpplib.h"
  40 #include "target.h"
  41 #include "langhooks.h"
  42 #include "tree-inline.h"
  43 #include "c-tree.h"
  44 #include "toplev.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
  52 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  53
  54 /* We let tm.h override the types used here, to handle trivial differences
  55    such as the choice of unsigned int or long unsigned int for size_t.
  56    When machines start needing nontrivial differences in the size type,
  57    it would be best to do something here to figure out automatically
  58    from other information what type to use.  */
  59
  60 #ifndef SIZE_TYPE
  61 #define SIZE_TYPE "long unsigned int"
  62 #endif
  63
  64 #ifndef PID_TYPE
  65 #define PID_TYPE "int"
  66 #endif
  67
  68 #ifndef WCHAR_TYPE
  69 #define WCHAR_TYPE "int"
  70 #endif
  71
  72 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  73 #define MODIFIED_WCHAR_TYPE \
  74         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  75
  76 #ifndef PTRDIFF_TYPE
  77 #define PTRDIFF_TYPE "long int"
  78 #endif
  79
  80 #ifndef WINT_TYPE
  81 #define WINT_TYPE "unsigned int"
  82 #endif
  83
  84 #ifndef INTMAX_TYPE
  85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  86                      ? "int"                                    \
  87                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  88                         ? "long int"                            \
  89                         : "long long int"))
  90 #endif
  91
  92 #ifndef UINTMAX_TYPE
  93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  94                      ? "unsigned int"                           \
  95                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  96                         ? "long unsigned int"                   \
  97                         : "long long unsigned int"))
  98 #endif
  99
 100 /* The following symbols are subsumed in the c_global_trees array, and
 101    listed here individually for documentation purposes.
 102
 103    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
 104
 105         tree short_integer_type_node;
 106         tree long_integer_type_node;
 107         tree long_long_integer_type_node;
 108
 109         tree short_unsigned_type_node;
 110         tree long_unsigned_type_node;
 111         tree long_long_unsigned_type_node;
 112
 113         tree truthvalue_type_node;
 114         tree truthvalue_false_node;
 115         tree truthvalue_true_node;
 116
 117         tree ptrdiff_type_node;
 118
 119         tree unsigned_char_type_node;
 120         tree signed_char_type_node;
 121         tree wchar_type_node;
 122         tree signed_wchar_type_node;
 123         tree unsigned_wchar_type_node;
 124
 125         tree float_type_node;
 126         tree double_type_node;
 127         tree long_double_type_node;
 128
 129         tree complex_integer_type_node;
 130         tree complex_float_type_node;
 131         tree complex_double_type_node;
 132         tree complex_long_double_type_node;
 133
 134         tree dfloat32_type_node;
 135         tree dfloat64_type_node;
 136         tree_dfloat128_type_node;
 137
 138         tree intQI_type_node;
 139         tree intHI_type_node;
 140         tree intSI_type_node;
 141         tree intDI_type_node;
 142         tree intTI_type_node;
 143
 144         tree unsigned_intQI_type_node;
 145         tree unsigned_intHI_type_node;
 146         tree unsigned_intSI_type_node;
 147         tree unsigned_intDI_type_node;
 148         tree unsigned_intTI_type_node;
 149
 150         tree widest_integer_literal_type_node;
 151         tree widest_unsigned_literal_type_node;
 152
 153    Nodes for types `void *' and `const void *'.
 154
 155         tree ptr_type_node, const_ptr_type_node;
 156
 157    Nodes for types `char *' and `const char *'.
 158
 159         tree string_type_node, const_string_type_node;
 160
 161    Type `char[SOMENUMBER]'.
 162    Used when an array of char is needed and the size is irrelevant.
 163
 164         tree char_array_type_node;
 165
 166    Type `int[SOMENUMBER]' or something like it.
 167    Used when an array of int needed and the size is irrelevant.
 168
 169         tree int_array_type_node;
 170
 171    Type `wchar_t[SOMENUMBER]' or something like it.
 172    Used when a wide string literal is created.
 173
 174         tree wchar_array_type_node;
 175
 176    Type `int ()' -- used for implicit declaration of functions.
 177
 178         tree default_function_type;
 179
 180    A VOID_TYPE node, packaged in a TREE_LIST.
 181
 182         tree void_list_node;
 183
 184   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 185   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 186   VAR_DECLS, but C++ does.)
 187
 188         tree function_name_decl_node;
 189         tree pretty_function_name_decl_node;
 190         tree c99_function_name_decl_node;
 191
 192   Stack of nested function name VAR_DECLs.
 193
 194         tree saved_function_name_decls;
 195
 196 */
 197
 198 tree c_global_trees[CTI_MAX];
 199 \f
 200 /* Switches common to the C front ends.  */
 201
 202 /* Nonzero if prepreprocessing only.  */
 203
 204 int flag_preprocess_only;
 205
 206 /* Nonzero means don't output line number information.  */
 207
 208 char flag_no_line_commands;
 209
 210 /* Nonzero causes -E output not to be done, but directives such as
 211    #define that have side effects are still obeyed.  */
 212
 213 char flag_no_output;
 214
 215 /* Nonzero means dump macros in some fashion.  */
 216
 217 char flag_dump_macros;
 218
 219 /* Nonzero means pass #include lines through to the output.  */
 220
 221 char flag_dump_includes;
 222
 223 /* Nonzero means process PCH files while preprocessing.  */
 224
 225 bool flag_pch_preprocess;
 226
 227 /* The file name to which we should write a precompiled header, or
 228    NULL if no header will be written in this compile.  */
 229
 230 const char *pch_file;
 231
 232 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 233    user's namespace.  */
 234 int flag_iso;
 235
 236 /* Nonzero if -undef was given.  It suppresses target built-in macros
 237    and assertions.  */
 238 int flag_undef;
 239
 240 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 241
 242 int flag_no_builtin;
 243
 244 /* Nonzero means don't recognize the non-ANSI builtin functions.
 245    -ansi sets this.  */
 246
 247 int flag_no_nonansi_builtin;
 248
 249 /* Nonzero means give `double' the same size as `float'.  */
 250
 251 int flag_short_double;
 252
 253 /* Nonzero means give `wchar_t' the same size as `short'.  */
 254
 255 int flag_short_wchar;
 256
 257 /* Nonzero means allow implicit conversions between vectors with
 258    differing numbers of subparts and/or differing element types.  */
 259 int flag_lax_vector_conversions;
 260
 261 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
 262 int flag_ms_extensions;
 263
 264 /* Nonzero means don't recognize the keyword `asm'.  */
 265
 266 int flag_no_asm;
 267
 268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
 269
 270 int flag_signed_bitfields = 1;
 271
 272 /* Warn about #pragma directives that are not recognized.  */
 273
 274 int warn_unknown_pragmas; /* Tri state variable.  */
 275
 276 /* Warn about format/argument anomalies in calls to formatted I/O functions
 277    (*printf, *scanf, strftime, strfmon, etc.).  */
 278
 279 int warn_format;
 280
 281 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
 282    with GCC this doesn't matter as __null is guaranteed to have the right
 283    size.  */
 284
 285 int warn_strict_null_sentinel;
 286
 287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
 288    calls will be used in ObjC; passing nil receivers to such calls
 289    will most likely result in crashes.  */
 290 int flag_nil_receivers = 1;
 291
 292 /* Nonzero means that code generation will be altered to support
 293    "zero-link" execution.  This currently affects ObjC only, but may
 294    affect other languages in the future.  */
 295 int flag_zero_link = 0;
 296
 297 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
 298    unit.  It will inform the ObjC runtime that class definition(s) herein
 299    contained are to replace one(s) previously loaded.  */
 300 int flag_replace_objc_classes = 0;
 301
 302 /* C/ObjC language option variables.  */
 303
 304
 305 /* Nonzero means allow type mismatches in conditional expressions;
 306    just make their values `void'.  */
 307
 308 int flag_cond_mismatch;
 309
 310 /* Nonzero means enable C89 Amendment 1 features.  */
 311
 312 int flag_isoc94;
 313
 314 /* Nonzero means use the ISO C99 dialect of C.  */
 315
 316 int flag_isoc99;
 317
 318 /* Nonzero means that we have builtin functions, and main is an int.  */
 319
 320 int flag_hosted = 1;
 321
 322 /* Warn if main is suspicious.  */
 323
 324 int warn_main;
 325
 326
 327 /* ObjC language option variables.  */
 328
 329
 330 /* Open and close the file for outputting class declarations, if
 331    requested (ObjC).  */
 332
 333 int flag_gen_declaration;
 334
 335 /* Tells the compiler that this is a special run.  Do not perform any
 336    compiling, instead we are to test some platform dependent features
 337    and output a C header file with appropriate definitions.  */
 338
 339 int print_struct_values;
 340
 341 /* Tells the compiler what is the constant string class for Objc.  */
 342
 343 const char *constant_string_class_name;
 344
 345
 346 /* C++ language option variables.  */
 347
 348
 349 /* Nonzero means don't recognize any extension keywords.  */
 350
 351 int flag_no_gnu_keywords;
 352
 353 /* Nonzero means do emit exported implementations of functions even if
 354    they can be inlined.  */
 355
 356 int flag_implement_inlines = 1;
 357
 358 /* Nonzero means that implicit instantiations will be emitted if needed.  */
 359
 360 int flag_implicit_templates = 1;
 361
 362 /* Nonzero means that implicit instantiations of inline templates will be
 363    emitted if needed, even if instantiations of non-inline templates
 364    aren't.  */
 365
 366 int flag_implicit_inline_templates = 1;
 367
 368 /* Nonzero means generate separate instantiation control files and
 369    juggle them at link time.  */
 370
 371 int flag_use_repository;
 372
 373 /* Nonzero if we want to issue diagnostics that the standard says are not
 374    required.  */
 375
 376 int flag_optional_diags = 1;
 377
 378 /* Nonzero means we should attempt to elide constructors when possible.  */
 379
 380 int flag_elide_constructors = 1;
 381
 382 /* Nonzero means that member functions defined in class scope are
 383    inline by default.  */
 384
 385 int flag_default_inline = 1;
 386
 387 /* Controls whether compiler generates 'type descriptor' that give
 388    run-time type information.  */
 389
 390 int flag_rtti = 1;
 391
 392 /* Nonzero if we want to conserve space in the .o files.  We do this
 393    by putting uninitialized data and runtime initialized data into
 394    .common instead of .data at the expense of not flagging multiple
 395    definitions.  */
 396
 397 int flag_conserve_space;
 398
 399 /* Nonzero if we want to obey access control semantics.  */
 400
 401 int flag_access_control = 1;
 402
 403 /* Nonzero if we want to check the return value of new and avoid calling
 404    constructors if it is a null pointer.  */
 405
 406 int flag_check_new;
 407
 408 /* Nonzero if we want to allow the use of experimental features that
 409    are likely to become part of C++0x. */
 410
 411 int flag_cpp0x = 0;
 412
 413 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
 414    initialization variables.
 415    0: Old rules, set by -fno-for-scope.
 416    2: New ISO rules, set by -ffor-scope.
 417    1: Try to implement new ISO rules, but with backup compatibility
 418    (and warnings).  This is the default, for now.  */
 419
 420 int flag_new_for_scope = 1;
 421
 422 /* Nonzero if we want to emit defined symbols with common-like linkage as
 423    weak symbols where possible, in order to conform to C++ semantics.
 424    Otherwise, emit them as local symbols.  */
 425
 426 int flag_weak = 1;
 427
 428 /* 0 means we want the preprocessor to not emit line directives for
 429    the current working directory.  1 means we want it to do it.  -1
 430    means we should decide depending on whether debugging information
 431    is being emitted or not.  */
 432
 433 int flag_working_directory = -1;
 434
 435 /* Nonzero to use __cxa_atexit, rather than atexit, to register
 436    destructors for local statics and global objects.  '2' means it has been
 437    set nonzero as a default, not by a command-line flag.  */
 438
 439 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
 440
 441 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
 442    code.  '2' means it has not been set explicitly on the command line.  */
 443
 444 int flag_use_cxa_get_exception_ptr = 2;
 445
 446 /* Nonzero means make the default pedwarns warnings instead of errors.
 447    The value of this flag is ignored if -pedantic is specified.  */
 448
 449 int flag_permissive;
 450
 451 /* Nonzero means to implement standard semantics for exception
 452    specifications, calling unexpected if an exception is thrown that
 453    doesn't match the specification.  Zero means to treat them as
 454    assertions and optimize accordingly, but not check them.  */
 455
 456 int flag_enforce_eh_specs = 1;
 457
 458 /* Nonzero means to generate thread-safe code for initializing local
 459    statics.  */
 460
 461 int flag_threadsafe_statics = 1;
 462
 463 /* Nonzero means warn about implicit declarations.  */
 464
 465 int warn_implicit = 1;
 466
 467 /* Maximum template instantiation depth.  This limit is rather
 468    arbitrary, but it exists to limit the time it takes to notice
 469    infinite template instantiations.  */
 470
 471 int max_tinst_depth = 500;
 472
 473
 474
 475 /* The elements of `ridpointers' are identifier nodes for the reserved
 476    type names and storage classes.  It is indexed by a RID_... value.  */
 477 tree *ridpointers;
 478
 479 tree (*make_fname_decl) (tree, int);
 480
 481 /* Nonzero means the expression being parsed will never be evaluated.
 482    This is a count, since unevaluated expressions can nest.  */
 483 int skip_evaluation;
 484
 485 /* Information about how a function name is generated.  */
 486 struct fname_var_t
 487 {
 488   tree *const decl;     /* pointer to the VAR_DECL.  */
 489   const unsigned rid;   /* RID number for the identifier.  */
 490   const int pretty;     /* How pretty is it? */
 491 };
 492
 493 /* The three ways of getting then name of the current function.  */
 494
 495 const struct fname_var_t fname_vars[] =
 496 {
 497   /* C99 compliant __func__, must be first.  */
 498   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 499   /* GCC __FUNCTION__ compliant.  */
 500   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 501   /* GCC __PRETTY_FUNCTION__ compliant.  */
 502   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 503   {NULL, 0, 0},
 504 };
 505
 506 static tree check_case_value (tree);
 507 static bool check_case_bounds (tree, tree, tree *, tree *);
 508
 509 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
 510 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
 511 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
 512 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
 513 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
 514 static tree handle_always_inline_attribute (tree *, tree, tree, int,
 515                                             bool *);
 516 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
 517                                          bool *);
 518 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
 519 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
 520 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
 521 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
 522                                                  bool *);
 523 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
 524 static tree handle_transparent_union_attribute (tree *, tree, tree,
 525                                                 int, bool *);
 526 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
 527 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
 528 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
 529 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
 530 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
 531 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
 532 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
 533 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
 534 static tree handle_visibility_attribute (tree *, tree, tree, int,
 535                                          bool *);
 536 static tree handle_tls_model_attribute (tree *, tree, tree, int,
 537                                         bool *);
 538 static tree handle_no_instrument_function_attribute (tree *, tree,
 539                                                      tree, int, bool *);
 540 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
 541 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
 542 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
 543                                              bool *);
 544 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
 545 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
 546 static tree handle_deprecated_attribute (tree *, tree, tree, int,
 547                                          bool *);
 548 static tree handle_vector_size_attribute (tree *, tree, tree, int,
 549                                           bool *);
 550 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
 551 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
 552 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
 553 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
 554                                                  bool *);
 555 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
 556
 557 static void check_function_nonnull (tree, tree);
 558 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
 559 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
 560 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
 561 static int resort_field_decl_cmp (const void *, const void *);
 562
 563 /* Table of machine-independent attributes common to all C-like languages.  */
 564 const struct attribute_spec c_common_attribute_table[] =
 565 {
 566   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 567   { "packed",                 0, 0, false, false, false,
 568                               handle_packed_attribute },
 569   { "nocommon",               0, 0, true,  false, false,
 570                               handle_nocommon_attribute },
 571   { "common",                 0, 0, true,  false, false,
 572                               handle_common_attribute },
 573   /* FIXME: logically, noreturn attributes should be listed as
 574      "false, true, true" and apply to function types.  But implementing this
 575      would require all the places in the compiler that use TREE_THIS_VOLATILE
 576      on a decl to identify non-returning functions to be located and fixed
 577      to check the function type instead.  */
 578   { "noreturn",               0, 0, true,  false, false,
 579                               handle_noreturn_attribute },
 580   { "volatile",               0, 0, true,  false, false,
 581                               handle_noreturn_attribute },
 582   { "noinline",               0, 0, true,  false, false,
 583                               handle_noinline_attribute },
 584   { "always_inline",          0, 0, true,  false, false,
 585                               handle_always_inline_attribute },
 586   { "gnu_inline",             0, 0, true,  false, false,
 587                               handle_gnu_inline_attribute },
 588   { "flatten",                0, 0, true,  false, false,
 589                               handle_flatten_attribute },
 590   { "used",                   0, 0, true,  false, false,
 591                               handle_used_attribute },
 592   { "unused",                 0, 0, false, false, false,
 593                               handle_unused_attribute },
 594   { "externally_visible",     0, 0, true,  false, false,
 595                               handle_externally_visible_attribute },
 596   /* The same comments as for noreturn attributes apply to const ones.  */
 597   { "const",                  0, 0, true,  false, false,
 598                               handle_const_attribute },
 599   { "transparent_union",      0, 0, false, false, false,
 600                               handle_transparent_union_attribute },
 601   { "constructor",            0, 1, true,  false, false,
 602                               handle_constructor_attribute },
 603   { "destructor",             0, 1, true,  false, false,
 604                               handle_destructor_attribute },
 605   { "mode",                   1, 1, false,  true, false,
 606                               handle_mode_attribute },
 607   { "section",                1, 1, true,  false, false,
 608                               handle_section_attribute },
 609   { "aligned",                0, 1, false, false, false,
 610                               handle_aligned_attribute },
 611   { "weak",                   0, 0, true,  false, false,
 612                               handle_weak_attribute },
 613   { "alias",                  1, 1, true,  false, false,
 614                               handle_alias_attribute },
 615   { "weakref",                0, 1, true,  false, false,
 616                               handle_weakref_attribute },
 617   { "no_instrument_function", 0, 0, true,  false, false,
 618                               handle_no_instrument_function_attribute },
 619   { "malloc",                 0, 0, true,  false, false,
 620                               handle_malloc_attribute },
 621   { "returns_twice",          0, 0, true,  false, false,
 622                               handle_returns_twice_attribute },
 623   { "no_stack_limit",         0, 0, true,  false, false,
 624                               handle_no_limit_stack_attribute },
 625   { "pure",                   0, 0, true,  false, false,
 626                               handle_pure_attribute },
 627   /* For internal use (marking of builtins) only.  The name contains space
 628      to prevent its usage in source code.  */
 629   { "no vops",                0, 0, true,  false, false,
 630                               handle_novops_attribute },
 631   { "deprecated",             0, 0, false, false, false,
 632                               handle_deprecated_attribute },
 633   { "vector_size",            1, 1, false, true, false,
 634                               handle_vector_size_attribute },
 635   { "visibility",             1, 1, false, false, false,
 636                               handle_visibility_attribute },
 637   { "tls_model",              1, 1, true,  false, false,
 638                               handle_tls_model_attribute },
 639   { "nonnull",                0, -1, false, true, true,
 640                               handle_nonnull_attribute },
 641   { "nothrow",                0, 0, true,  false, false,
 642                               handle_nothrow_attribute },
 643   { "may_alias",              0, 0, false, true, false, NULL },
 644   { "cleanup",                1, 1, true, false, false,
 645                               handle_cleanup_attribute },
 646   { "warn_unused_result",     0, 0, false, true, true,
 647                               handle_warn_unused_result_attribute },
 648   { "sentinel",               0, 1, false, true, true,
 649                               handle_sentinel_attribute },
 650   { NULL,                     0, 0, false, false, false, NULL }
 651 };
 652
 653 /* Give the specifications for the format attributes, used by C and all
 654    descendants.  */
 655
 656 const struct attribute_spec c_common_format_attribute_table[] =
 657 {
 658   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 659   { "format",                 3, 3, false, true,  true,
 660                               handle_format_attribute },
 661   { "format_arg",             1, 1, false, true,  true,
 662                               handle_format_arg_attribute },
 663   { NULL,                     0, 0, false, false, false, NULL }
 664 };
 665
 666 /* Push current bindings for the function name VAR_DECLS.  */
 667
 668 void
 669 start_fname_decls (void)
 670 {
 671   unsigned ix;
 672   tree saved = NULL_TREE;
 673
 674   for (ix = 0; fname_vars[ix].decl; ix++)
 675     {
 676       tree decl = *fname_vars[ix].decl;
 677
 678       if (decl)
 679         {
 680           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
 681           *fname_vars[ix].decl = NULL_TREE;
 682         }
 683     }
 684   if (saved || saved_function_name_decls)
 685     /* Normally they'll have been NULL, so only push if we've got a
 686        stack, or they are non-NULL.  */
 687     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 688                                            saved_function_name_decls);
 689 }
 690
 691 /* Finish up the current bindings, adding them into the current function's
 692    statement tree.  This must be done _before_ finish_stmt_tree is called.
 693    If there is no current function, we must be at file scope and no statements
 694    are involved. Pop the previous bindings.  */
 695
 696 void
 697 finish_fname_decls (void)
 698 {
 699   unsigned ix;
 700   tree stmts = NULL_TREE;
 701   tree stack = saved_function_name_decls;
 702
 703   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 704     append_to_statement_list (TREE_VALUE (stack), &stmts);
 705
 706   if (stmts)
 707     {
 708       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
 709
 710       if (TREE_CODE (*bodyp) == BIND_EXPR)
 711         bodyp = &BIND_EXPR_BODY (*bodyp);
 712
 713       append_to_statement_list_force (*bodyp, &stmts);
 714       *bodyp = stmts;
 715     }
 716
 717   for (ix = 0; fname_vars[ix].decl; ix++)
 718     *fname_vars[ix].decl = NULL_TREE;
 719
 720   if (stack)
 721     {
 722       /* We had saved values, restore them.  */
 723       tree saved;
 724
 725       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 726         {
 727           tree decl = TREE_PURPOSE (saved);
 728           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 729
 730           *fname_vars[ix].decl = decl;
 731         }
 732       stack = TREE_CHAIN (stack);
 733     }
 734   saved_function_name_decls = stack;
 735 }
 736
 737 /* Return the text name of the current function, suitably prettified
 738    by PRETTY_P.  Return string must be freed by caller.  */
 739
 740 const char *
 741 fname_as_string (int pretty_p)
 742 {
 743   const char *name = "top level";
 744   char *namep;
 745   int vrb = 2;
 746
 747   if (!pretty_p)
 748     {
 749       name = "";
 750       vrb = 0;
 751     }
 752
 753   if (current_function_decl)
 754     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
 755
 756   if (c_lex_string_translate)
 757     {
 758       int len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
 759       cpp_string cstr = { 0, 0 }, strname;
 760
 761       namep = XNEWVEC (char, len);
 762       snprintf (namep, len, "\"%s\"", name);
 763       strname.text = (unsigned char *) namep;
 764       strname.len = len - 1;
 765
 766       if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
 767         {
 768           XDELETEVEC (namep);
 769           return (char *) cstr.text;
 770         }
 771     }
 772   else
 773     namep = xstrdup (name);
 774
 775   return namep;
 776 }
 777
 778 /* Expand DECL if it declares an entity not handled by the
 779    common code.  */
 780
 781 int
 782 c_expand_decl (tree decl)
 783 {
 784   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
 785     {
 786       /* Let the back-end know about this variable.  */
 787       if (!anon_aggr_type_p (TREE_TYPE (decl)))
 788         emit_local_var (decl);
 789       else
 790         expand_anon_union_decl (decl, NULL_TREE,
 791                                 DECL_ANON_UNION_ELEMS (decl));
 792     }
 793   else
 794     return 0;
 795
 796   return 1;
 797 }
 798
 799
 800 /* Return the VAR_DECL for a const char array naming the current
 801    function. If the VAR_DECL has not yet been created, create it
 802    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 803    ID is its name (unfortunately C and C++ hold the RID values of
 804    keywords in different places, so we can't derive RID from ID in
 805    this language independent code.  */
 806
 807 tree
 808 fname_decl (unsigned int rid, tree id)
 809 {
 810   unsigned ix;
 811   tree decl = NULL_TREE;
 812
 813   for (ix = 0; fname_vars[ix].decl; ix++)
 814     if (fname_vars[ix].rid == rid)
 815       break;
 816
 817   decl = *fname_vars[ix].decl;
 818   if (!decl)
 819     {
 820       /* If a tree is built here, it would normally have the lineno of
 821          the current statement.  Later this tree will be moved to the
 822          beginning of the function and this line number will be wrong.
 823          To avoid this problem set the lineno to 0 here; that prevents
 824          it from appearing in the RTL.  */
 825       tree stmts;
 826       location_t saved_location = input_location;
 827 #ifdef USE_MAPPED_LOCATION
 828       input_location = UNKNOWN_LOCATION;
 829 #else
 830       input_line = 0;
 831 #endif
 832
 833       stmts = push_stmt_list ();
 834       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 835       stmts = pop_stmt_list (stmts);
 836       if (!IS_EMPTY_STMT (stmts))
 837         saved_function_name_decls
 838           = tree_cons (decl, stmts, saved_function_name_decls);
 839       *fname_vars[ix].decl = decl;
 840       input_location = saved_location;
 841     }
 842   if (!ix && !current_function_decl)
 843     pedwarn ("%qD is not defined outside of function scope", decl);
 844
 845   return decl;
 846 }
 847
 848 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
 849
 850 tree
 851 fix_string_type (tree value)
 852 {
 853   const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 854   const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
 855   int length = TREE_STRING_LENGTH (value);
 856   int nchars;
 857   tree e_type, i_type, a_type;
 858
 859   /* Compute the number of elements, for the array type.  */
 860   nchars = wide_flag ? length / wchar_bytes : length;
 861
 862   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
 863      limit in C++98 Annex B is very large (65536) and is not normative,
 864      so we do not diagnose it (warn_overlength_strings is forced off
 865      in c_common_post_options).  */
 866   if (warn_overlength_strings)
 867     {
 868       const int nchars_max = flag_isoc99 ? 4095 : 509;
 869       const int relevant_std = flag_isoc99 ? 99 : 90;
 870       if (nchars - 1 > nchars_max)
 871         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
 872            separate the %d from the 'C'.  'ISO' should not be
 873            translated, but it may be moved after 'C%d' in languages
 874            where modifiers follow nouns.  */
 875         pedwarn ("string length %qd is greater than the length %qd "
 876                  "ISO C%d compilers are required to support",
 877                  nchars - 1, nchars_max, relevant_std);
 878     }
 879
 880   /* Create the array type for the string constant.  The ISO C++
 881      standard says that a string literal has type `const char[N]' or
 882      `const wchar_t[N]'.  We use the same logic when invoked as a C
 883      front-end with -Wwrite-strings.
 884      ??? We should change the type of an expression depending on the
 885      state of a warning flag.  We should just be warning -- see how
 886      this is handled in the C++ front-end for the deprecated implicit
 887      conversion from string literals to `char*' or `wchar_t*'.
 888
 889      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
 890      array type being the unqualified version of that type.
 891      Therefore, if we are constructing an array of const char, we must
 892      construct the matching unqualified array type first.  The C front
 893      end does not require this, but it does no harm, so we do it
 894      unconditionally.  */
 895   e_type = wide_flag ? wchar_type_node : char_type_node;
 896   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
 897   a_type = build_array_type (e_type, i_type);
 898   if (c_dialect_cxx() || warn_write_strings)
 899     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
 900
 901   TREE_TYPE (value) = a_type;
 902   TREE_CONSTANT (value) = 1;
 903   TREE_INVARIANT (value) = 1;
 904   TREE_READONLY (value) = 1;
 905   TREE_STATIC (value) = 1;
 906   return value;
 907 }
 908 \f
 909 /* Print a warning if a constant expression had overflow in folding.
 910    Invoke this function on every expression that the language
 911    requires to be a constant expression.
 912    Note the ANSI C standard says it is erroneous for a
 913    constant expression to overflow.  */
 914
 915 void
 916 constant_expression_warning (tree value)
 917 {
 918   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
 919        || TREE_CODE (value) == VECTOR_CST
 920        || TREE_CODE (value) == COMPLEX_CST)
 921       && TREE_OVERFLOW (value)
 922       && warn_overflow
 923       && pedantic)
 924     pedwarn ("overflow in constant expression");
 925 }
 926
 927 /* Print a warning if an expression had overflow in folding and its
 928    operands hadn't.
 929
 930    Invoke this function on every expression that
 931    (1) appears in the source code, and
 932    (2) is a constant expression that overflowed, and
 933    (3) is not already checked by convert_and_check;
 934    however, do not invoke this function on operands of explicit casts
 935    or when the expression is the result of an operator and any operand
 936    already overflowed.  */
 937
 938 void
 939 overflow_warning (tree value)
 940 {
 941   if (skip_evaluation) return;
 942
 943   switch (TREE_CODE (value))
 944     {
 945     case INTEGER_CST:
 946       warning (OPT_Woverflow, "integer overflow in expression");
 947       break;
 948
 949     case REAL_CST:
 950       warning (OPT_Woverflow, "floating point overflow in expression");
 951       break;
 952
 953     case VECTOR_CST:
 954       warning (OPT_Woverflow, "vector overflow in expression");
 955       break;
 956
 957     case COMPLEX_CST:
 958       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
 959         warning (OPT_Woverflow, "complex integer overflow in expression");
 960       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
 961         warning (OPT_Woverflow, "complex floating point overflow in expression");
 962       break;
 963
 964     default:
 965       break;
 966     }
 967 }
 968
 969 /* Print a warning about casts that might indicate violation
 970    of strict aliasing rules if -Wstrict-aliasing is used and
 971    strict aliasing mode is in effect. OTYPE is the original
 972    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
 973
 974 void
 975 strict_aliasing_warning (tree otype, tree type, tree expr)
 976 {
 977   if (flag_strict_aliasing && warn_strict_aliasing
 978       && POINTER_TYPE_P (type) && POINTER_TYPE_P (otype)
 979       && TREE_CODE (expr) == ADDR_EXPR
 980       && (DECL_P (TREE_OPERAND (expr, 0))
 981           || handled_component_p (TREE_OPERAND (expr, 0)))
 982       && !VOID_TYPE_P (TREE_TYPE (type)))
 983     {
 984       /* Casting the address of an object to non void pointer. Warn
 985          if the cast breaks type based aliasing.  */
 986       if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
 987         warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
 988                  "might break strict-aliasing rules");
 989       else
 990         {
 991           HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
 992           HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
 993
 994           if (!alias_sets_conflict_p (set1, set2))
 995             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
 996                      "pointer will break strict-aliasing rules");
 997           else if (warn_strict_aliasing > 1
 998                   && !alias_sets_might_conflict_p (set1, set2))
 999             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1000                      "pointer might break strict-aliasing rules");
1001         }
1002     }
1003 }
1004
1005 /* Print a warning about if (); or if () .. else; constructs
1006    via the special empty statement node that we create.  INNER_THEN
1007    and INNER_ELSE are the statement lists of the if and the else
1008    block.  */
1009
1010 void
1011 empty_body_warning (tree inner_then, tree inner_else)
1012 {
1013   if (warn_empty_body)
1014     {
1015       if (TREE_CODE (inner_then) == STATEMENT_LIST
1016           && STATEMENT_LIST_TAIL (inner_then))
1017         inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1018
1019       if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1020           && STATEMENT_LIST_TAIL (inner_else))
1021         inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1022
1023       if (IS_EMPTY_STMT (inner_then) && !inner_else)
1024         warning (OPT_Wempty_body, "%Hempty body in an if-statement",
1025                  EXPR_LOCUS (inner_then));
1026
1027       if (inner_else && IS_EMPTY_STMT (inner_else))
1028         warning (OPT_Wempty_body, "%Hempty body in an else-statement",
1029                  EXPR_LOCUS (inner_else));
1030    }
1031 }
1032
1033 /* Warn for unlikely, improbable, or stupid DECL declarations
1034    of `main'.  */
1035
1036 void
1037 check_main_parameter_types (tree decl)
1038 {
1039   tree args;
1040   int argct = 0;
1041
1042   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1043       args = TREE_CHAIN (args))
1044    {
1045      tree type = args ? TREE_VALUE (args) : 0;
1046
1047      if (type == void_type_node || type == error_mark_node )
1048        break;
1049
1050      ++argct;
1051      switch (argct)
1052        {
1053        case 1:
1054          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1055            pedwarn ("first argument of %q+D should be %<int%>", decl);
1056          break;
1057
1058        case 2:
1059          if (TREE_CODE (type) != POINTER_TYPE
1060              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1061              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1062                  != char_type_node))
1063            pedwarn ("second argument of %q+D should be %<char **%>",
1064                     decl);
1065          break;
1066
1067        case 3:
1068          if (TREE_CODE (type) != POINTER_TYPE
1069              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1070              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1071                  != char_type_node))
1072            pedwarn ("third argument of %q+D should probably be "
1073                     "%<char **%>", decl);
1074          break;
1075        }
1076    }
1077
1078   /* It is intentional that this message does not mention the third
1079     argument because it's only mentioned in an appendix of the
1080     standard.  */
1081   if (argct > 0 && (argct < 2 || argct > 3))
1082    pedwarn ("%q+D takes only zero or two arguments", decl);
1083 }
1084
1085 /* True if vector types T1 and T2 can be converted to each other
1086    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1087    can only be converted with -flax-vector-conversions yet that is not
1088    in effect, emit a note telling the user about that option if such
1089    a note has not previously been emitted.  */
1090 bool
1091 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1092 {
1093   static bool emitted_lax_note = false;
1094   bool convertible_lax;
1095
1096   if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1097       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1098     return true;
1099
1100   convertible_lax =
1101     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1102      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1103          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1104      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1105          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1106
1107   if (!convertible_lax || flag_lax_vector_conversions)
1108     return convertible_lax;
1109
1110   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1111       && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1112     return true;
1113
1114   if (emit_lax_note && !emitted_lax_note)
1115     {
1116       emitted_lax_note = true;
1117       inform ("use -flax-vector-conversions to permit "
1118               "conversions between vectors with differing "
1119               "element types or numbers of subparts");
1120     }
1121
1122   return false;
1123 }
1124
1125 /* Warns if the conversion of EXPR to TYPE may alter a value.
1126    This function is called from convert_and_check.  */
1127
1128 static void
1129 conversion_warning (tree type, tree expr)
1130 {
1131   bool give_warning = false;
1132
1133   unsigned int formal_prec = TYPE_PRECISION (type);
1134
1135   if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1136     {
1137       /* Warn for real constant that is not an exact integer converted
1138          to integer type.  */
1139       if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1140           && TREE_CODE (type) == INTEGER_TYPE)
1141         {
1142           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1143             give_warning = true;
1144         }
1145       /* Warn for an integer constant that does not fit into integer type.  */
1146       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1147                && TREE_CODE (type) == INTEGER_TYPE
1148                && !int_fits_type_p (expr, type))
1149         {
1150           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1151             warning (OPT_Wconversion,
1152                      "negative integer implicitly converted to unsigned type");
1153           else
1154             give_warning = true;
1155         }
1156       else if (TREE_CODE (type) == REAL_TYPE)
1157         {
1158           /* Warn for an integer constant that does not fit into real type.  */
1159           if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1160             {
1161               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1162               if (!exact_real_truncate (TYPE_MODE (type), &a))
1163                 give_warning = true;
1164             }
1165           /* Warn for a real constant that does not fit into a smaller
1166              real type.  */
1167           else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1168                    && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1169             {
1170               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1171               if (!exact_real_truncate (TYPE_MODE (type), &a))
1172                 give_warning = true;
1173             }
1174         }
1175
1176       if (give_warning)
1177         warning (OPT_Wconversion,
1178                  "conversion to %qT alters %qT constant value",
1179                  type, TREE_TYPE (expr));
1180     }
1181   else /* 'expr' is not a constant.  */
1182     {
1183       /* Warn for real types converted to integer types.  */
1184       if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1185           && TREE_CODE (type) == INTEGER_TYPE)
1186         give_warning = true;
1187
1188       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1189                && TREE_CODE (type) == INTEGER_TYPE)
1190         {
1191           /* Warn for integer types converted to smaller integer types.  */
1192           if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr))
1193               /* When they are the same width but different signedness,
1194                  then the value may change.  */
1195               || (formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1196                   && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1197               /* Even when converted to a bigger type, if the type is
1198                  unsigned but expr is signed, then negative values
1199                  will be changed.  */
1200               || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1201             give_warning = true;
1202         }
1203
1204       /* Warn for integer types converted to real types if and only if
1205          all the range of values of the integer type cannot be
1206          represented by the real type.  */
1207       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1208                && TREE_CODE (type) == REAL_TYPE)
1209         {
1210           tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1211           tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1212           REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1213           REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1214
1215           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1216               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1217             give_warning = true;
1218         }
1219
1220       /* Warn for real types converted to smaller real types.  */
1221       else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1222                && TREE_CODE (type) == REAL_TYPE
1223                && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1224         give_warning = true;
1225
1226
1227       if (give_warning)
1228         warning (OPT_Wconversion,
1229                  "conversion to %qT from %qT may alter its value",
1230                  type, TREE_TYPE (expr));
1231     }
1232 }
1233
1234 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1235    Invoke this function on every expression that is converted implicitly,
1236    i.e. because of language rules and not because of an explicit cast.  */
1237
1238 tree
1239 convert_and_check (tree type, tree expr)
1240 {
1241   tree result;
1242
1243   if (TREE_TYPE (expr) == type)
1244     return expr;
1245
1246   result = convert (type, expr);
1247
1248   if (skip_evaluation)
1249     return result;
1250
1251
1252   if (TREE_CODE (expr) == INTEGER_CST
1253       && (TREE_CODE (type) == INTEGER_TYPE
1254           || TREE_CODE (type) == ENUMERAL_TYPE)
1255       && !int_fits_type_p (expr, type))
1256     {
1257       /* Do not diagnose overflow in a constant expression merely
1258          because a conversion overflowed.  */
1259       if (TREE_OVERFLOW (result))
1260         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1261
1262       if (TYPE_UNSIGNED (type))
1263         {
1264           /* This detects cases like converting -129 or 256 to
1265              unsigned char.  */
1266           if (!int_fits_type_p (expr, c_common_signed_type (type)))
1267             warning (OPT_Woverflow,
1268                      "large integer implicitly truncated to unsigned type");
1269           else if (warn_conversion)
1270             conversion_warning (type, expr);
1271         }
1272       else
1273         {
1274           if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1275             warning (OPT_Woverflow,
1276                      "overflow in implicit constant conversion");
1277           /* No warning for converting 0x80000000 to int.  */
1278           else if (pedantic
1279                    && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1280                        || TYPE_PRECISION (TREE_TYPE (expr))
1281                        != TYPE_PRECISION (type)))
1282             warning (OPT_Woverflow,
1283                      "overflow in implicit constant conversion");
1284           else if (warn_conversion)
1285             conversion_warning (type, expr);
1286         }
1287     }
1288   else if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result))
1289     warning (OPT_Woverflow,
1290              "overflow in implicit constant conversion");
1291   else if (warn_conversion)
1292     conversion_warning (type, expr);
1293
1294   return result;
1295 }
1296 \f
1297 /* A node in a list that describes references to variables (EXPR), which are
1298    either read accesses if WRITER is zero, or write accesses, in which case
1299    WRITER is the parent of EXPR.  */
1300 struct tlist
1301 {
1302   struct tlist *next;
1303   tree expr, writer;
1304 };
1305
1306 /* Used to implement a cache the results of a call to verify_tree.  We only
1307    use this for SAVE_EXPRs.  */
1308 struct tlist_cache
1309 {
1310   struct tlist_cache *next;
1311   struct tlist *cache_before_sp;
1312   struct tlist *cache_after_sp;
1313   tree expr;
1314 };
1315
1316 /* Obstack to use when allocating tlist structures, and corresponding
1317    firstobj.  */
1318 static struct obstack tlist_obstack;
1319 static char *tlist_firstobj = 0;
1320
1321 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1322    warnings.  */
1323 static struct tlist *warned_ids;
1324 /* SAVE_EXPRs need special treatment.  We process them only once and then
1325    cache the results.  */
1326 static struct tlist_cache *save_expr_cache;
1327
1328 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1329 static void merge_tlist (struct tlist **, struct tlist *, int);
1330 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1331 static int warning_candidate_p (tree);
1332 static void warn_for_collisions (struct tlist *);
1333 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1334 static struct tlist *new_tlist (struct tlist *, tree, tree);
1335
1336 /* Create a new struct tlist and fill in its fields.  */
1337 static struct tlist *
1338 new_tlist (struct tlist *next, tree t, tree writer)
1339 {
1340   struct tlist *l;
1341   l = XOBNEW (&tlist_obstack, struct tlist);
1342   l->next = next;
1343   l->expr = t;
1344   l->writer = writer;
1345   return l;
1346 }
1347
1348 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1349    is nonnull, we ignore any node we find which has a writer equal to it.  */
1350
1351 static void
1352 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1353 {
1354   while (add)
1355     {
1356       struct tlist *next = add->next;
1357       if (!copy)
1358         add->next = *to;
1359       if (!exclude_writer || add->writer != exclude_writer)
1360         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1361       add = next;
1362     }
1363 }
1364
1365 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1366    each variable that already exists in TO, no new node is added; however if
1367    there is a write access recorded in ADD, and an occurrence on TO is only
1368    a read access, then the occurrence in TO will be modified to record the
1369    write.  */
1370
1371 static void
1372 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1373 {
1374   struct tlist **end = to;
1375
1376   while (*end)
1377     end = &(*end)->next;
1378
1379   while (add)
1380     {
1381       int found = 0;
1382       struct tlist *tmp2;
1383       struct tlist *next = add->next;
1384
1385       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1386         if (tmp2->expr == add->expr)
1387           {
1388             found = 1;
1389             if (!tmp2->writer)
1390               tmp2->writer = add->writer;
1391           }
1392       if (!found)
1393         {
1394           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1395           end = &(*end)->next;
1396           *end = 0;
1397         }
1398       add = next;
1399     }
1400 }
1401
1402 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1403    references in list LIST conflict with it, excluding reads if ONLY writers
1404    is nonzero.  */
1405
1406 static void
1407 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1408                        int only_writes)
1409 {
1410   struct tlist *tmp;
1411
1412   /* Avoid duplicate warnings.  */
1413   for (tmp = warned_ids; tmp; tmp = tmp->next)
1414     if (tmp->expr == written)
1415       return;
1416
1417   while (list)
1418     {
1419       if (list->expr == written
1420           && list->writer != writer
1421           && (!only_writes || list->writer)
1422           && DECL_NAME (list->expr))
1423         {
1424           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1425           warning (0, "operation on %qE may be undefined", list->expr);
1426         }
1427       list = list->next;
1428     }
1429 }
1430
1431 /* Given a list LIST of references to variables, find whether any of these
1432    can cause conflicts due to missing sequence points.  */
1433
1434 static void
1435 warn_for_collisions (struct tlist *list)
1436 {
1437   struct tlist *tmp;
1438
1439   for (tmp = list; tmp; tmp = tmp->next)
1440     {
1441       if (tmp->writer)
1442         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1443     }
1444 }
1445
1446 /* Return nonzero if X is a tree that can be verified by the sequence point
1447    warnings.  */
1448 static int
1449 warning_candidate_p (tree x)
1450 {
1451   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1452 }
1453
1454 /* Walk the tree X, and record accesses to variables.  If X is written by the
1455    parent tree, WRITER is the parent.
1456    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1457    expression or its only operand forces a sequence point, then everything up
1458    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1459    in PNO_SP.
1460    Once we return, we will have emitted warnings if any subexpression before
1461    such a sequence point could be undefined.  On a higher level, however, the
1462    sequence point may not be relevant, and we'll merge the two lists.
1463
1464    Example: (b++, a) + b;
1465    The call that processes the COMPOUND_EXPR will store the increment of B
1466    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1467    processes the PLUS_EXPR will need to merge the two lists so that
1468    eventually, all accesses end up on the same list (and we'll warn about the
1469    unordered subexpressions b++ and b.
1470
1471    A note on merging.  If we modify the former example so that our expression
1472    becomes
1473      (b++, b) + a
1474    care must be taken not simply to add all three expressions into the final
1475    PNO_SP list.  The function merge_tlist takes care of that by merging the
1476    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1477    way, so that no more than one access to B is recorded.  */
1478
1479 static void
1480 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1481              tree writer)
1482 {
1483   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1484   enum tree_code code;
1485   enum tree_code_class cl;
1486
1487   /* X may be NULL if it is the operand of an empty statement expression
1488      ({ }).  */
1489   if (x == NULL)
1490     return;
1491
1492  restart:
1493   code = TREE_CODE (x);
1494   cl = TREE_CODE_CLASS (code);
1495
1496   if (warning_candidate_p (x))
1497     {
1498       *pno_sp = new_tlist (*pno_sp, x, writer);
1499       return;
1500     }
1501
1502   switch (code)
1503     {
1504     case CONSTRUCTOR:
1505       return;
1506
1507     case COMPOUND_EXPR:
1508     case TRUTH_ANDIF_EXPR:
1509     case TRUTH_ORIF_EXPR:
1510       tmp_before = tmp_nosp = tmp_list3 = 0;
1511       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1512       warn_for_collisions (tmp_nosp);
1513       merge_tlist (pbefore_sp, tmp_before, 0);
1514       merge_tlist (pbefore_sp, tmp_nosp, 0);
1515       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1516       merge_tlist (pbefore_sp, tmp_list3, 0);
1517       return;
1518
1519     case COND_EXPR:
1520       tmp_before = tmp_list2 = 0;
1521       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1522       warn_for_collisions (tmp_list2);
1523       merge_tlist (pbefore_sp, tmp_before, 0);
1524       merge_tlist (pbefore_sp, tmp_list2, 1);
1525
1526       tmp_list3 = tmp_nosp = 0;
1527       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1528       warn_for_collisions (tmp_nosp);
1529       merge_tlist (pbefore_sp, tmp_list3, 0);
1530
1531       tmp_list3 = tmp_list2 = 0;
1532       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1533       warn_for_collisions (tmp_list2);
1534       merge_tlist (pbefore_sp, tmp_list3, 0);
1535       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1536          two first, to avoid warning for (a ? b++ : b++).  */
1537       merge_tlist (&tmp_nosp, tmp_list2, 0);
1538       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1539       return;
1540
1541     case PREDECREMENT_EXPR:
1542     case PREINCREMENT_EXPR:
1543     case POSTDECREMENT_EXPR:
1544     case POSTINCREMENT_EXPR:
1545       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1546       return;
1547
1548     case MODIFY_EXPR:
1549       tmp_before = tmp_nosp = tmp_list3 = 0;
1550       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1551       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1552       /* Expressions inside the LHS are not ordered wrt. the sequence points
1553          in the RHS.  Example:
1554            *a = (a++, 2)
1555          Despite the fact that the modification of "a" is in the before_sp
1556          list (tmp_before), it conflicts with the use of "a" in the LHS.
1557          We can handle this by adding the contents of tmp_list3
1558          to those of tmp_before, and redoing the collision warnings for that
1559          list.  */
1560       add_tlist (&tmp_before, tmp_list3, x, 1);
1561       warn_for_collisions (tmp_before);
1562       /* Exclude the LHS itself here; we first have to merge it into the
1563          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1564          didn't exclude the LHS, we'd get it twice, once as a read and once
1565          as a write.  */
1566       add_tlist (pno_sp, tmp_list3, x, 0);
1567       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1568
1569       merge_tlist (pbefore_sp, tmp_before, 0);
1570       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1571         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1572       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1573       return;
1574
1575     case CALL_EXPR:
1576       /* We need to warn about conflicts among arguments and conflicts between
1577          args and the function address.  Side effects of the function address,
1578          however, are not ordered by the sequence point of the call.  */
1579       {
1580         call_expr_arg_iterator iter;
1581         tree arg;
1582         tmp_before = tmp_nosp = 0;
1583         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
1584         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
1585           {
1586             tmp_list2 = tmp_list3 = 0;
1587             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
1588             merge_tlist (&tmp_list3, tmp_list2, 0);
1589             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1590           }
1591         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1592         warn_for_collisions (tmp_before);
1593         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1594         return;
1595       }
1596
1597     case TREE_LIST:
1598       /* Scan all the list, e.g. indices of multi dimensional array.  */
1599       while (x)
1600         {
1601           tmp_before = tmp_nosp = 0;
1602           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1603           merge_tlist (&tmp_nosp, tmp_before, 0);
1604           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1605           x = TREE_CHAIN (x);
1606         }
1607       return;
1608
1609     case SAVE_EXPR:
1610       {
1611         struct tlist_cache *t;
1612         for (t = save_expr_cache; t; t = t->next)
1613           if (t->expr == x)
1614             break;
1615
1616         if (!t)
1617           {
1618             t = XOBNEW (&tlist_obstack, struct tlist_cache);
1619             t->next = save_expr_cache;
1620             t->expr = x;
1621             save_expr_cache = t;
1622
1623             tmp_before = tmp_nosp = 0;
1624             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1625             warn_for_collisions (tmp_nosp);
1626
1627             tmp_list3 = 0;
1628             while (tmp_nosp)
1629               {
1630                 struct tlist *t = tmp_nosp;
1631                 tmp_nosp = t->next;
1632                 merge_tlist (&tmp_list3, t, 0);
1633               }
1634             t->cache_before_sp = tmp_before;
1635             t->cache_after_sp = tmp_list3;
1636           }
1637         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1638         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1639         return;
1640       }
1641
1642     default:
1643       /* For other expressions, simply recurse on their operands.
1644          Manual tail recursion for unary expressions.
1645          Other non-expressions need not be processed.  */
1646       if (cl == tcc_unary)
1647         {
1648           x = TREE_OPERAND (x, 0);
1649           writer = 0;
1650           goto restart;
1651         }
1652       else if (IS_EXPR_CODE_CLASS (cl))
1653         {
1654           int lp;
1655           int max = TREE_OPERAND_LENGTH (x);
1656           for (lp = 0; lp < max; lp++)
1657             {
1658               tmp_before = tmp_nosp = 0;
1659               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1660               merge_tlist (&tmp_nosp, tmp_before, 0);
1661               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1662             }
1663         }
1664       return;
1665     }
1666 }
1667
1668 /* Try to warn for undefined behavior in EXPR due to missing sequence
1669    points.  */
1670
1671 void
1672 verify_sequence_points (tree expr)
1673 {
1674   struct tlist *before_sp = 0, *after_sp = 0;
1675
1676   warned_ids = 0;
1677   save_expr_cache = 0;
1678   if (tlist_firstobj == 0)
1679     {
1680       gcc_obstack_init (&tlist_obstack);
1681       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1682     }
1683
1684   verify_tree (expr, &before_sp, &after_sp, 0);
1685   warn_for_collisions (after_sp);
1686   obstack_free (&tlist_obstack, tlist_firstobj);
1687 }
1688 \f
1689 /* Validate the expression after `case' and apply default promotions.  */
1690
1691 static tree
1692 check_case_value (tree value)
1693 {
1694   if (value == NULL_TREE)
1695     return value;
1696
1697   /* ??? Can we ever get nops here for a valid case value?  We
1698      shouldn't for C.  */
1699   STRIP_TYPE_NOPS (value);
1700   /* In C++, the following is allowed:
1701
1702        const int i = 3;
1703        switch (...) { case i: ... }
1704
1705      So, we try to reduce the VALUE to a constant that way.  */
1706   if (c_dialect_cxx ())
1707     {
1708       value = decl_constant_value (value);
1709       STRIP_TYPE_NOPS (value);
1710       value = fold (value);
1711     }
1712
1713   if (TREE_CODE (value) == INTEGER_CST)
1714     /* Promote char or short to int.  */
1715     value = perform_integral_promotions (value);
1716   else if (value != error_mark_node)
1717     {
1718       error ("case label does not reduce to an integer constant");
1719       value = error_mark_node;
1720     }
1721
1722   constant_expression_warning (value);
1723
1724   return value;
1725 }
1726 \f
1727 /* See if the case values LOW and HIGH are in the range of the original
1728    type (i.e. before the default conversion to int) of the switch testing
1729    expression.
1730    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1731    the type before promoting it.  CASE_LOW_P is a pointer to the lower
1732    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1733    if the case is not a case range.
1734    The caller has to make sure that we are not called with NULL for
1735    CASE_LOW_P (i.e. the default case).
1736    Returns true if the case label is in range of ORIG_TYPE (saturated or
1737    untouched) or false if the label is out of range.  */
1738
1739 static bool
1740 check_case_bounds (tree type, tree orig_type,
1741                    tree *case_low_p, tree *case_high_p)
1742 {
1743   tree min_value, max_value;
1744   tree case_low = *case_low_p;
1745   tree case_high = case_high_p ? *case_high_p : case_low;
1746
1747   /* If there was a problem with the original type, do nothing.  */
1748   if (orig_type == error_mark_node)
1749     return true;
1750
1751   min_value = TYPE_MIN_VALUE (orig_type);
1752   max_value = TYPE_MAX_VALUE (orig_type);
1753
1754   /* Case label is less than minimum for type.  */
1755   if (tree_int_cst_compare (case_low, min_value) < 0
1756       && tree_int_cst_compare (case_high, min_value) < 0)
1757     {
1758       warning (0, "case label value is less than minimum value for type");
1759       return false;
1760     }
1761
1762   /* Case value is greater than maximum for type.  */
1763   if (tree_int_cst_compare (case_low, max_value) > 0
1764       && tree_int_cst_compare (case_high, max_value) > 0)
1765     {
1766       warning (0, "case label value exceeds maximum value for type");
1767       return false;
1768     }
1769
1770   /* Saturate lower case label value to minimum.  */
1771   if (tree_int_cst_compare (case_high, min_value) >= 0
1772       && tree_int_cst_compare (case_low, min_value) < 0)
1773     {
1774       warning (0, "lower value in case label range"
1775                " less than minimum value for type");
1776       case_low = min_value;
1777     }
1778
1779   /* Saturate upper case label value to maximum.  */
1780   if (tree_int_cst_compare (case_low, max_value) <= 0
1781       && tree_int_cst_compare (case_high, max_value) > 0)
1782     {
1783       warning (0, "upper value in case label range"
1784                " exceeds maximum value for type");
1785       case_high = max_value;
1786     }
1787
1788   if (*case_low_p != case_low)
1789     *case_low_p = convert (type, case_low);
1790   if (case_high_p && *case_high_p != case_high)
1791     *case_high_p = convert (type, case_high);
1792
1793   return true;
1794 }
1795 \f
1796 /* Return an integer type with BITS bits of precision,
1797    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1798
1799 tree
1800 c_common_type_for_size (unsigned int bits, int unsignedp)
1801 {
1802   if (bits == TYPE_PRECISION (integer_type_node))
1803     return unsignedp ? unsigned_type_node : integer_type_node;
1804
1805   if (bits == TYPE_PRECISION (signed_char_type_node))
1806     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1807
1808   if (bits == TYPE_PRECISION (short_integer_type_node))
1809     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1810
1811   if (bits == TYPE_PRECISION (long_integer_type_node))
1812     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1813
1814   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1815     return (unsignedp ? long_long_unsigned_type_node
1816             : long_long_integer_type_node);
1817
1818   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1819     return (unsignedp ? widest_unsigned_literal_type_node
1820             : widest_integer_literal_type_node);
1821
1822   if (bits <= TYPE_PRECISION (intQI_type_node))
1823     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1824
1825   if (bits <= TYPE_PRECISION (intHI_type_node))
1826     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1827
1828   if (bits <= TYPE_PRECISION (intSI_type_node))
1829     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1830
1831   if (bits <= TYPE_PRECISION (intDI_type_node))
1832     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1833
1834   return 0;
1835 }
1836
1837 /* Used for communication between c_common_type_for_mode and
1838    c_register_builtin_type.  */
1839 static GTY(()) tree registered_builtin_types;
1840
1841 /* Return a data type that has machine mode MODE.
1842    If the mode is an integer,
1843    then UNSIGNEDP selects between signed and unsigned types.  */
1844
1845 tree
1846 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1847 {
1848   tree t;
1849
1850   if (mode == TYPE_MODE (integer_type_node))
1851     return unsignedp ? unsigned_type_node : integer_type_node;
1852
1853   if (mode == TYPE_MODE (signed_char_type_node))
1854     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1855
1856   if (mode == TYPE_MODE (short_integer_type_node))
1857     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1858
1859   if (mode == TYPE_MODE (long_integer_type_node))
1860     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1861
1862   if (mode == TYPE_MODE (long_long_integer_type_node))
1863     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1864
1865   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1866     return unsignedp ? widest_unsigned_literal_type_node
1867                      : widest_integer_literal_type_node;
1868
1869   if (mode == QImode)
1870     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1871
1872   if (mode == HImode)
1873     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1874
1875   if (mode == SImode)
1876     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1877
1878   if (mode == DImode)
1879     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1880
1881 #if HOST_BITS_PER_WIDE_INT >= 64
1882   if (mode == TYPE_MODE (intTI_type_node))
1883     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1884 #endif
1885
1886   if (mode == TYPE_MODE (float_type_node))
1887     return float_type_node;
1888
1889   if (mode == TYPE_MODE (double_type_node))
1890     return double_type_node;
1891
1892   if (mode == TYPE_MODE (long_double_type_node))
1893     return long_double_type_node;
1894
1895   if (mode == TYPE_MODE (void_type_node))
1896     return void_type_node;
1897
1898   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1899     return (unsignedp
1900             ? make_unsigned_type (GET_MODE_PRECISION (mode))
1901             : make_signed_type (GET_MODE_PRECISION (mode)));
1902
1903   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1904     return (unsignedp
1905             ? make_unsigned_type (GET_MODE_PRECISION (mode))
1906             : make_signed_type (GET_MODE_PRECISION (mode)));
1907
1908   if (COMPLEX_MODE_P (mode))
1909     {
1910       enum machine_mode inner_mode;
1911       tree inner_type;
1912
1913       if (mode == TYPE_MODE (complex_float_type_node))
1914         return complex_float_type_node;
1915       if (mode == TYPE_MODE (complex_double_type_node))
1916         return complex_double_type_node;
1917       if (mode == TYPE_MODE (complex_long_double_type_node))
1918         return complex_long_double_type_node;
1919
1920       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1921         return complex_integer_type_node;
1922
1923       inner_mode = GET_MODE_INNER (mode);
1924       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1925       if (inner_type != NULL_TREE)
1926         return build_complex_type (inner_type);
1927     }
1928   else if (VECTOR_MODE_P (mode))
1929     {
1930       enum machine_mode inner_mode = GET_MODE_INNER (mode);
1931       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1932       if (inner_type != NULL_TREE)
1933         return build_vector_type_for_mode (inner_type, mode);
1934     }
1935
1936   if (mode == TYPE_MODE (dfloat32_type_node))
1937     return dfloat32_type_node;
1938   if (mode == TYPE_MODE (dfloat64_type_node))
1939     return dfloat64_type_node;
1940   if (mode == TYPE_MODE (dfloat128_type_node))
1941     return dfloat128_type_node;
1942
1943   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1944     if (TYPE_MODE (TREE_VALUE (t)) == mode)
1945       return TREE_VALUE (t);
1946
1947   return 0;
1948 }
1949
1950 /* Return an unsigned type the same as TYPE in other respects.  */
1951 tree
1952 c_common_unsigned_type (tree type)
1953 {
1954   tree type1 = TYPE_MAIN_VARIANT (type);
1955   if (type1 == signed_char_type_node || type1 == char_type_node)
1956     return unsigned_char_type_node;
1957   if (type1 == integer_type_node)
1958     return unsigned_type_node;
1959   if (type1 == short_integer_type_node)
1960     return short_unsigned_type_node;
1961   if (type1 == long_integer_type_node)
1962     return long_unsigned_type_node;
1963   if (type1 == long_long_integer_type_node)
1964     return long_long_unsigned_type_node;
1965   if (type1 == widest_integer_literal_type_node)
1966     return widest_unsigned_literal_type_node;
1967 #if HOST_BITS_PER_WIDE_INT >= 64
1968   if (type1 == intTI_type_node)
1969     return unsigned_intTI_type_node;
1970 #endif
1971   if (type1 == intDI_type_node)
1972     return unsigned_intDI_type_node;
1973   if (type1 == intSI_type_node)
1974     return unsigned_intSI_type_node;
1975   if (type1 == intHI_type_node)
1976     return unsigned_intHI_type_node;
1977   if (type1 == intQI_type_node)
1978     return unsigned_intQI_type_node;
1979
1980   return c_common_signed_or_unsigned_type (1, type);
1981 }
1982
1983 /* Return a signed type the same as TYPE in other respects.  */
1984
1985 tree
1986 c_common_signed_type (tree type)
1987 {
1988   tree type1 = TYPE_MAIN_VARIANT (type);
1989   if (type1 == unsigned_char_type_node || type1 == char_type_node)
1990     return signed_char_type_node;
1991   if (type1 == unsigned_type_node)
1992     return integer_type_node;
1993   if (type1 == short_unsigned_type_node)
1994     return short_integer_type_node;
1995   if (type1 == long_unsigned_type_node)
1996     return long_integer_type_node;
1997   if (type1 == long_long_unsigned_type_node)
1998     return long_long_integer_type_node;
1999   if (type1 == widest_unsigned_literal_type_node)
2000     return widest_integer_literal_type_node;
2001 #if HOST_BITS_PER_WIDE_INT >= 64
2002   if (type1 == unsigned_intTI_type_node)
2003     return intTI_type_node;
2004 #endif
2005   if (type1 == unsigned_intDI_type_node)
2006     return intDI_type_node;
2007   if (type1 == unsigned_intSI_type_node)
2008     return intSI_type_node;
2009   if (type1 == unsigned_intHI_type_node)
2010     return intHI_type_node;
2011   if (type1 == unsigned_intQI_type_node)
2012     return intQI_type_node;
2013
2014   return c_common_signed_or_unsigned_type (0, type);
2015 }
2016
2017 /* Return a type the same as TYPE except unsigned or
2018    signed according to UNSIGNEDP.  */
2019
2020 tree
2021 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2022 {
2023   if (!INTEGRAL_TYPE_P (type)
2024       || TYPE_UNSIGNED (type) == unsignedp)
2025     return type;
2026
2027   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2028      the precision; they have precision set to match their range, but
2029      may use a wider mode to match an ABI.  If we change modes, we may
2030      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
2031      the precision as well, so as to yield correct results for
2032      bit-field types.  C++ does not have these separate bit-field
2033      types, and producing a signed or unsigned variant of an
2034      ENUMERAL_TYPE may cause other problems as well.  */
2035
2036 #define TYPE_OK(node)                                                       \
2037   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
2038    && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2039   if (TYPE_OK (signed_char_type_node))
2040     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2041   if (TYPE_OK (integer_type_node))
2042     return unsignedp ? unsigned_type_node : integer_type_node;
2043   if (TYPE_OK (short_integer_type_node))
2044     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2045   if (TYPE_OK (long_integer_type_node))
2046     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2047   if (TYPE_OK (long_long_integer_type_node))
2048     return (unsignedp ? long_long_unsigned_type_node
2049             : long_long_integer_type_node);
2050   if (TYPE_OK (widest_integer_literal_type_node))
2051     return (unsignedp ? widest_unsigned_literal_type_node
2052             : widest_integer_literal_type_node);
2053
2054 #if HOST_BITS_PER_WIDE_INT >= 64
2055   if (TYPE_OK (intTI_type_node))
2056     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2057 #endif
2058   if (TYPE_OK (intDI_type_node))
2059     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2060   if (TYPE_OK (intSI_type_node))
2061     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2062   if (TYPE_OK (intHI_type_node))
2063     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2064   if (TYPE_OK (intQI_type_node))
2065     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2066 #undef TYPE_OK
2067
2068   if (c_dialect_cxx ())
2069     return type;
2070   else
2071     return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2072 }
2073
2074 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
2075
2076 tree
2077 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2078 {
2079   /* Extended integer types of the same width as a standard type have
2080      lesser rank, so those of the same width as int promote to int or
2081      unsigned int and are valid for printf formats expecting int or
2082      unsigned int.  To avoid such special cases, avoid creating
2083      extended integer types for bit-fields if a standard integer type
2084      is available.  */
2085   if (width == TYPE_PRECISION (integer_type_node))
2086     return unsignedp ? unsigned_type_node : integer_type_node;
2087   if (width == TYPE_PRECISION (signed_char_type_node))
2088     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2089   if (width == TYPE_PRECISION (short_integer_type_node))
2090     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2091   if (width == TYPE_PRECISION (long_integer_type_node))
2092     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2093   if (width == TYPE_PRECISION (long_long_integer_type_node))
2094     return (unsignedp ? long_long_unsigned_type_node
2095             : long_long_integer_type_node);
2096   return build_nonstandard_integer_type (width, unsignedp);
2097 }
2098
2099 /* The C version of the register_builtin_type langhook.  */
2100
2101 void
2102 c_register_builtin_type (tree type, const char* name)
2103 {
2104   tree decl;
2105
2106   decl = build_decl (TYPE_DECL, get_identifier (name), type);
2107   DECL_ARTIFICIAL (decl) = 1;
2108   if (!TYPE_NAME (type))
2109     TYPE_NAME (type) = decl;
2110   pushdecl (decl);
2111
2112   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2113 }
2114
2115 \f
2116 /* Return the minimum number of bits needed to represent VALUE in a
2117    signed or unsigned type, UNSIGNEDP says which.  */
2118
2119 unsigned int
2120 min_precision (tree value, int unsignedp)
2121 {
2122   int log;
2123
2124   /* If the value is negative, compute its negative minus 1.  The latter
2125      adjustment is because the absolute value of the largest negative value
2126      is one larger than the largest positive value.  This is equivalent to
2127      a bit-wise negation, so use that operation instead.  */
2128
2129   if (tree_int_cst_sgn (value) < 0)
2130     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2131
2132   /* Return the number of bits needed, taking into account the fact
2133      that we need one more bit for a signed than unsigned type.  */
2134
2135   if (integer_zerop (value))
2136     log = 0;
2137   else
2138     log = tree_floor_log2 (value);
2139
2140   return log + 1 + !unsignedp;
2141 }
2142 \f
2143 /* Print an error message for invalid operands to arith operation
2144    CODE.  */
2145
2146 void
2147 binary_op_error (enum tree_code code)
2148 {
2149   const char *opname;
2150
2151   switch (code)
2152     {
2153     case PLUS_EXPR:
2154       opname = "+"; break;
2155     case MINUS_EXPR:
2156       opname = "-"; break;
2157     case MULT_EXPR:
2158       opname = "*"; break;
2159     case MAX_EXPR:
2160       opname = "max"; break;
2161     case MIN_EXPR:
2162       opname = "min"; break;
2163     case EQ_EXPR:
2164       opname = "=="; break;
2165     case NE_EXPR:
2166       opname = "!="; break;
2167     case LE_EXPR:
2168       opname = "<="; break;
2169     case GE_EXPR:
2170       opname = ">="; break;
2171     case LT_EXPR:
2172       opname = "<"; break;
2173     case GT_EXPR:
2174       opname = ">"; break;
2175     case LSHIFT_EXPR:
2176       opname = "<<"; break;
2177     case RSHIFT_EXPR:
2178       opname = ">>"; break;
2179     case TRUNC_MOD_EXPR:
2180     case FLOOR_MOD_EXPR:
2181       opname = "%"; break;
2182     case TRUNC_DIV_EXPR:
2183     case FLOOR_DIV_EXPR:
2184       opname = "/"; break;
2185     case BIT_AND_EXPR:
2186       opname = "&"; break;
2187     case BIT_IOR_EXPR:
2188       opname = "|"; break;
2189     case TRUTH_ANDIF_EXPR:
2190       opname = "&&"; break;
2191     case TRUTH_ORIF_EXPR:
2192       opname = "||"; break;
2193     case BIT_XOR_EXPR:
2194       opname = "^"; break;
2195     default:
2196       gcc_unreachable ();
2197     }
2198   error ("invalid operands to binary %s", opname);
2199 }
2200 \f
2201 /* Subroutine of build_binary_op, used for comparison operations.
2202    See if the operands have both been converted from subword integer types
2203    and, if so, perhaps change them both back to their original type.
2204    This function is also responsible for converting the two operands
2205    to the proper common type for comparison.
2206
2207    The arguments of this function are all pointers to local variables
2208    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2209    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2210
2211    If this function returns nonzero, it means that the comparison has
2212    a constant value.  What this function returns is an expression for
2213    that value.  */
2214
2215 tree
2216 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2217                  enum tree_code *rescode_ptr)
2218 {
2219   tree type;
2220   tree op0 = *op0_ptr;
2221   tree op1 = *op1_ptr;
2222   int unsignedp0, unsignedp1;
2223   int real1, real2;
2224   tree primop0, primop1;
2225   enum tree_code code = *rescode_ptr;
2226
2227   /* Throw away any conversions to wider types
2228      already present in the operands.  */
2229
2230   primop0 = get_narrower (op0, &unsignedp0);
2231   primop1 = get_narrower (op1, &unsignedp1);
2232
2233   /* Handle the case that OP0 does not *contain* a conversion
2234      but it *requires* conversion to FINAL_TYPE.  */
2235
2236   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2237     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2238   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2239     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2240
2241   /* If one of the operands must be floated, we cannot optimize.  */
2242   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2243   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2244
2245   /* If first arg is constant, swap the args (changing operation
2246      so value is preserved), for canonicalization.  Don't do this if
2247      the second arg is 0.  */
2248
2249   if (TREE_CONSTANT (primop0)
2250       && !integer_zerop (primop1) && !real_zerop (primop1))
2251     {
2252       tree tem = primop0;
2253       int temi = unsignedp0;
2254       primop0 = primop1;
2255       primop1 = tem;
2256       tem = op0;
2257       op0 = op1;
2258       op1 = tem;
2259       *op0_ptr = op0;
2260       *op1_ptr = op1;
2261       unsignedp0 = unsignedp1;
2262       unsignedp1 = temi;
2263       temi = real1;
2264       real1 = real2;
2265       real2 = temi;
2266
2267       switch (code)
2268         {
2269         case LT_EXPR:
2270           code = GT_EXPR;
2271           break;
2272         case GT_EXPR:
2273           code = LT_EXPR;
2274           break;
2275         case LE_EXPR:
2276           code = GE_EXPR;
2277           break;
2278         case GE_EXPR:
2279           code = LE_EXPR;
2280           break;
2281         default:
2282           break;
2283         }
2284       *rescode_ptr = code;
2285     }
2286
2287   /* If comparing an integer against a constant more bits wide,
2288      maybe we can deduce a value of 1 or 0 independent of the data.
2289      Or else truncate the constant now
2290      rather than extend the variable at run time.
2291
2292      This is only interesting if the constant is the wider arg.
2293      Also, it is not safe if the constant is unsigned and the
2294      variable arg is signed, since in this case the variable
2295      would be sign-extended and then regarded as unsigned.
2296      Our technique fails in this case because the lowest/highest
2297      possible unsigned results don't follow naturally from the
2298      lowest/highest possible values of the variable operand.
2299      For just EQ_EXPR and NE_EXPR there is another technique that
2300      could be used: see if the constant can be faithfully represented
2301      in the other operand's type, by truncating it and reextending it
2302      and see if that preserves the constant's value.  */
2303
2304   if (!real1 && !real2
2305       && TREE_CODE (primop1) == INTEGER_CST
2306       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2307     {
2308       int min_gt, max_gt, min_lt, max_lt;
2309       tree maxval, minval;
2310       /* 1 if comparison is nominally unsigned.  */
2311       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2312       tree val;
2313
2314       type = c_common_signed_or_unsigned_type (unsignedp0,
2315                                                TREE_TYPE (primop0));
2316
2317       maxval = TYPE_MAX_VALUE (type);
2318       minval = TYPE_MIN_VALUE (type);
2319
2320       if (unsignedp && !unsignedp0)
2321         *restype_ptr = c_common_signed_type (*restype_ptr);
2322
2323       if (TREE_TYPE (primop1) != *restype_ptr)
2324         {
2325           /* Convert primop1 to target type, but do not introduce
2326              additional overflow.  We know primop1 is an int_cst.  */
2327           primop1 = force_fit_type_double (*restype_ptr,
2328                                            TREE_INT_CST_LOW (primop1),
2329                                            TREE_INT_CST_HIGH (primop1), 0,
2330                                            TREE_OVERFLOW (primop1));
2331         }
2332       if (type != *restype_ptr)
2333         {
2334           minval = convert (*restype_ptr, minval);
2335           maxval = convert (*restype_ptr, maxval);
2336         }
2337
2338       if (unsignedp && unsignedp0)
2339         {
2340           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2341           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2342           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2343           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2344         }
2345       else
2346         {
2347           min_gt = INT_CST_LT (primop1, minval);
2348           max_gt = INT_CST_LT (primop1, maxval);
2349           min_lt = INT_CST_LT (minval, primop1);
2350           max_lt = INT_CST_LT (maxval, primop1);
2351         }
2352
2353       val = 0;
2354       /* This used to be a switch, but Genix compiler can't handle that.  */
2355       if (code == NE_EXPR)
2356         {
2357           if (max_lt || min_gt)
2358             val = truthvalue_true_node;
2359         }
2360       else if (code == EQ_EXPR)
2361         {
2362           if (max_lt || min_gt)
2363             val = truthvalue_false_node;
2364         }
2365       else if (code == LT_EXPR)
2366         {
2367           if (max_lt)
2368             val = truthvalue_true_node;
2369           if (!min_lt)
2370             val = truthvalue_false_node;
2371         }
2372       else if (code == GT_EXPR)
2373         {
2374           if (min_gt)
2375             val = truthvalue_true_node;
2376           if (!max_gt)
2377             val = truthvalue_false_node;
2378         }
2379       else if (code == LE_EXPR)
2380         {
2381           if (!max_gt)
2382             val = truthvalue_true_node;
2383           if (min_gt)
2384             val = truthvalue_false_node;
2385         }
2386       else if (code == GE_EXPR)
2387         {
2388           if (!min_lt)
2389             val = truthvalue_true_node;
2390           if (max_lt)
2391             val = truthvalue_false_node;
2392         }
2393
2394       /* If primop0 was sign-extended and unsigned comparison specd,
2395          we did a signed comparison above using the signed type bounds.
2396          But the comparison we output must be unsigned.
2397
2398          Also, for inequalities, VAL is no good; but if the signed
2399          comparison had *any* fixed result, it follows that the
2400          unsigned comparison just tests the sign in reverse
2401          (positive values are LE, negative ones GE).
2402          So we can generate an unsigned comparison
2403          against an extreme value of the signed type.  */
2404
2405       if (unsignedp && !unsignedp0)
2406         {
2407           if (val != 0)
2408             switch (code)
2409               {
2410               case LT_EXPR:
2411               case GE_EXPR:
2412                 primop1 = TYPE_MIN_VALUE (type);
2413                 val = 0;
2414                 break;
2415
2416               case LE_EXPR:
2417               case GT_EXPR:
2418                 primop1 = TYPE_MAX_VALUE (type);
2419                 val = 0;
2420                 break;
2421
2422               default:
2423                 break;
2424               }
2425           type = c_common_unsigned_type (type);
2426         }
2427
2428       if (TREE_CODE (primop0) != INTEGER_CST)
2429         {
2430           if (val == truthvalue_false_node)
2431             warning (0, "comparison is always false due to limited range of data type");
2432           if (val == truthvalue_true_node)
2433             warning (0, "comparison is always true due to limited range of data type");
2434         }
2435
2436       if (val != 0)
2437         {
2438           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2439           if (TREE_SIDE_EFFECTS (primop0))
2440             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2441           return val;
2442         }
2443
2444       /* Value is not predetermined, but do the comparison
2445          in the type of the operand that is not constant.
2446          TYPE is already properly set.  */
2447     }
2448
2449   /* If either arg is decimal float and the other is float, find the
2450      proper common type to use for comparison.  */
2451   else if (real1 && real2
2452            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2453                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2454     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2455
2456   else if (real1 && real2
2457            && (TYPE_PRECISION (TREE_TYPE (primop0))
2458                == TYPE_PRECISION (TREE_TYPE (primop1))))
2459     type = TREE_TYPE (primop0);
2460
2461   /* If args' natural types are both narrower than nominal type
2462      and both extend in the same manner, compare them
2463      in the type of the wider arg.
2464      Otherwise must actually extend both to the nominal
2465      common type lest different ways of extending
2466      alter the result.
2467      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2468
2469   else if (unsignedp0 == unsignedp1 && real1 == real2
2470            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2471            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2472     {
2473       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2474       type = c_common_signed_or_unsigned_type (unsignedp0
2475                                                || TYPE_UNSIGNED (*restype_ptr),
2476                                                type);
2477       /* Make sure shorter operand is extended the right way
2478          to match the longer operand.  */
2479       primop0
2480         = convert (c_common_signed_or_unsigned_type (unsignedp0,
2481                                                      TREE_TYPE (primop0)),
2482                    primop0);
2483       primop1
2484         = convert (c_common_signed_or_unsigned_type (unsignedp1,
2485                                                      TREE_TYPE (primop1)),
2486                    primop1);
2487     }
2488   else
2489     {
2490       /* Here we must do the comparison on the nominal type
2491          using the args exactly as we received them.  */
2492       type = *restype_ptr;
2493       primop0 = op0;
2494       primop1 = op1;
2495
2496       if (!real1 && !real2 && integer_zerop (primop1)
2497           && TYPE_UNSIGNED (*restype_ptr))
2498         {
2499           tree value = 0;
2500           switch (code)
2501             {
2502             case GE_EXPR:
2503               /* All unsigned values are >= 0, so we warn if extra warnings
2504                  are requested.  However, if OP0 is a constant that is
2505                  >= 0, the signedness of the comparison isn't an issue,
2506                  so suppress the warning.  */
2507               if (extra_warnings && !in_system_header
2508                   && !(TREE_CODE (primop0) == INTEGER_CST
2509                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2510                                                    primop0))))
2511                 warning (0, "comparison of unsigned expression >= 0 is always true");
2512               value = truthvalue_true_node;
2513               break;
2514
2515             case LT_EXPR:
2516               if (extra_warnings && !in_system_header
2517                   && !(TREE_CODE (primop0) == INTEGER_CST
2518                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2519                                                    primop0))))
2520                 warning (0, "comparison of unsigned expression < 0 is always false");
2521               value = truthvalue_false_node;
2522               break;
2523
2524             default:
2525               break;
2526             }
2527
2528           if (value != 0)
2529             {
2530               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2531               if (TREE_SIDE_EFFECTS (primop0))
2532                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2533                                primop0, value);
2534               return value;
2535             }
2536         }
2537     }
2538
2539   *op0_ptr = convert (type, primop0);
2540   *op1_ptr = convert (type, primop1);
2541
2542   *restype_ptr = truthvalue_type_node;
2543
2544   return 0;
2545 }
2546 \f
2547 /* Return a tree for the sum or difference (RESULTCODE says which)
2548    of pointer PTROP and integer INTOP.  */
2549
2550 tree
2551 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2552 {
2553   tree size_exp, ret;
2554
2555   /* The result is a pointer of the same type that is being added.  */
2556
2557   tree result_type = TREE_TYPE (ptrop);
2558
2559   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2560     {
2561       if (pedantic || warn_pointer_arith)
2562         pedwarn ("pointer of type %<void *%> used in arithmetic");
2563       size_exp = integer_one_node;
2564     }
2565   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2566     {
2567       if (pedantic || warn_pointer_arith)
2568         pedwarn ("pointer to a function used in arithmetic");
2569       size_exp = integer_one_node;
2570     }
2571   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2572     {
2573       if (pedantic || warn_pointer_arith)
2574         pedwarn ("pointer to member function used in arithmetic");
2575       size_exp = integer_one_node;
2576     }
2577   else
2578     size_exp = size_in_bytes (TREE_TYPE (result_type));
2579
2580   /* We are manipulating pointer values, so we don't need to warn
2581      about relying on undefined signed overflow.  We disable the
2582      warning here because we use integer types so fold won't know that
2583      they are really pointers.  */
2584   fold_defer_overflow_warnings ();
2585
2586   /* If what we are about to multiply by the size of the elements
2587      contains a constant term, apply distributive law
2588      and multiply that constant term separately.
2589      This helps produce common subexpressions.  */
2590
2591   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2592       && !TREE_CONSTANT (intop)
2593       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2594       && TREE_CONSTANT (size_exp)
2595       /* If the constant comes from pointer subtraction,
2596          skip this optimization--it would cause an error.  */
2597       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2598       /* If the constant is unsigned, and smaller than the pointer size,
2599          then we must skip this optimization.  This is because it could cause
2600          an overflow error if the constant is negative but INTOP is not.  */
2601       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2602           || (TYPE_PRECISION (TREE_TYPE (intop))
2603               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2604     {
2605       enum tree_code subcode = resultcode;
2606       tree int_type = TREE_TYPE (intop);
2607       if (TREE_CODE (intop) == MINUS_EXPR)
2608         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2609       /* Convert both subexpression types to the type of intop,
2610          because weird cases involving pointer arithmetic
2611          can result in a sum or difference with different type args.  */
2612       ptrop = build_binary_op (subcode, ptrop,
2613                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2614       intop = convert (int_type, TREE_OPERAND (intop, 0));
2615     }
2616
2617   /* Convert the integer argument to a type the same size as sizetype
2618      so the multiply won't overflow spuriously.  */
2619
2620   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2621       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2622     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2623                                              TYPE_UNSIGNED (sizetype)), intop);
2624
2625   /* Replace the integer argument with a suitable product by the object size.
2626      Do this multiplication as signed, then convert to the appropriate
2627      pointer type (actually unsigned integral).  */
2628
2629   intop = convert (result_type,
2630                    build_binary_op (MULT_EXPR, intop,
2631                                     convert (TREE_TYPE (intop), size_exp), 1));
2632
2633   /* Create the sum or difference.  */
2634   ret = fold_build2 (resultcode, result_type, ptrop, intop);
2635
2636   fold_undefer_and_ignore_overflow_warnings ();
2637
2638   return ret;
2639 }
2640 \f
2641 /* Return whether EXPR is a declaration whose address can never be
2642    NULL.  */
2643
2644 bool
2645 decl_with_nonnull_addr_p (tree expr)
2646 {
2647   return (DECL_P (expr)
2648           && (TREE_CODE (expr) == PARM_DECL
2649               || TREE_CODE (expr) == LABEL_DECL
2650               || !DECL_WEAK (expr)));
2651 }
2652
2653 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2654    or for an `if' or `while' statement or ?..: exp.  It should already
2655    have been validated to be of suitable type; otherwise, a bad
2656    diagnostic may result.
2657
2658    This preparation consists of taking the ordinary
2659    representation of an expression expr and producing a valid tree
2660    boolean expression describing whether expr is nonzero.  We could
2661    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2662    but we optimize comparisons, &&, ||, and !.
2663
2664    The resulting type should always be `truthvalue_type_node'.  */
2665
2666 tree
2667 c_common_truthvalue_conversion (tree expr)
2668 {
2669   switch (TREE_CODE (expr))
2670     {
2671     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
2672     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
2673     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2674     case ORDERED_EXPR: case UNORDERED_EXPR:
2675       if (TREE_TYPE (expr) == truthvalue_type_node)
2676         return expr;
2677       return build2 (TREE_CODE (expr), truthvalue_type_node,
2678                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2679
2680     case TRUTH_ANDIF_EXPR:
2681     case TRUTH_ORIF_EXPR:
2682     case TRUTH_AND_EXPR:
2683     case TRUTH_OR_EXPR:
2684     case TRUTH_XOR_EXPR:
2685       if (TREE_TYPE (expr) == truthvalue_type_node)
2686         return expr;
2687       return build2 (TREE_CODE (expr), truthvalue_type_node,
2688                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2689                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2690
2691     case TRUTH_NOT_EXPR:
2692       if (TREE_TYPE (expr) == truthvalue_type_node)
2693         return expr;
2694       return build1 (TREE_CODE (expr), truthvalue_type_node,
2695                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2696
2697     case ERROR_MARK:
2698       return expr;
2699
2700     case INTEGER_CST:
2701       return integer_zerop (expr) ? truthvalue_false_node
2702                                   : truthvalue_true_node;
2703
2704     case REAL_CST:
2705       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2706              ? truthvalue_true_node
2707              : truthvalue_false_node;
2708
2709     case FUNCTION_DECL:
2710       expr = build_unary_op (ADDR_EXPR, expr, 0);
2711       /* Fall through.  */
2712
2713     case ADDR_EXPR:
2714       {
2715         tree inner = TREE_OPERAND (expr, 0);
2716         if (decl_with_nonnull_addr_p (inner))
2717           {
2718             /* Common Ada/Pascal programmer's mistake.  */
2719             warning (OPT_Waddress,
2720                      "the address of %qD will always evaluate as %<true%>",
2721                      inner);
2722             return truthvalue_true_node;
2723           }
2724
2725         /* If we still have a decl, it is possible for its address to
2726            be NULL, so we cannot optimize.  */
2727         if (DECL_P (inner))
2728           {
2729             gcc_assert (DECL_WEAK (inner));
2730             break;
2731           }
2732
2733         if (TREE_SIDE_EFFECTS (inner))
2734           return build2 (COMPOUND_EXPR, truthvalue_type_node,
2735                          inner, truthvalue_true_node);
2736         else
2737           return truthvalue_true_node;
2738       }
2739
2740     case COMPLEX_EXPR:
2741       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2742                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2743                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2744                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2745                               0);
2746
2747     case NEGATE_EXPR:
2748     case ABS_EXPR:
2749     case FLOAT_EXPR:
2750       /* These don't change whether an object is nonzero or zero.  */
2751       return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2752
2753     case LROTATE_EXPR:
2754     case RROTATE_EXPR:
2755       /* These don't change whether an object is zero or nonzero, but
2756          we can't ignore them if their second arg has side-effects.  */
2757       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2758         return build2 (COMPOUND_EXPR, truthvalue_type_node,
2759                        TREE_OPERAND (expr, 1),
2760                        c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2761       else
2762         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2763
2764     case COND_EXPR:
2765       /* Distribute the conversion into the arms of a COND_EXPR.  */
2766       return fold_build3 (COND_EXPR, truthvalue_type_node,
2767                 TREE_OPERAND (expr, 0),
2768                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2769                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2770
2771     case CONVERT_EXPR:
2772     case NOP_EXPR:
2773       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2774          since that affects how `default_conversion' will behave.  */
2775       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2776           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2777         break;
2778       /* If this is widening the argument, we can ignore it.  */
2779       if (TYPE_PRECISION (TREE_TYPE (expr))
2780           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2781         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2782       break;
2783
2784     case MODIFY_EXPR:
2785       if (!TREE_NO_WARNING (expr)
2786           && warn_parentheses)
2787         {
2788           warning (OPT_Wparentheses,
2789                    "suggest parentheses around assignment used as truth value");
2790           TREE_NO_WARNING (expr) = 1;
2791         }
2792       break;
2793
2794     default:
2795       break;
2796     }
2797
2798   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2799     {
2800       tree t = save_expr (expr);
2801       return (build_binary_op
2802               ((TREE_SIDE_EFFECTS (expr)
2803                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2804         c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2805         c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2806                0));
2807     }
2808
2809   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2810 }
2811 \f
2812 static void def_builtin_1  (enum built_in_function fncode,
2813                             const char *name,
2814                             enum built_in_class fnclass,
2815                             tree fntype, tree libtype,
2816                             bool both_p, bool fallback_p, bool nonansi_p,
2817                             tree fnattrs, bool implicit_p);
2818
2819 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2820    down to the element type of an array.  */
2821
2822 tree
2823 c_build_qualified_type (tree type, int type_quals)
2824 {
2825   if (type == error_mark_node)
2826     return type;
2827
2828   if (TREE_CODE (type) == ARRAY_TYPE)
2829     {
2830       tree t;
2831       tree element_type = c_build_qualified_type (TREE_TYPE (type),
2832                                                   type_quals);
2833
2834       /* See if we already have an identically qualified type.  */
2835       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2836         {
2837           if (TYPE_QUALS (strip_array_types (t)) == type_quals
2838               && TYPE_NAME (t) == TYPE_NAME (type)
2839               && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2840               && attribute_list_equal (TYPE_ATTRIBUTES (t),
2841                                        TYPE_ATTRIBUTES (type)))
2842             break;
2843         }
2844       if (!t)
2845         {
2846           t = build_variant_type_copy (type);
2847           TREE_TYPE (t) = element_type;
2848         }
2849       return t;
2850     }
2851
2852   /* A restrict-qualified pointer type must be a pointer to object or
2853      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2854      REFERENCE_TYPEs, which is appropriate for C++.  */
2855   if ((type_quals & TYPE_QUAL_RESTRICT)
2856       && (!POINTER_TYPE_P (type)
2857           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2858     {
2859       error ("invalid use of %<restrict%>");
2860       type_quals &= ~TYPE_QUAL_RESTRICT;
2861     }
2862
2863   return build_qualified_type (type, type_quals);
2864 }
2865
2866 /* Apply the TYPE_QUALS to the new DECL.  */
2867
2868 void
2869 c_apply_type_quals_to_decl (int type_quals, tree decl)
2870 {
2871   tree type = TREE_TYPE (decl);
2872
2873   if (type == error_mark_node)
2874     return;
2875
2876   if (((type_quals & TYPE_QUAL_CONST)
2877        || (type && TREE_CODE (type) == REFERENCE_TYPE))
2878       /* An object declared 'const' is only readonly after it is
2879          initialized.  We don't have any way of expressing this currently,
2880          so we need to be conservative and unset TREE_READONLY for types
2881          with constructors.  Otherwise aliasing code will ignore stores in
2882          an inline constructor.  */
2883       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2884     TREE_READONLY (decl) = 1;
2885   if (type_quals & TYPE_QUAL_VOLATILE)
2886     {
2887       TREE_SIDE_EFFECTS (decl) = 1;
2888       TREE_THIS_VOLATILE (decl) = 1;
2889     }
2890   if (type_quals & TYPE_QUAL_RESTRICT)
2891     {
2892       while (type && TREE_CODE (type) == ARRAY_TYPE)
2893         /* Allow 'restrict' on arrays of pointers.
2894            FIXME currently we just ignore it.  */
2895         type = TREE_TYPE (type);
2896       if (!type
2897           || !POINTER_TYPE_P (type)
2898           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2899         error ("invalid use of %<restrict%>");
2900       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2901         /* Indicate we need to make a unique alias set for this pointer.
2902            We can't do it here because it might be pointing to an
2903            incomplete type.  */
2904         DECL_POINTER_ALIAS_SET (decl) = -2;
2905     }
2906 }
2907
2908 /* Hash function for the problem of multiple type definitions in
2909    different files.  This must hash all types that will compare
2910    equal via comptypes to the same value.  In practice it hashes
2911    on some of the simple stuff and leaves the details to comptypes.  */
2912
2913 static hashval_t
2914 c_type_hash (const void *p)
2915 {
2916   int i = 0;
2917   int shift, size;
2918   tree t = (tree) p;
2919   tree t2;
2920   switch (TREE_CODE (t))
2921     {
2922     /* For pointers, hash on pointee type plus some swizzling.  */
2923     case POINTER_TYPE:
2924       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2925     /* Hash on number of elements and total size.  */
2926     case ENUMERAL_TYPE:
2927       shift = 3;
2928       t2 = TYPE_VALUES (t);
2929       break;
2930     case RECORD_TYPE:
2931       shift = 0;
2932       t2 = TYPE_FIELDS (t);
2933       break;
2934     case QUAL_UNION_TYPE:
2935       shift = 1;
2936       t2 = TYPE_FIELDS (t);
2937       break;
2938     case UNION_TYPE:
2939       shift = 2;
2940       t2 = TYPE_FIELDS (t);
2941       break;
2942     default:
2943       gcc_unreachable ();
2944     }
2945   for (; t2; t2 = TREE_CHAIN (t2))
2946     i++;
2947   size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2948   return ((size << 24) | (i << shift));
2949 }
2950
2951 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2952
2953 /* Return the typed-based alias set for T, which may be an expression
2954    or a type.  Return -1 if we don't do anything special.  */
2955
2956 HOST_WIDE_INT
2957 c_common_get_alias_set (tree t)
2958 {
2959   tree u;
2960   PTR *slot;
2961
2962   /* Permit type-punning when accessing a union, provided the access
2963      is directly through the union.  For example, this code does not
2964      permit taking the address of a union member and then storing
2965      through it.  Even the type-punning allowed here is a GCC
2966      extension, albeit a common and useful one; the C standard says
2967      that such accesses have implementation-defined behavior.  */
2968   for (u = t;
2969        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2970        u = TREE_OPERAND (u, 0))
2971     if (TREE_CODE (u) == COMPONENT_REF
2972         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2973       return 0;
2974
2975   /* That's all the expressions we handle specially.  */
2976   if (!TYPE_P (t))
2977     return -1;
2978
2979   /* The C standard guarantees that any object may be accessed via an
2980      lvalue that has character type.  */
2981   if (t == char_type_node
2982       || t == signed_char_type_node
2983       || t == unsigned_char_type_node)
2984     return 0;
2985
2986   /* If it has the may_alias attribute, it can alias anything.  */
2987   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2988     return 0;
2989
2990   /* The C standard specifically allows aliasing between signed and
2991      unsigned variants of the same type.  We treat the signed
2992      variant as canonical.  */
2993   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2994     {
2995       tree t1 = c_common_signed_type (t);
2996
2997       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2998       if (t1 != t)
2999         return get_alias_set (t1);
3000     }
3001   else if (POINTER_TYPE_P (t))
3002     {
3003       tree t1;
3004
3005       /* Unfortunately, there is no canonical form of a pointer type.
3006          In particular, if we have `typedef int I', then `int *', and
3007          `I *' are different types.  So, we have to pick a canonical
3008          representative.  We do this below.
3009
3010          Technically, this approach is actually more conservative that
3011          it needs to be.  In particular, `const int *' and `int *'
3012          should be in different alias sets, according to the C and C++
3013          standard, since their types are not the same, and so,
3014          technically, an `int **' and `const int **' cannot point at
3015          the same thing.
3016
3017          But, the standard is wrong.  In particular, this code is
3018          legal C++:
3019
3020             int *ip;
3021             int **ipp = &ip;
3022             const int* const* cipp = ipp;
3023
3024          And, it doesn't make sense for that to be legal unless you
3025          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3026          the pointed-to types.  This issue has been reported to the
3027          C++ committee.  */
3028       t1 = build_type_no_quals (t);
3029       if (t1 != t)
3030         return get_alias_set (t1);
3031     }
3032
3033   /* Handle the case of multiple type nodes referring to "the same" type,
3034      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
3035      C90 is handled.  (In C99 type compatibility is not transitive, which
3036      complicates things mightily. The alias set splay trees can theoretically
3037      represent this, but insertion is tricky when you consider all the
3038      different orders things might arrive in.) */
3039
3040   if (c_language != clk_c || flag_isoc99)
3041     return -1;
3042
3043   /* Save time if there's only one input file.  */
3044   if (num_in_fnames == 1)
3045     return -1;
3046
3047   /* Pointers need special handling if they point to any type that
3048      needs special handling (below).  */
3049   if (TREE_CODE (t) == POINTER_TYPE)
3050     {
3051       tree t2;
3052       /* Find bottom type under any nested POINTERs.  */
3053       for (t2 = TREE_TYPE (t);
3054      TREE_CODE (t2) == POINTER_TYPE;
3055      t2 = TREE_TYPE (t2))
3056   ;
3057       if (TREE_CODE (t2) != RECORD_TYPE
3058     && TREE_CODE (t2) != ENUMERAL_TYPE
3059     && TREE_CODE (t2) != QUAL_UNION_TYPE
3060     && TREE_CODE (t2) != UNION_TYPE)
3061   return -1;
3062       if (TYPE_SIZE (t2) == 0)
3063   return -1;
3064     }
3065   /* These are the only cases that need special handling.  */
3066   if (TREE_CODE (t) != RECORD_TYPE
3067       && TREE_CODE (t) != ENUMERAL_TYPE
3068       && TREE_CODE (t) != QUAL_UNION_TYPE
3069       && TREE_CODE (t) != UNION_TYPE
3070       && TREE_CODE (t) != POINTER_TYPE)
3071     return -1;
3072   /* Undefined? */
3073   if (TYPE_SIZE (t) == 0)
3074     return -1;
3075
3076   /* Look up t in hash table.  Only one of the compatible types within each
3077      alias set is recorded in the table.  */
3078   if (!type_hash_table)
3079     type_hash_table = htab_create_ggc (1021, c_type_hash,
3080             (htab_eq) lang_hooks.types_compatible_p,
3081             NULL);
3082   slot = htab_find_slot (type_hash_table, t, INSERT);
3083   if (*slot != NULL)
3084     {
3085       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3086       return TYPE_ALIAS_SET ((tree)*slot);
3087     }
3088   else
3089     /* Our caller will assign and record (in t) a new alias set; all we need
3090        to do is remember t in the hash table.  */
3091     *slot = t;
3092
3093   return -1;
3094 }
3095 \f
3096 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3097    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
3098    flag controls whether we should diagnose possibly ill-formed
3099    constructs or not.  */
3100
3101 tree
3102 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3103 {
3104   const char *op_name;
3105   tree value = NULL;
3106   enum tree_code type_code = TREE_CODE (type);
3107
3108   op_name = is_sizeof ? "sizeof" : "__alignof__";
3109
3110   if (type_code == FUNCTION_TYPE)
3111     {
3112       if (is_sizeof)
3113         {
3114           if (complain && (pedantic || warn_pointer_arith))
3115             pedwarn ("invalid application of %<sizeof%> to a function type");
3116           value = size_one_node;
3117         }
3118       else
3119         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3120     }
3121   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3122     {
3123       if (type_code == VOID_TYPE
3124           && complain && (pedantic || warn_pointer_arith))
3125         pedwarn ("invalid application of %qs to a void type", op_name);
3126       value = size_one_node;
3127     }
3128   else if (!COMPLETE_TYPE_P (type))
3129     {
3130       if (complain)
3131         error ("invalid application of %qs to incomplete type %qT ",
3132                op_name, type);
3133       value = size_zero_node;
3134     }
3135   else
3136     {
3137       if (is_sizeof)
3138         /* Convert in case a char is more than one unit.  */
3139         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3140                             size_int (TYPE_PRECISION (char_type_node)
3141                                       / BITS_PER_UNIT));
3142       else
3143         value = size_int (TYPE_ALIGN_UNIT (type));
3144     }
3145
3146   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3147      TYPE_IS_SIZETYPE means that certain things (like overflow) will
3148      never happen.  However, this node should really have type
3149      `size_t', which is just a typedef for an ordinary integer type.  */
3150   value = fold_convert (size_type_node, value);
3151   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3152
3153   return value;
3154 }
3155
3156 /* Implement the __alignof keyword: Return the minimum required
3157    alignment of EXPR, measured in bytes.  For VAR_DECL's and
3158    FIELD_DECL's return DECL_ALIGN (which can be set from an
3159    "aligned" __attribute__ specification).  */
3160
3161 tree
3162 c_alignof_expr (tree expr)
3163 {
3164   tree t;
3165
3166   if (TREE_CODE (expr) == VAR_DECL)
3167     t = size_int (DECL_ALIGN_UNIT (expr));
3168
3169   else if (TREE_CODE (expr) == COMPONENT_REF
3170            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3171     {
3172       error ("%<__alignof%> applied to a bit-field");
3173       t = size_one_node;
3174     }
3175   else if (TREE_CODE (expr) == COMPONENT_REF
3176            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3177     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3178
3179   else if (TREE_CODE (expr) == INDIRECT_REF)
3180     {
3181       tree t = TREE_OPERAND (expr, 0);
3182       tree best = t;
3183       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3184
3185       while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3186              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3187         {
3188           int thisalign;
3189
3190           t = TREE_OPERAND (t, 0);
3191           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3192           if (thisalign > bestalign)
3193             best = t, bestalign = thisalign;
3194         }
3195       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3196     }
3197   else
3198     return c_alignof (TREE_TYPE (expr));
3199
3200   return fold_convert (size_type_node, t);
3201 }
3202 \f
3203 /* Handle C and C++ default attributes.  */
3204
3205 enum built_in_attribute
3206 {
3207 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3208 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3209 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3210 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3211 #include "builtin-attrs.def"
3212 #undef DEF_ATTR_NULL_TREE
3213 #undef DEF_ATTR_INT
3214 #undef DEF_ATTR_IDENT
3215 #undef DEF_ATTR_TREE_LIST
3216   ATTR_LAST
3217 };
3218
3219 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3220
3221 static void c_init_attributes (void);
3222
3223 enum c_builtin_type
3224 {
3225 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3226 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3227 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3228 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3229 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3230 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3231 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3232 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3233 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3234 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3235 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3236 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3237 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3238 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3239 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3240   NAME,
3241 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3242 #include "builtin-types.def"
3243 #undef DEF_PRIMITIVE_TYPE
3244 #undef DEF_FUNCTION_TYPE_0
3245 #undef DEF_FUNCTION_TYPE_1
3246 #undef DEF_FUNCTION_TYPE_2
3247 #undef DEF_FUNCTION_TYPE_3
3248 #undef DEF_FUNCTION_TYPE_4
3249 #undef DEF_FUNCTION_TYPE_5
3250 #undef DEF_FUNCTION_TYPE_6
3251 #undef DEF_FUNCTION_TYPE_7
3252 #undef DEF_FUNCTION_TYPE_VAR_0
3253 #undef DEF_FUNCTION_TYPE_VAR_1
3254 #undef DEF_FUNCTION_TYPE_VAR_2
3255 #undef DEF_FUNCTION_TYPE_VAR_3
3256 #undef DEF_FUNCTION_TYPE_VAR_4
3257 #undef DEF_FUNCTION_TYPE_VAR_5
3258 #undef DEF_POINTER_TYPE
3259   BT_LAST
3260 };
3261
3262 typedef enum c_builtin_type builtin_type;
3263
3264 /* A temporary array for c_common_nodes_and_builtins.  Used in
3265    communication with def_fn_type.  */
3266 static tree builtin_types[(int) BT_LAST + 1];
3267
3268 /* A helper function for c_common_nodes_and_builtins.  Build function type
3269    for DEF with return type RET and N arguments.  If VAR is true, then the
3270    function should be variadic after those N arguments.
3271
3272    Takes special care not to ICE if any of the types involved are
3273    error_mark_node, which indicates that said type is not in fact available
3274    (see builtin_type_for_size).  In which case the function type as a whole
3275    should be error_mark_node.  */
3276
3277 static void
3278 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3279 {
3280   tree args = NULL, t;
3281   va_list list;
3282   int i;
3283
3284   va_start (list, n);
3285   for (i = 0; i < n; ++i)
3286     {
3287       builtin_type a = va_arg (list, builtin_type);
3288       t = builtin_types[a];
3289       if (t == error_mark_node)
3290         goto egress;
3291       args = tree_cons (NULL_TREE, t, args);
3292     }
3293   va_end (list);
3294
3295   args = nreverse (args);
3296   if (!var)
3297     args = chainon (args, void_list_node);
3298
3299   t = builtin_types[ret];
3300   if (t == error_mark_node)
3301     goto egress;
3302   t = build_function_type (t, args);
3303
3304  egress:
3305   builtin_types[def] = t;
3306 }
3307
3308 /* Build builtin functions common to both C and C++ language
3309    frontends.  */
3310
3311 static void
3312 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3313 {
3314 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3315   builtin_types[ENUM] = VALUE;
3316 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3317   def_fn_type (ENUM, RETURN, 0, 0);
3318 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3319   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3320 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3321   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3322 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3323   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3324 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3325   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3326 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3327   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3328 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3329                             ARG6)                                       \
3330   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3331 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3332                             ARG6, ARG7)                                 \
3333   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3334 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3335   def_fn_type (ENUM, RETURN, 1, 0);
3336 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3337   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3338 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3339   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3340 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3341   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3342 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3343   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3344 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3345   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3346 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3347   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3348
3349 #include "builtin-types.def"
3350
3351 #undef DEF_PRIMITIVE_TYPE
3352 #undef DEF_FUNCTION_TYPE_1
3353 #undef DEF_FUNCTION_TYPE_2
3354 #undef DEF_FUNCTION_TYPE_3
3355 #undef DEF_FUNCTION_TYPE_4
3356 #undef DEF_FUNCTION_TYPE_5
3357 #undef DEF_FUNCTION_TYPE_6
3358 #undef DEF_FUNCTION_TYPE_VAR_0
3359 #undef DEF_FUNCTION_TYPE_VAR_1
3360 #undef DEF_FUNCTION_TYPE_VAR_2
3361 #undef DEF_FUNCTION_TYPE_VAR_3
3362 #undef DEF_FUNCTION_TYPE_VAR_4
3363 #undef DEF_FUNCTION_TYPE_VAR_5
3364 #undef DEF_POINTER_TYPE
3365   builtin_types[(int) BT_LAST] = NULL_TREE;
3366
3367   c_init_attributes ();
3368
3369 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3370                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
3371   if (NAME && COND)                                                     \
3372     def_builtin_1 (ENUM, NAME, CLASS,                                   \
3373                    builtin_types[(int) TYPE],                           \
3374                    builtin_types[(int) LIBTYPE],                        \
3375                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
3376                    built_in_attributes[(int) ATTRS], IMPLICIT);
3377 #include "builtins.def"
3378 #undef DEF_BUILTIN
3379
3380   build_common_builtin_nodes ();
3381
3382   targetm.init_builtins ();
3383   if (flag_mudflap)
3384     mudflap_init ();
3385 }
3386
3387 /* Build tree nodes and builtin functions common to both C and C++ language
3388    frontends.  */
3389
3390 void
3391 c_common_nodes_and_builtins (void)
3392 {
3393   int wchar_type_size;
3394   tree array_domain_type;
3395   tree va_list_ref_type_node;
3396   tree va_list_arg_type_node;
3397
3398   /* Define `int' and `char' first so that dbx will output them first.  */
3399   record_builtin_type (RID_INT, NULL, integer_type_node);
3400   record_builtin_type (RID_CHAR, "char", char_type_node);
3401
3402   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
3403      "unsigned long", "long long unsigned" and "unsigned short" were in C++
3404      but not C.  Are the conditionals here needed?  */
3405   if (c_dialect_cxx ())
3406     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3407   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3408   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3409   record_builtin_type (RID_MAX, "long unsigned int",
3410                        long_unsigned_type_node);
3411   if (c_dialect_cxx ())
3412     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3413   record_builtin_type (RID_MAX, "long long int",
3414                        long_long_integer_type_node);
3415   record_builtin_type (RID_MAX, "long long unsigned int",
3416                        long_long_unsigned_type_node);
3417   if (c_dialect_cxx ())
3418     record_builtin_type (RID_MAX, "long long unsigned",
3419                          long_long_unsigned_type_node);
3420   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3421   record_builtin_type (RID_MAX, "short unsigned int",
3422                        short_unsigned_type_node);
3423   if (c_dialect_cxx ())
3424     record_builtin_type (RID_MAX, "unsigned short",
3425                          short_unsigned_type_node);
3426
3427   /* Define both `signed char' and `unsigned char'.  */
3428   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3429   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3430
3431   /* These are types that c_common_type_for_size and
3432      c_common_type_for_mode use.  */
3433   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3434                                          intQI_type_node));
3435   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3436                                          intHI_type_node));
3437   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3438                                          intSI_type_node));
3439   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3440                                          intDI_type_node));
3441 #if HOST_BITS_PER_WIDE_INT >= 64
3442   if (targetm.scalar_mode_supported_p (TImode))
3443     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3444                                            get_identifier ("__int128_t"),
3445                                            intTI_type_node));
3446 #endif
3447   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3448                                          unsigned_intQI_type_node));
3449   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3450                                          unsigned_intHI_type_node));
3451   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3452                                          unsigned_intSI_type_node));
3453   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3454                                          unsigned_intDI_type_node));
3455 #if HOST_BITS_PER_WIDE_INT >= 64
3456   if (targetm.scalar_mode_supported_p (TImode))
3457     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3458                                            get_identifier ("__uint128_t"),
3459                                            unsigned_intTI_type_node));
3460 #endif
3461
3462   /* Create the widest literal types.  */
3463   widest_integer_literal_type_node
3464     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3465   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3466                                          widest_integer_literal_type_node));
3467
3468   widest_unsigned_literal_type_node
3469     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3470   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3471                                          widest_unsigned_literal_type_node));
3472
3473   /* `unsigned long' is the standard type for sizeof.
3474      Note that stddef.h uses `unsigned long',
3475      and this must agree, even if long and int are the same size.  */
3476   size_type_node =
3477     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3478   signed_size_type_node = c_common_signed_type (size_type_node);
3479   set_sizetype (size_type_node);
3480
3481   pid_type_node =
3482     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3483
3484   build_common_tree_nodes_2 (flag_short_double);
3485
3486   record_builtin_type (RID_FLOAT, NULL, float_type_node);
3487   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3488   record_builtin_type (RID_MAX, "long double", long_double_type_node);
3489
3490   /* Only supported decimal floating point extension if the target
3491      actually supports underlying modes. */
3492   if (targetm.scalar_mode_supported_p (SDmode)
3493       && targetm.scalar_mode_supported_p (DDmode)
3494       && targetm.scalar_mode_supported_p (TDmode))
3495     {
3496       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3497       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3498       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3499     }
3500
3501   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3502                                          get_identifier ("complex int"),
3503                                          complex_integer_type_node));
3504   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3505                                          get_identifier ("complex float"),
3506                                          complex_float_type_node));
3507   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3508                                          get_identifier ("complex double"),
3509                                          complex_double_type_node));
3510   lang_hooks.decls.pushdecl
3511     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3512                  complex_long_double_type_node));
3513
3514   if (c_dialect_cxx ())
3515     /* For C++, make fileptr_type_node a distinct void * type until
3516        FILE type is defined.  */
3517     fileptr_type_node = build_variant_type_copy (ptr_type_node);
3518
3519   record_builtin_type (RID_VOID, NULL, void_type_node);
3520
3521   /* Set the TYPE_NAME for any variants that were built before
3522      record_builtin_type gave names to the built-in types. */
3523   {
3524     tree void_name = TYPE_NAME (void_type_node);
3525     TYPE_NAME (void_type_node) = NULL_TREE;
3526     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3527       = void_name;
3528     TYPE_NAME (void_type_node) = void_name;
3529   }
3530
3531   /* This node must not be shared.  */
3532   void_zero_node = make_node (INTEGER_CST);
3533   TREE_TYPE (void_zero_node) = void_type_node;
3534
3535   void_list_node = build_void_list_node ();
3536
3537   /* Make a type to be the domain of a few array types
3538      whose domains don't really matter.
3539      200 is small enough that it always fits in size_t
3540      and large enough that it can hold most function names for the
3541      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3542   array_domain_type = build_index_type (size_int (200));
3543
3544   /* Make a type for arrays of characters.
3545      With luck nothing will ever really depend on the length of this
3546      array type.  */
3547   char_array_type_node
3548     = build_array_type (char_type_node, array_domain_type);
3549
3550   /* Likewise for arrays of ints.  */
3551   int_array_type_node
3552     = build_array_type (integer_type_node, array_domain_type);
3553
3554   string_type_node = build_pointer_type (char_type_node);
3555   const_string_type_node
3556     = build_pointer_type (build_qualified_type
3557                           (char_type_node, TYPE_QUAL_CONST));
3558
3559   /* This is special for C++ so functions can be overloaded.  */
3560   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3561   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3562   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3563   if (c_dialect_cxx ())
3564     {
3565       if (TYPE_UNSIGNED (wchar_type_node))
3566         wchar_type_node = make_unsigned_type (wchar_type_size);
3567       else
3568         wchar_type_node = make_signed_type (wchar_type_size);
3569       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3570     }
3571   else
3572     {
3573       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3574       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3575     }
3576
3577   /* This is for wide string constants.  */
3578   wchar_array_type_node
3579     = build_array_type (wchar_type_node, array_domain_type);
3580
3581   wint_type_node =
3582     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3583
3584   intmax_type_node =
3585     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3586   uintmax_type_node =
3587     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3588
3589   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3590   ptrdiff_type_node
3591     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3592   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3593
3594   lang_hooks.decls.pushdecl
3595     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3596                  va_list_type_node));
3597
3598   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3599     {
3600       va_list_arg_type_node = va_list_ref_type_node =
3601         build_pointer_type (TREE_TYPE (va_list_type_node));
3602     }
3603   else
3604     {
3605       va_list_arg_type_node = va_list_type_node;
3606       va_list_ref_type_node = build_reference_type (va_list_type_node);
3607     }
3608
3609   if (!flag_preprocess_only)
3610     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3611
3612   main_identifier_node = get_identifier ("main");
3613
3614   /* Create the built-in __null node.  It is important that this is
3615      not shared.  */
3616   null_node = make_node (INTEGER_CST);
3617   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3618
3619   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
3620   memset (builtin_types, 0, sizeof (builtin_types));
3621 }
3622
3623 /* Look up the function in built_in_decls that corresponds to DECL
3624    and set ASMSPEC as its user assembler name.  DECL must be a
3625    function decl that declares a builtin.  */
3626
3627 void
3628 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3629 {
3630   tree builtin;
3631   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3632               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3633               && asmspec != 0);
3634
3635   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3636   set_user_assembler_name (builtin, asmspec);
3637   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3638     init_block_move_fn (asmspec);
3639   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3640     init_block_clear_fn (asmspec);
3641 }
3642
3643 /* The number of named compound-literals generated thus far.  */
3644 static GTY(()) int compound_literal_number;
3645
3646 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
3647
3648 void
3649 set_compound_literal_name (tree decl)
3650 {
3651   char *name;
3652   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3653                            compound_literal_number);
3654   compound_literal_number++;
3655   DECL_NAME (decl) = get_identifier (name);
3656 }
3657
3658 tree
3659 build_va_arg (tree expr, tree type)
3660 {
3661   return build1 (VA_ARG_EXPR, type, expr);
3662 }
3663
3664
3665 /* Linked list of disabled built-in functions.  */
3666
3667 typedef struct disabled_builtin
3668 {
3669   const char *name;
3670   struct disabled_builtin *next;
3671 } disabled_builtin;
3672 static disabled_builtin *disabled_builtins = NULL;
3673
3674 static bool builtin_function_disabled_p (const char *);
3675
3676 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3677    begins with "__builtin_", give an error.  */
3678
3679 void
3680 disable_builtin_function (const char *name)
3681 {
3682   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3683     error ("cannot disable built-in function %qs", name);
3684   else
3685     {
3686       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3687       new_disabled_builtin->name = name;
3688       new_disabled_builtin->next = disabled_builtins;
3689       disabled_builtins = new_disabled_builtin;
3690     }
3691 }
3692
3693
3694 /* Return true if the built-in function NAME has been disabled, false
3695    otherwise.  */
3696
3697 static bool
3698 builtin_function_disabled_p (const char *name)
3699 {
3700   disabled_builtin *p;
3701   for (p = disabled_builtins; p != NULL; p = p->next)
3702     {
3703       if (strcmp (name, p->name) == 0)
3704         return true;
3705     }
3706   return false;
3707 }
3708
3709
3710 /* Worker for DEF_BUILTIN.
3711    Possibly define a builtin function with one or two names.
3712    Does not declare a non-__builtin_ function if flag_no_builtin, or if
3713    nonansi_p and flag_no_nonansi_builtin.  */
3714
3715 static void
3716 def_builtin_1 (enum built_in_function fncode,
3717                const char *name,
3718                enum built_in_class fnclass,
3719                tree fntype, tree libtype,
3720                bool both_p, bool fallback_p, bool nonansi_p,
3721                tree fnattrs, bool implicit_p)
3722 {
3723   tree decl;
3724   const char *libname;
3725
3726   if (fntype == error_mark_node)
3727     return;
3728
3729   gcc_assert ((!both_p && !fallback_p)
3730               || !strncmp (name, "__builtin_",
3731                            strlen ("__builtin_")));
3732
3733   libname = name + strlen ("__builtin_");
3734   decl = add_builtin_function (name, fntype, fncode, fnclass,
3735                                (fallback_p ? libname : NULL),
3736                                fnattrs);
3737   if (both_p
3738       && !flag_no_builtin && !builtin_function_disabled_p (libname)
3739       && !(nonansi_p && flag_no_nonansi_builtin))
3740     add_builtin_function (libname, libtype, fncode, fnclass,
3741                           NULL, fnattrs);
3742
3743   built_in_decls[(int) fncode] = decl;
3744   if (implicit_p)
3745     implicit_built_in_decls[(int) fncode] = decl;
3746 }
3747 \f
3748 /* Nonzero if the type T promotes to int.  This is (nearly) the
3749    integral promotions defined in ISO C99 6.3.1.1/2.  */
3750
3751 bool
3752 c_promoting_integer_type_p (tree t)
3753 {
3754   switch (TREE_CODE (t))
3755     {
3756     case INTEGER_TYPE:
3757       return (TYPE_MAIN_VARIANT (t) == char_type_node
3758               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3759               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3760               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3761               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3762               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3763
3764     case ENUMERAL_TYPE:
3765       /* ??? Technically all enumerations not larger than an int
3766          promote to an int.  But this is used along code paths
3767          that only want to notice a size change.  */
3768       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3769
3770     case BOOLEAN_TYPE:
3771       return 1;
3772
3773     default:
3774       return 0;
3775     }
3776 }
3777
3778 /* Return 1 if PARMS specifies a fixed number of parameters
3779    and none of their types is affected by default promotions.  */
3780
3781 int
3782 self_promoting_args_p (tree parms)
3783 {
3784   tree t;
3785   for (t = parms; t; t = TREE_CHAIN (t))
3786     {
3787       tree type = TREE_VALUE (t);
3788
3789       if (type == error_mark_node)
3790         continue;
3791
3792       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3793         return 0;
3794
3795       if (type == 0)
3796         return 0;
3797
3798       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3799         return 0;
3800
3801       if (c_promoting_integer_type_p (type))
3802         return 0;
3803     }
3804   return 1;
3805 }
3806
3807 /* Recursively examines the array elements of TYPE, until a non-array
3808    element type is found.  */
3809
3810 tree
3811 strip_array_types (tree type)
3812 {
3813   while (TREE_CODE (type) == ARRAY_TYPE)
3814     type = TREE_TYPE (type);
3815
3816   return type;
3817 }
3818
3819 /* Recursively remove any '*' or '&' operator from TYPE.  */
3820 tree
3821 strip_pointer_operator (tree t)
3822 {
3823   while (POINTER_TYPE_P (t))
3824     t = TREE_TYPE (t);
3825   return t;
3826 }
3827
3828 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3829    representing case labels, or NULL_TREE for a `default' label.
3830    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3831    K2, and 0 if K1 and K2 are equal.  */
3832
3833 int
3834 case_compare (splay_tree_key k1, splay_tree_key k2)
3835 {
3836   /* Consider a NULL key (such as arises with a `default' label) to be
3837      smaller than anything else.  */
3838   if (!k1)
3839     return k2 ? -1 : 0;
3840   else if (!k2)
3841     return k1 ? 1 : 0;
3842
3843   return tree_int_cst_compare ((tree) k1, (tree) k2);
3844 }
3845
3846 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3847    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3848    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3849    case label was declared using the usual C/C++ syntax, rather than
3850    the GNU case range extension.  CASES is a tree containing all the
3851    case ranges processed so far; COND is the condition for the
3852    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
3853    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
3854
3855 tree
3856 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3857                   tree low_value, tree high_value)
3858 {
3859   tree type;
3860   tree label;
3861   tree case_label;
3862   splay_tree_node node;
3863
3864   /* Create the LABEL_DECL itself.  */
3865   label = create_artificial_label ();
3866
3867   /* If there was an error processing the switch condition, bail now
3868      before we get more confused.  */
3869   if (!cond || cond == error_mark_node)
3870     goto error_out;
3871
3872   if ((low_value && TREE_TYPE (low_value)
3873        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3874       || (high_value && TREE_TYPE (high_value)
3875           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3876     {
3877       error ("pointers are not permitted as case values");
3878       goto error_out;
3879     }
3880
3881   /* Case ranges are a GNU extension.  */
3882   if (high_value && pedantic)
3883     pedwarn ("range expressions in switch statements are non-standard");
3884
3885   type = TREE_TYPE (cond);
3886   if (low_value)
3887     {
3888       low_value = check_case_value (low_value);
3889       low_value = convert_and_check (type, low_value);
3890       if (low_value == error_mark_node)
3891         goto error_out;
3892     }
3893   if (high_value)
3894     {
3895       high_value = check_case_value (high_value);
3896       high_value = convert_and_check (type, high_value);
3897       if (high_value == error_mark_node)
3898         goto error_out;
3899     }
3900
3901   if (low_value && high_value)
3902     {
3903       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3904          really a case range, even though it was written that way.
3905          Remove the HIGH_VALUE to simplify later processing.  */
3906       if (tree_int_cst_equal (low_value, high_value))
3907         high_value = NULL_TREE;
3908       else if (!tree_int_cst_lt (low_value, high_value))
3909         warning (0, "empty range specified");
3910     }
3911
3912   /* See if the case is in range of the type of the original testing
3913      expression.  If both low_value and high_value are out of range,
3914      don't insert the case label and return NULL_TREE.  */
3915   if (low_value
3916       && !check_case_bounds (type, orig_type,
3917                              &low_value, high_value ? &high_value : NULL))
3918     return NULL_TREE;
3919
3920   /* Look up the LOW_VALUE in the table of case labels we already
3921      have.  */
3922   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3923   /* If there was not an exact match, check for overlapping ranges.
3924      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3925      that's a `default' label and the only overlap is an exact match.  */
3926   if (!node && (low_value || high_value))
3927     {
3928       splay_tree_node low_bound;
3929       splay_tree_node high_bound;
3930
3931       /* Even though there wasn't an exact match, there might be an
3932          overlap between this case range and another case range.
3933          Since we've (inductively) not allowed any overlapping case
3934          ranges, we simply need to find the greatest low case label
3935          that is smaller that LOW_VALUE, and the smallest low case
3936          label that is greater than LOW_VALUE.  If there is an overlap
3937          it will occur in one of these two ranges.  */
3938       low_bound = splay_tree_predecessor (cases,
3939                                           (splay_tree_key) low_value);
3940       high_bound = splay_tree_successor (cases,
3941                                          (splay_tree_key) low_value);
3942
3943       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3944          the LOW_VALUE, so there is no need to check unless the
3945          LOW_BOUND is in fact itself a case range.  */
3946       if (low_bound
3947           && CASE_HIGH ((tree) low_bound->value)
3948           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3949                                     low_value) >= 0)
3950         node = low_bound;
3951       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3952          range is bigger than the low end of the current range, so we
3953          are only interested if the current range is a real range, and
3954          not an ordinary case label.  */
3955       else if (high_bound
3956                && high_value
3957                && (tree_int_cst_compare ((tree) high_bound->key,
3958                                          high_value)
3959                    <= 0))
3960         node = high_bound;
3961     }
3962   /* If there was an overlap, issue an error.  */
3963   if (node)
3964     {
3965       tree duplicate = CASE_LABEL ((tree) node->value);
3966
3967       if (high_value)
3968         {
3969           error ("duplicate (or overlapping) case value");
3970           error ("%Jthis is the first entry overlapping that value", duplicate);
3971         }
3972       else if (low_value)
3973         {
3974           error ("duplicate case value") ;
3975           error ("%Jpreviously used here", duplicate);
3976         }
3977       else
3978         {
3979           error ("multiple default labels in one switch");
3980           error ("%Jthis is the first default label", duplicate);
3981         }
3982       goto error_out;
3983     }
3984
3985   /* Add a CASE_LABEL to the statement-tree.  */
3986   case_label = add_stmt (build_case_label (low_value, high_value, label));
3987   /* Register this case label in the splay tree.  */
3988   splay_tree_insert (cases,
3989                      (splay_tree_key) low_value,
3990                      (splay_tree_value) case_label);
3991
3992   return case_label;
3993
3994  error_out:
3995   /* Add a label so that the back-end doesn't think that the beginning of
3996      the switch is unreachable.  Note that we do not add a case label, as
3997      that just leads to duplicates and thence to failure later on.  */
3998   if (!cases->root)
3999     {
4000       tree t = create_artificial_label ();
4001       add_stmt (build_stmt (LABEL_EXPR, t));
4002     }
4003   return error_mark_node;
4004 }
4005
4006 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4007    Used to verify that case values match up with enumerator values.  */
4008
4009 static void
4010 match_case_to_enum_1 (tree key, tree type, tree label)
4011 {
4012   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4013
4014   /* ??? Not working too hard to print the double-word value.
4015      Should perhaps be done with %lwd in the diagnostic routines?  */
4016   if (TREE_INT_CST_HIGH (key) == 0)
4017     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4018               TREE_INT_CST_LOW (key));
4019   else if (!TYPE_UNSIGNED (type)
4020            && TREE_INT_CST_HIGH (key) == -1
4021            && TREE_INT_CST_LOW (key) != 0)
4022     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4023               -TREE_INT_CST_LOW (key));
4024   else
4025     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4026               TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
4027
4028   if (TYPE_NAME (type) == 0)
4029     warning (0, "%Jcase value %qs not in enumerated type",
4030              CASE_LABEL (label), buf);
4031   else
4032     warning (0, "%Jcase value %qs not in enumerated type %qT",
4033              CASE_LABEL (label), buf, type);
4034 }
4035
4036 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4037    Used to verify that case values match up with enumerator values.  */
4038
4039 static int
4040 match_case_to_enum (splay_tree_node node, void *data)
4041 {
4042   tree label = (tree) node->value;
4043   tree type = (tree) data;
4044
4045   /* Skip default case.  */
4046   if (!CASE_LOW (label))
4047     return 0;
4048
4049   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4050      when we did our enum->case scan.  Reset our scratch bit after.  */
4051   if (!CASE_LOW_SEEN (label))
4052     match_case_to_enum_1 (CASE_LOW (label), type, label);
4053   else
4054     CASE_LOW_SEEN (label) = 0;
4055
4056   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
4057      not set, that means that CASE_HIGH did not appear when we did our
4058      enum->case scan.  Reset our scratch bit after.  */
4059   if (CASE_HIGH (label))
4060     {
4061       if (!CASE_HIGH_SEEN (label))
4062         match_case_to_enum_1 (CASE_HIGH (label), type, label);
4063       else
4064         CASE_HIGH_SEEN (label) = 0;
4065     }
4066
4067   return 0;
4068 }
4069
4070 /* Handle -Wswitch*.  Called from the front end after parsing the
4071    switch construct.  */
4072 /* ??? Should probably be somewhere generic, since other languages
4073    besides C and C++ would want this.  At the moment, however, C/C++
4074    are the only tree-ssa languages that support enumerations at all,
4075    so the point is moot.  */
4076
4077 void
4078 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4079                       tree type, tree cond)
4080 {
4081   splay_tree_node default_node;
4082   splay_tree_node node;
4083   tree chain;
4084
4085   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4086     return;
4087
4088   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4089   if (!default_node)
4090     warning (OPT_Wswitch_default, "%Hswitch missing default case",
4091              &switch_location);
4092
4093   /* From here on, we only care about about enumerated types.  */
4094   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4095     return;
4096
4097   /* If the switch expression was an enumerated type, check that
4098      exactly all enumeration literals are covered by the cases.
4099      The check is made when -Wswitch was specified and there is no
4100      default case, or when -Wswitch-enum was specified.  */
4101
4102   if (!warn_switch_enum
4103       && !(warn_switch && !default_node))
4104     return;
4105
4106   /* Clearing COND if it is not an integer constant simplifies
4107      the tests inside the loop below.  */
4108   if (TREE_CODE (cond) != INTEGER_CST)
4109     cond = NULL_TREE;
4110
4111   /* The time complexity here is O(N*lg(N)) worst case, but for the
4112       common case of monotonically increasing enumerators, it is
4113       O(N), since the nature of the splay tree will keep the next
4114       element adjacent to the root at all times.  */
4115
4116   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4117     {
4118       tree value = TREE_VALUE (chain);
4119       node = splay_tree_lookup (cases, (splay_tree_key) value);
4120       if (node)
4121         {
4122           /* Mark the CASE_LOW part of the case entry as seen.  */
4123           tree label = (tree) node->value;
4124           CASE_LOW_SEEN (label) = 1;
4125           continue;
4126         }
4127
4128       /* Even though there wasn't an exact match, there might be a
4129          case range which includes the enumator's value.  */
4130       node = splay_tree_predecessor (cases, (splay_tree_key) value);
4131       if (node && CASE_HIGH ((tree) node->value))
4132         {
4133           tree label = (tree) node->value;
4134           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4135           if (cmp >= 0)
4136             {
4137               /* If we match the upper bound exactly, mark the CASE_HIGH
4138                  part of the case entry as seen.  */
4139               if (cmp == 0)
4140                 CASE_HIGH_SEEN (label) = 1;
4141               continue;
4142             }
4143         }
4144
4145       /* We've now determined that this enumerated literal isn't
4146          handled by the case labels of the switch statement.  */
4147
4148       /* If the switch expression is a constant, we only really care
4149          about whether that constant is handled by the switch.  */
4150       if (cond && tree_int_cst_compare (cond, value))
4151         continue;
4152
4153       warning (0, "%Henumeration value %qE not handled in switch",
4154                &switch_location, TREE_PURPOSE (chain));
4155     }
4156
4157   /* Warn if there are case expressions that don't correspond to
4158      enumerators.  This can occur since C and C++ don't enforce
4159      type-checking of assignments to enumeration variables.
4160
4161      The time complexity here is now always O(N) worst case, since
4162      we should have marked both the lower bound and upper bound of
4163      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4164      above.  This scan also resets those fields.  */
4165   splay_tree_foreach (cases, match_case_to_enum, type);
4166 }
4167
4168 /* Finish an expression taking the address of LABEL (an
4169    IDENTIFIER_NODE).  Returns an expression for the address.  */
4170
4171 tree
4172 finish_label_address_expr (tree label)
4173 {
4174   tree result;
4175
4176   if (pedantic)
4177     pedwarn ("taking the address of a label is non-standard");
4178
4179   if (label == error_mark_node)
4180     return error_mark_node;
4181
4182   label = lookup_label (label);
4183   if (label == NULL_TREE)
4184     result = null_pointer_node;
4185   else
4186     {
4187       TREE_USED (label) = 1;
4188       result = build1 (ADDR_EXPR, ptr_type_node, label);
4189       /* The current function in not necessarily uninlinable.
4190          Computed gotos are incompatible with inlining, but the value
4191          here could be used only in a diagnostic, for example.  */
4192     }
4193
4194   return result;
4195 }
4196
4197 /* Hook used by expand_expr to expand language-specific tree codes.  */
4198 /* The only things that should go here are bits needed to expand
4199    constant initializers.  Everything else should be handled by the
4200    gimplification routines.  */
4201
4202 rtx
4203 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4204                int modifier /* Actually enum_modifier.  */,
4205                rtx *alt_rtl)
4206 {
4207   switch (TREE_CODE (exp))
4208     {
4209     case COMPOUND_LITERAL_EXPR:
4210       {
4211         /* Initialize the anonymous variable declared in the compound
4212            literal, then return the variable.  */
4213         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4214         emit_local_var (decl);
4215         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4216       }
4217
4218     default:
4219       gcc_unreachable ();
4220     }
4221 }
4222
4223
4224 /* Generate the RTL for the body of FNDECL.  */
4225
4226 void
4227 c_expand_body (tree fndecl)
4228 {
4229
4230   if (!DECL_INITIAL (fndecl)
4231       || DECL_INITIAL (fndecl) == error_mark_node)
4232     return;
4233
4234   tree_rest_of_compilation (fndecl);
4235
4236   if (DECL_STATIC_CONSTRUCTOR (fndecl)
4237       && targetm.have_ctors_dtors)
4238     targetm.asm_out.constructor (XEXP (DECL_RTL (fndecl), 0),
4239                                  decl_init_priority_lookup (fndecl));
4240   if (DECL_STATIC_DESTRUCTOR (fndecl)
4241       && targetm.have_ctors_dtors)
4242     targetm.asm_out.destructor (XEXP (DECL_RTL (fndecl), 0),
4243                                 decl_fini_priority_lookup (fndecl));
4244 }
4245
4246 /* Hook used by staticp to handle language-specific tree codes.  */
4247
4248 tree
4249 c_staticp (tree exp)
4250 {
4251   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4252           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4253           ? exp : NULL);
4254 }
4255 \f
4256
4257 /* Given a boolean expression ARG, return a tree representing an increment
4258    or decrement (as indicated by CODE) of ARG.  The front end must check for
4259    invalid cases (e.g., decrement in C++).  */
4260 tree
4261 boolean_increment (enum tree_code code, tree arg)
4262 {
4263   tree val;
4264   tree true_res = boolean_true_node;
4265
4266   arg = stabilize_reference (arg);
4267   switch (code)
4268     {
4269     case PREINCREMENT_EXPR:
4270       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4271       break;
4272     case POSTINCREMENT_EXPR:
4273       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4274       arg = save_expr (arg);
4275       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4276       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4277       break;
4278     case PREDECREMENT_EXPR:
4279       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4280                     invert_truthvalue (arg));
4281       break;
4282     case POSTDECREMENT_EXPR:
4283       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4284                     invert_truthvalue (arg));
4285       arg = save_expr (arg);
4286       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4287       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4288       break;
4289     default:
4290       gcc_unreachable ();
4291     }
4292   TREE_SIDE_EFFECTS (val) = 1;
4293   return val;
4294 }
4295 \f
4296 /* Built-in macros for stddef.h, that require macros defined in this
4297    file.  */
4298 void
4299 c_stddef_cpp_builtins(void)
4300 {
4301   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4302   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4303   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4304   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4305   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4306   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4307 }
4308
4309 static void
4310 c_init_attributes (void)
4311 {
4312   /* Fill in the built_in_attributes array.  */
4313 #define DEF_ATTR_NULL_TREE(ENUM)                                \
4314   built_in_attributes[(int) ENUM] = NULL_TREE;
4315 #define DEF_ATTR_INT(ENUM, VALUE)                               \
4316   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4317 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
4318   built_in_attributes[(int) ENUM] = get_identifier (STRING);
4319 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4320   built_in_attributes[(int) ENUM]                       \
4321     = tree_cons (built_in_attributes[(int) PURPOSE],    \
4322                  built_in_attributes[(int) VALUE],      \
4323                  built_in_attributes[(int) CHAIN]);
4324 #include "builtin-attrs.def"
4325 #undef DEF_ATTR_NULL_TREE
4326 #undef DEF_ATTR_INT
4327 #undef DEF_ATTR_IDENT
4328 #undef DEF_ATTR_TREE_LIST
4329 }
4330
4331 /* Attribute handlers common to C front ends.  */
4332
4333 /* Handle a "packed" attribute; arguments as in
4334    struct attribute_spec.handler.  */
4335
4336 static tree
4337 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4338                          int flags, bool *no_add_attrs)
4339 {
4340   if (TYPE_P (*node))
4341     {
4342       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4343         *node = build_variant_type_copy (*node);
4344       TYPE_PACKED (*node) = 1;
4345     }
4346   else if (TREE_CODE (*node) == FIELD_DECL)
4347     {
4348       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4349         warning (OPT_Wattributes,
4350                  "%qE attribute ignored for field of type %qT",
4351                  name, TREE_TYPE (*node));
4352       else
4353         DECL_PACKED (*node) = 1;
4354     }
4355   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4356      used for DECL_REGISTER.  It wouldn't mean anything anyway.
4357      We can't set DECL_PACKED on the type of a TYPE_DECL, because
4358      that changes what the typedef is typing.  */
4359   else
4360     {
4361       warning (OPT_Wattributes, "%qE attribute ignored", name);
4362       *no_add_attrs = true;
4363     }
4364
4365   return NULL_TREE;
4366 }
4367
4368 /* Handle a "nocommon" attribute; arguments as in
4369    struct attribute_spec.handler.  */
4370
4371 static tree
4372 handle_nocommon_attribute (tree *node, tree name,
4373                            tree ARG_UNUSED (args),
4374                            int ARG_UNUSED (flags), bool *no_add_attrs)
4375 {
4376   if (TREE_CODE (*node) == VAR_DECL)
4377     DECL_COMMON (*node) = 0;
4378   else
4379     {
4380       warning (OPT_Wattributes, "%qE attribute ignored", name);
4381       *no_add_attrs = true;
4382     }
4383
4384   return NULL_TREE;
4385 }
4386
4387 /* Handle a "common" attribute; arguments as in
4388    struct attribute_spec.handler.  */
4389
4390 static tree
4391 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4392                          int ARG_UNUSED (flags), bool *no_add_attrs)
4393 {
4394   if (TREE_CODE (*node) == VAR_DECL)
4395     DECL_COMMON (*node) = 1;
4396   else
4397     {
4398       warning (OPT_Wattributes, "%qE attribute ignored", name);
4399       *no_add_attrs = true;
4400     }
4401
4402   return NULL_TREE;
4403 }
4404
4405 /* Handle a "noreturn" attribute; arguments as in
4406    struct attribute_spec.handler.  */
4407
4408 static tree
4409 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4410                            int ARG_UNUSED (flags), bool *no_add_attrs)
4411 {
4412   tree type = TREE_TYPE (*node);
4413
4414   /* See FIXME comment in c_common_attribute_table.  */
4415   if (TREE_CODE (*node) == FUNCTION_DECL)
4416     TREE_THIS_VOLATILE (*node) = 1;
4417   else if (TREE_CODE (type) == POINTER_TYPE
4418            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4419     TREE_TYPE (*node)
4420       = build_pointer_type
4421         (build_type_variant (TREE_TYPE (type),
4422                              TYPE_READONLY (TREE_TYPE (type)), 1));
4423   else
4424     {
4425       warning (OPT_Wattributes, "%qE attribute ignored", name);
4426       *no_add_attrs = true;
4427     }
4428
4429   return NULL_TREE;
4430 }
4431
4432 /* Handle a "noinline" attribute; arguments as in
4433    struct attribute_spec.handler.  */
4434
4435 static tree
4436 handle_noinline_attribute (tree *node, tree name,
4437                            tree ARG_UNUSED (args),
4438                            int ARG_UNUSED (flags), bool *no_add_attrs)
4439 {
4440   if (TREE_CODE (*node) == FUNCTION_DECL)
4441     DECL_UNINLINABLE (*node) = 1;
4442   else
4443     {
4444       warning (OPT_Wattributes, "%qE attribute ignored", name);
4445       *no_add_attrs = true;
4446     }
4447
4448   return NULL_TREE;
4449 }
4450
4451 /* Handle a "always_inline" attribute; arguments as in
4452    struct attribute_spec.handler.  */
4453
4454 static tree
4455 handle_always_inline_attribute (tree *node, tree name,
4456                                 tree ARG_UNUSED (args),
4457                                 int ARG_UNUSED (flags),
4458                                 bool *no_add_attrs)
4459 {
4460   if (TREE_CODE (*node) == FUNCTION_DECL)
4461     {
4462       /* Do nothing else, just set the attribute.  We'll get at
4463          it later with lookup_attribute.  */
4464     }
4465   else
4466     {
4467       warning (OPT_Wattributes, "%qE attribute ignored", name);
4468       *no_add_attrs = true;
4469     }
4470
4471   return NULL_TREE;
4472 }
4473
4474 /* Handle a "gnu_inline" attribute; arguments as in
4475    struct attribute_spec.handler.  */
4476
4477 static tree
4478 handle_gnu_inline_attribute (tree *node, tree name,
4479                              tree ARG_UNUSED (args),
4480                              int ARG_UNUSED (flags),
4481                              bool *no_add_attrs)
4482 {
4483   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4484     {
4485       /* Do nothing else, just set the attribute.  We'll get at
4486          it later with lookup_attribute.  */
4487     }
4488   else
4489     {
4490       warning (OPT_Wattributes, "%qE attribute ignored", name);
4491       *no_add_attrs = true;
4492     }
4493
4494   return NULL_TREE;
4495 }
4496
4497 /* Handle a "flatten" attribute; arguments as in
4498    struct attribute_spec.handler.  */
4499
4500 static tree
4501 handle_flatten_attribute (tree *node, tree name,
4502                           tree args ATTRIBUTE_UNUSED,
4503                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4504 {
4505   if (TREE_CODE (*node) == FUNCTION_DECL)
4506     /* Do nothing else, just set the attribute.  We'll get at
4507        it later with lookup_attribute.  */
4508     ;
4509   else
4510     {
4511       warning (OPT_Wattributes, "%qE attribute ignored", name);
4512       *no_add_attrs = true;
4513     }
4514
4515   return NULL_TREE;
4516 }
4517
4518
4519 /* Handle a "used" attribute; arguments as in
4520    struct attribute_spec.handler.  */
4521
4522 static tree
4523 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4524                        int ARG_UNUSED (flags), bool *no_add_attrs)
4525 {
4526   tree node = *pnode;
4527
4528   if (TREE_CODE (node) == FUNCTION_DECL
4529       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4530     {
4531       TREE_USED (node) = 1;
4532       DECL_PRESERVE_P (node) = 1;
4533     }
4534   else
4535     {
4536       warning (OPT_Wattributes, "%qE attribute ignored", name);
4537       *no_add_attrs = true;
4538     }
4539
4540   return NULL_TREE;
4541 }
4542
4543 /* Handle a "unused" attribute; arguments as in
4544    struct attribute_spec.handler.  */
4545
4546 static tree
4547 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4548                          int flags, bool *no_add_attrs)
4549 {
4550   if (DECL_P (*node))
4551     {
4552       tree decl = *node;
4553
4554       if (TREE_CODE (decl) == PARM_DECL
4555           || TREE_CODE (decl) == VAR_DECL
4556           || TREE_CODE (decl) == FUNCTION_DECL
4557           || TREE_CODE (decl) == LABEL_DECL
4558           || TREE_CODE (decl) == TYPE_DECL)
4559         TREE_USED (decl) = 1;
4560       else
4561         {
4562           warning (OPT_Wattributes, "%qE attribute ignored", name);
4563           *no_add_attrs = true;
4564         }
4565     }
4566   else
4567     {
4568       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4569         *node = build_variant_type_copy (*node);
4570       TREE_USED (*node) = 1;
4571     }
4572
4573   return NULL_TREE;
4574 }
4575
4576 /* Handle a "externally_visible" attribute; arguments as in
4577    struct attribute_spec.handler.  */
4578
4579 static tree
4580 handle_externally_visible_attribute (tree *pnode, tree name,
4581                                      tree ARG_UNUSED (args),
4582                                      int ARG_UNUSED (flags),
4583                                      bool *no_add_attrs)
4584 {
4585   tree node = *pnode;
4586
4587   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4588     {
4589       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4590            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4591         {
4592           warning (OPT_Wattributes,
4593                    "%qE attribute have effect only on public objects", name);
4594           *no_add_attrs = true;
4595         }
4596     }
4597   else
4598     {
4599       warning (OPT_Wattributes, "%qE attribute ignored", name);
4600       *no_add_attrs = true;
4601     }
4602
4603   return NULL_TREE;
4604 }
4605
4606 /* Handle a "const" attribute; arguments as in
4607    struct attribute_spec.handler.  */
4608
4609 static tree
4610 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4611                         int ARG_UNUSED (flags), bool *no_add_attrs)
4612 {
4613   tree type = TREE_TYPE (*node);
4614
4615   /* See FIXME comment on noreturn in c_common_attribute_table.  */
4616   if (TREE_CODE (*node) == FUNCTION_DECL)
4617     TREE_READONLY (*node) = 1;
4618   else if (TREE_CODE (type) == POINTER_TYPE
4619            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4620     TREE_TYPE (*node)
4621       = build_pointer_type
4622         (build_type_variant (TREE_TYPE (type), 1,
4623                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
4624   else
4625     {
4626       warning (OPT_Wattributes, "%qE attribute ignored", name);
4627       *no_add_attrs = true;
4628     }
4629
4630   return NULL_TREE;
4631 }
4632
4633 /* Handle a "transparent_union" attribute; arguments as in
4634    struct attribute_spec.handler.  */
4635
4636 static tree
4637 handle_transparent_union_attribute (tree *node, tree name,
4638                                     tree ARG_UNUSED (args), int flags,
4639                                     bool *no_add_attrs)
4640 {
4641   tree type = NULL;
4642
4643   *no_add_attrs = true;
4644
4645   if (DECL_P (*node))
4646     {
4647       if (TREE_CODE (*node) != TYPE_DECL)
4648         goto ignored;
4649       node = &TREE_TYPE (*node);
4650       type = *node;
4651     }
4652   else if (TYPE_P (*node))
4653     type = *node;
4654   else
4655     goto ignored;
4656
4657   if (TREE_CODE (type) == UNION_TYPE)
4658     {
4659       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4660          the code in finish_struct.  */
4661       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4662         {
4663           if (TYPE_FIELDS (type) == NULL_TREE
4664               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4665             goto ignored;
4666
4667           /* A type variant isn't good enough, since we don't a cast
4668              to such a type removed as a no-op.  */
4669           *node = type = build_duplicate_type (type);
4670         }
4671
4672       TYPE_TRANSPARENT_UNION (type) = 1;
4673       return NULL_TREE;
4674     }
4675
4676  ignored:
4677   warning (OPT_Wattributes, "%qE attribute ignored", name);
4678   return NULL_TREE;
4679 }
4680
4681 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
4682    get the requested priority for a constructor or destructor,
4683    possibly issuing diagnostics for invalid or reserved
4684    priorities.  */
4685
4686 static priority_type
4687 get_priority (tree args, bool is_destructor)
4688 {
4689   HOST_WIDE_INT pri;
4690   tree arg;
4691
4692   if (!args)
4693     return DEFAULT_INIT_PRIORITY;
4694
4695   arg = TREE_VALUE (args);
4696   if (!host_integerp (arg, /*pos=*/0)
4697       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4698     goto invalid;
4699
4700   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
4701   if (pri < 0 || pri > MAX_INIT_PRIORITY)
4702     goto invalid;
4703
4704   if (pri <= MAX_RESERVED_INIT_PRIORITY)
4705     {
4706       if (is_destructor)
4707         warning (0,
4708                  "destructor priorities from 0 to %d are reserved "
4709                  "for the implementation",
4710                  MAX_RESERVED_INIT_PRIORITY);
4711       else
4712         warning (0,
4713                  "constructor priorities from 0 to %d are reserved "
4714                  "for the implementation",
4715                  MAX_RESERVED_INIT_PRIORITY);
4716     }
4717   return pri;
4718
4719  invalid:
4720   if (is_destructor)
4721     error ("destructor priorities must be integers from 0 to %d inclusive",
4722            MAX_INIT_PRIORITY);
4723   else
4724     error ("constructor priorities must be integers from 0 to %d inclusive",
4725            MAX_INIT_PRIORITY);
4726   return DEFAULT_INIT_PRIORITY;
4727 }
4728
4729 /* Handle a "constructor" attribute; arguments as in
4730    struct attribute_spec.handler.  */
4731
4732 static tree
4733 handle_constructor_attribute (tree *node, tree name, tree args,
4734                               int ARG_UNUSED (flags),
4735                               bool *no_add_attrs)
4736 {
4737   tree decl = *node;
4738   tree type = TREE_TYPE (decl);
4739
4740   if (TREE_CODE (decl) == FUNCTION_DECL
4741       && TREE_CODE (type) == FUNCTION_TYPE
4742       && decl_function_context (decl) == 0)
4743     {
4744       priority_type priority;
4745       DECL_STATIC_CONSTRUCTOR (decl) = 1;
4746       priority = get_priority (args, /*is_destructor=*/false);
4747       SET_DECL_INIT_PRIORITY (decl, priority);
4748       TREE_USED (decl) = 1;
4749     }
4750   else
4751     {
4752       warning (OPT_Wattributes, "%qE attribute ignored", name);
4753       *no_add_attrs = true;
4754     }
4755
4756   return NULL_TREE;
4757 }
4758
4759 /* Handle a "destructor" attribute; arguments as in
4760    struct attribute_spec.handler.  */
4761
4762 static tree
4763 handle_destructor_attribute (tree *node, tree name, tree args,
4764                              int ARG_UNUSED (flags),
4765                              bool *no_add_attrs)
4766 {
4767   tree decl = *node;
4768   tree type = TREE_TYPE (decl);
4769
4770   if (TREE_CODE (decl) == FUNCTION_DECL
4771       && TREE_CODE (type) == FUNCTION_TYPE
4772       && decl_function_context (decl) == 0)
4773     {
4774       priority_type priority;
4775       DECL_STATIC_DESTRUCTOR (decl) = 1;
4776       priority = get_priority (args, /*is_destructor=*/true);
4777       SET_DECL_FINI_PRIORITY (decl, priority);
4778       TREE_USED (decl) = 1;
4779     }
4780   else
4781     {
4782       warning (OPT_Wattributes, "%qE attribute ignored", name);
4783       *no_add_attrs = true;
4784     }
4785
4786   return NULL_TREE;
4787 }
4788
4789 /* Handle a "mode" attribute; arguments as in
4790    struct attribute_spec.handler.  */
4791
4792 static tree
4793 handle_mode_attribute (tree *node, tree name, tree args,
4794                        int ARG_UNUSED (flags), bool *no_add_attrs)
4795 {
4796   tree type = *node;
4797
4798   *no_add_attrs = true;
4799
4800   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4801     warning (OPT_Wattributes, "%qE attribute ignored", name);
4802   else
4803     {
4804       int j;
4805       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4806       int len = strlen (p);
4807       enum machine_mode mode = VOIDmode;
4808       tree typefm;
4809       bool valid_mode;
4810
4811       if (len > 4 && p[0] == '_' && p[1] == '_'
4812           && p[len - 1] == '_' && p[len - 2] == '_')
4813         {
4814           char *newp = (char *) alloca (len - 1);
4815
4816           strcpy (newp, &p[2]);
4817           newp[len - 4] = '\0';
4818           p = newp;
4819         }
4820
4821       /* Change this type to have a type with the specified mode.
4822          First check for the special modes.  */
4823       if (!strcmp (p, "byte"))
4824         mode = byte_mode;
4825       else if (!strcmp (p, "word"))
4826         mode = word_mode;
4827       else if (!strcmp (p, "pointer"))
4828         mode = ptr_mode;
4829       else
4830         for (j = 0; j < NUM_MACHINE_MODES; j++)
4831           if (!strcmp (p, GET_MODE_NAME (j)))
4832             {
4833               mode = (enum machine_mode) j;
4834               break;
4835             }
4836
4837       if (mode == VOIDmode)
4838         {
4839           error ("unknown machine mode %qs", p);
4840           return NULL_TREE;
4841         }
4842
4843       valid_mode = false;
4844       switch (GET_MODE_CLASS (mode))
4845         {
4846         case MODE_INT:
4847         case MODE_PARTIAL_INT:
4848         case MODE_FLOAT:
4849         case MODE_DECIMAL_FLOAT:
4850           valid_mode = targetm.scalar_mode_supported_p (mode);
4851           break;
4852
4853         case MODE_COMPLEX_INT:
4854         case MODE_COMPLEX_FLOAT:
4855           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4856           break;
4857
4858         case MODE_VECTOR_INT:
4859         case MODE_VECTOR_FLOAT:
4860           warning (OPT_Wattributes, "specifying vector types with "
4861                    "__attribute__ ((mode)) is deprecated");
4862           warning (OPT_Wattributes,
4863                    "use __attribute__ ((vector_size)) instead");
4864           valid_mode = vector_mode_valid_p (mode);
4865           break;
4866
4867         default:
4868           break;
4869         }
4870       if (!valid_mode)
4871         {
4872           error ("unable to emulate %qs", p);
4873           return NULL_TREE;
4874         }
4875
4876       if (POINTER_TYPE_P (type))
4877         {
4878           tree (*fn)(tree, enum machine_mode, bool);
4879
4880           if (!targetm.valid_pointer_mode (mode))
4881             {
4882               error ("invalid pointer mode %qs", p);
4883               return NULL_TREE;
4884             }
4885
4886           if (TREE_CODE (type) == POINTER_TYPE)
4887             fn = build_pointer_type_for_mode;
4888           else
4889             fn = build_reference_type_for_mode;
4890           typefm = fn (TREE_TYPE (type), mode, false);
4891         }
4892       else
4893         typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4894
4895       if (typefm == NULL_TREE)
4896         {
4897           error ("no data type for mode %qs", p);
4898           return NULL_TREE;
4899         }
4900       else if (TREE_CODE (type) == ENUMERAL_TYPE)
4901         {
4902           /* For enumeral types, copy the precision from the integer
4903              type returned above.  If not an INTEGER_TYPE, we can't use
4904              this mode for this type.  */
4905           if (TREE_CODE (typefm) != INTEGER_TYPE)
4906             {
4907               error ("cannot use mode %qs for enumeral types", p);
4908               return NULL_TREE;
4909             }
4910
4911           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4912             {
4913               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4914               typefm = type;
4915             }
4916           else
4917             {
4918               /* We cannot build a type variant, as there's code that assumes
4919                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
4920                  debug generators.  Instead, create a subrange type.  This
4921                  results in all of the enumeral values being emitted only once
4922                  in the original, and the subtype gets them by reference.  */
4923               if (TYPE_UNSIGNED (type))
4924                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4925               else
4926                 typefm = make_signed_type (TYPE_PRECISION (typefm));
4927               TREE_TYPE (typefm) = type;
4928             }
4929         }
4930       else if (VECTOR_MODE_P (mode)
4931                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4932                : TREE_CODE (type) != TREE_CODE (typefm))
4933         {
4934           error ("mode %qs applied to inappropriate type", p);
4935           return NULL_TREE;
4936         }
4937
4938       *node = typefm;
4939     }
4940
4941   return NULL_TREE;
4942 }
4943
4944 /* Handle a "section" attribute; arguments as in
4945    struct attribute_spec.handler.  */
4946
4947 static tree
4948 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4949                           int ARG_UNUSED (flags), bool *no_add_attrs)
4950 {
4951   tree decl = *node;
4952
4953   if (targetm.have_named_sections)
4954     {
4955       user_defined_section_attribute = true;
4956
4957       if ((TREE_CODE (decl) == FUNCTION_DECL
4958            || TREE_CODE (decl) == VAR_DECL)
4959           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4960         {
4961           if (TREE_CODE (decl) == VAR_DECL
4962               && current_function_decl != NULL_TREE
4963               && !TREE_STATIC (decl))
4964             {
4965               error ("%Jsection attribute cannot be specified for "
4966                      "local variables", decl);
4967               *no_add_attrs = true;
4968             }
4969
4970           /* The decl may have already been given a section attribute
4971              from a previous declaration.  Ensure they match.  */
4972           else if (DECL_SECTION_NAME (decl) != NULL_TREE
4973                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4974                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4975             {
4976               error ("section of %q+D conflicts with previous declaration",
4977                      *node);
4978               *no_add_attrs = true;
4979             }
4980           else
4981             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4982         }
4983       else
4984         {
4985           error ("section attribute not allowed for %q+D", *node);
4986           *no_add_attrs = true;
4987         }
4988     }
4989   else
4990     {
4991       error ("%Jsection attributes are not supported for this target", *node);
4992       *no_add_attrs = true;
4993     }
4994
4995   return NULL_TREE;
4996 }
4997
4998 /* Handle a "aligned" attribute; arguments as in
4999    struct attribute_spec.handler.  */
5000
5001 static tree
5002 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5003                           int flags, bool *no_add_attrs)
5004 {
5005   tree decl = NULL_TREE;
5006   tree *type = NULL;
5007   int is_type = 0;
5008   tree align_expr = (args ? TREE_VALUE (args)
5009                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5010   int i;
5011
5012   if (DECL_P (*node))
5013     {
5014       decl = *node;
5015       type = &TREE_TYPE (decl);
5016       is_type = TREE_CODE (*node) == TYPE_DECL;
5017     }
5018   else if (TYPE_P (*node))
5019     type = node, is_type = 1;
5020
5021   if (TREE_CODE (align_expr) != INTEGER_CST)
5022     {
5023       error ("requested alignment is not a constant");
5024       *no_add_attrs = true;
5025     }
5026   else if ((i = tree_log2 (align_expr)) == -1)
5027     {
5028       error ("requested alignment is not a power of 2");
5029       *no_add_attrs = true;
5030     }
5031   else if (i > HOST_BITS_PER_INT - 2)
5032     {
5033       error ("requested alignment is too large");
5034       *no_add_attrs = true;
5035     }
5036   else if (is_type)
5037     {
5038       /* If we have a TYPE_DECL, then copy the type, so that we
5039          don't accidentally modify a builtin type.  See pushdecl.  */
5040       if (decl && TREE_TYPE (decl) != error_mark_node
5041           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5042         {
5043           tree tt = TREE_TYPE (decl);
5044           *type = build_variant_type_copy (*type);
5045           DECL_ORIGINAL_TYPE (decl) = tt;
5046           TYPE_NAME (*type) = decl;
5047           TREE_USED (*type) = TREE_USED (decl);
5048           TREE_TYPE (decl) = *type;
5049         }
5050       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5051         *type = build_variant_type_copy (*type);
5052
5053       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5054       TYPE_USER_ALIGN (*type) = 1;
5055     }
5056   else if (TREE_CODE (decl) != VAR_DECL
5057            && TREE_CODE (decl) != FIELD_DECL)
5058     {
5059       error ("alignment may not be specified for %q+D", decl);
5060       *no_add_attrs = true;
5061     }
5062   else
5063     {
5064       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5065       DECL_USER_ALIGN (decl) = 1;
5066     }
5067
5068   return NULL_TREE;
5069 }
5070
5071 /* Handle a "weak" attribute; arguments as in
5072    struct attribute_spec.handler.  */
5073
5074 static tree
5075 handle_weak_attribute (tree *node, tree name,
5076                        tree ARG_UNUSED (args),
5077                        int ARG_UNUSED (flags),
5078                        bool * ARG_UNUSED (no_add_attrs))
5079 {
5080   if (TREE_CODE (*node) == FUNCTION_DECL
5081       || TREE_CODE (*node) == VAR_DECL)
5082     declare_weak (*node);
5083   else
5084     warning (OPT_Wattributes, "%qE attribute ignored", name);
5085
5086
5087   return NULL_TREE;
5088 }
5089
5090 /* Handle an "alias" attribute; arguments as in
5091    struct attribute_spec.handler.  */
5092
5093 static tree
5094 handle_alias_attribute (tree *node, tree name, tree args,
5095                         int ARG_UNUSED (flags), bool *no_add_attrs)
5096 {
5097   tree decl = *node;
5098
5099   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5100       || (TREE_CODE (decl) != FUNCTION_DECL
5101           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5102       /* A static variable declaration is always a tentative definition,
5103          but the alias is a non-tentative definition which overrides.  */
5104       || (TREE_CODE (decl) != FUNCTION_DECL
5105           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5106     {
5107       error ("%q+D defined both normally and as an alias", decl);
5108       *no_add_attrs = true;
5109     }
5110
5111   /* Note that the very first time we process a nested declaration,
5112      decl_function_context will not be set.  Indeed, *would* never
5113      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5114      we do below.  After such frobbery, pushdecl would set the context.
5115      In any case, this is never what we want.  */
5116   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5117     {
5118       tree id;
5119
5120       id = TREE_VALUE (args);
5121       if (TREE_CODE (id) != STRING_CST)
5122         {
5123           error ("alias argument not a string");
5124           *no_add_attrs = true;
5125           return NULL_TREE;
5126         }
5127       id = get_identifier (TREE_STRING_POINTER (id));
5128       /* This counts as a use of the object pointed to.  */
5129       TREE_USED (id) = 1;
5130
5131       if (TREE_CODE (decl) == FUNCTION_DECL)
5132         DECL_INITIAL (decl) = error_mark_node;
5133       else
5134         {
5135           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5136             DECL_EXTERNAL (decl) = 1;
5137           else
5138             DECL_EXTERNAL (decl) = 0;
5139           TREE_STATIC (decl) = 1;
5140         }
5141     }
5142   else
5143     {
5144       warning (OPT_Wattributes, "%qE attribute ignored", name);
5145       *no_add_attrs = true;
5146     }
5147
5148   return NULL_TREE;
5149 }
5150
5151 /* Handle a "weakref" attribute; arguments as in struct
5152    attribute_spec.handler.  */
5153
5154 static tree
5155 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5156                           int flags, bool *no_add_attrs)
5157 {
5158   tree attr = NULL_TREE;
5159
5160   /* We must ignore the attribute when it is associated with
5161      local-scoped decls, since attribute alias is ignored and many
5162      such symbols do not even have a DECL_WEAK field.  */
5163   if (decl_function_context (*node) || current_function_decl)
5164     {
5165       warning (OPT_Wattributes, "%qE attribute ignored", name);
5166       *no_add_attrs = true;
5167       return NULL_TREE;
5168     }
5169
5170   /* The idea here is that `weakref("name")' mutates into `weakref,
5171      alias("name")', and weakref without arguments, in turn,
5172      implicitly adds weak. */
5173
5174   if (args)
5175     {
5176       attr = tree_cons (get_identifier ("alias"), args, attr);
5177       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5178
5179       *no_add_attrs = true;
5180
5181       decl_attributes (node, attr, flags);
5182     }
5183   else
5184     {
5185       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5186         error ("%Jweakref attribute must appear before alias attribute",
5187                *node);
5188
5189       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5190          and that isn't supported; and because it wants to add it to
5191          the list of weak decls, which isn't helpful.  */
5192       DECL_WEAK (*node) = 1;
5193     }
5194
5195   return NULL_TREE;
5196 }
5197
5198 /* Handle an "visibility" attribute; arguments as in
5199    struct attribute_spec.handler.  */
5200
5201 static tree
5202 handle_visibility_attribute (tree *node, tree name, tree args,
5203                              int ARG_UNUSED (flags),
5204                              bool *ARG_UNUSED (no_add_attrs))
5205 {
5206   tree decl = *node;
5207   tree id = TREE_VALUE (args);
5208   enum symbol_visibility vis;
5209
5210   if (TYPE_P (*node))
5211     {
5212       if (TREE_CODE (*node) == ENUMERAL_TYPE)
5213         /* OK */;
5214       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5215         {
5216           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5217                    name);
5218           return NULL_TREE;
5219         }
5220       else if (TYPE_FIELDS (*node))
5221         {
5222           error ("%qE attribute ignored because %qT is already defined",
5223                  name, *node);
5224           return NULL_TREE;
5225         }
5226     }
5227   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5228     {
5229       warning (OPT_Wattributes, "%qE attribute ignored", name);
5230       return NULL_TREE;
5231     }
5232
5233   if (TREE_CODE (id) != STRING_CST)
5234     {
5235       error ("visibility argument not a string");
5236       return NULL_TREE;
5237     }
5238
5239   /*  If this is a type, set the visibility on the type decl.  */
5240   if (TYPE_P (decl))
5241     {
5242       decl = TYPE_NAME (decl);
5243       if (!decl)
5244         return NULL_TREE;
5245       if (TREE_CODE (decl) == IDENTIFIER_NODE)
5246         {
5247            warning (OPT_Wattributes, "%qE attribute ignored on types",
5248                     name);
5249            return NULL_TREE;
5250         }
5251     }
5252
5253   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5254     vis = VISIBILITY_DEFAULT;
5255   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5256     vis = VISIBILITY_INTERNAL;
5257   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5258     vis = VISIBILITY_HIDDEN;
5259   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5260     vis = VISIBILITY_PROTECTED;
5261   else
5262     {
5263       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5264       vis = VISIBILITY_DEFAULT;
5265     }
5266
5267   if (DECL_VISIBILITY_SPECIFIED (decl)
5268       && vis != DECL_VISIBILITY (decl)
5269       && lookup_attribute ("visibility", (TYPE_P (*node)
5270                                           ? TYPE_ATTRIBUTES (*node)
5271                                           : DECL_ATTRIBUTES (decl))))
5272     error ("%qD redeclared with different visibility", decl);
5273
5274   DECL_VISIBILITY (decl) = vis;
5275   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5276
5277   /* Go ahead and attach the attribute to the node as well.  This is needed
5278      so we can determine whether we have VISIBILITY_DEFAULT because the
5279      visibility was not specified, or because it was explicitly overridden
5280      from the containing scope.  */
5281
5282   return NULL_TREE;
5283 }
5284
5285 /* Determine the ELF symbol visibility for DECL, which is either a
5286    variable or a function.  It is an error to use this function if a
5287    definition of DECL is not available in this translation unit.
5288    Returns true if the final visibility has been determined by this
5289    function; false if the caller is free to make additional
5290    modifications.  */
5291
5292 bool
5293 c_determine_visibility (tree decl)
5294 {
5295   gcc_assert (TREE_CODE (decl) == VAR_DECL
5296               || TREE_CODE (decl) == FUNCTION_DECL);
5297
5298   /* If the user explicitly specified the visibility with an
5299      attribute, honor that.  DECL_VISIBILITY will have been set during
5300      the processing of the attribute.  We check for an explicit
5301      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5302      to distinguish the use of an attribute from the use of a "#pragma
5303      GCC visibility push(...)"; in the latter case we still want other
5304      considerations to be able to overrule the #pragma.  */
5305   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5306     return true;
5307
5308   /* Anything that is exported must have default visibility.  */
5309   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5310       && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5311     {
5312       DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5313       DECL_VISIBILITY_SPECIFIED (decl) = 1;
5314       return true;
5315     }
5316
5317   /* Set default visibility to whatever the user supplied with
5318      visibility_specified depending on #pragma GCC visibility.  */
5319   if (!DECL_VISIBILITY_SPECIFIED (decl))
5320     {
5321       DECL_VISIBILITY (decl) = default_visibility;
5322       DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5323     }
5324   return false;
5325 }
5326
5327 /* Handle an "tls_model" attribute; arguments as in
5328    struct attribute_spec.handler.  */
5329
5330 static tree
5331 handle_tls_model_attribute (tree *node, tree name, tree args,
5332                             int ARG_UNUSED (flags), bool *no_add_attrs)
5333 {
5334   tree id;
5335   tree decl = *node;
5336   enum tls_model kind;
5337
5338   *no_add_attrs = true;
5339
5340   if (!DECL_THREAD_LOCAL_P (decl))
5341     {
5342       warning (OPT_Wattributes, "%qE attribute ignored", name);
5343       return NULL_TREE;
5344     }
5345
5346   kind = DECL_TLS_MODEL (decl);
5347   id = TREE_VALUE (args);
5348   if (TREE_CODE (id) != STRING_CST)
5349     {
5350       error ("tls_model argument not a string");
5351       return NULL_TREE;
5352     }
5353
5354   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5355     kind = TLS_MODEL_LOCAL_EXEC;
5356   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5357     kind = TLS_MODEL_INITIAL_EXEC;
5358   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5359     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5360   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5361     kind = TLS_MODEL_GLOBAL_DYNAMIC;
5362   else
5363     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5364
5365   DECL_TLS_MODEL (decl) = kind;
5366   return NULL_TREE;
5367 }
5368
5369 /* Handle a "no_instrument_function" attribute; arguments as in
5370    struct attribute_spec.handler.  */
5371
5372 static tree
5373 handle_no_instrument_function_attribute (tree *node, tree name,
5374                                          tree ARG_UNUSED (args),
5375                                          int ARG_UNUSED (flags),
5376                                          bool *no_add_attrs)
5377 {
5378   tree decl = *node;
5379
5380   if (TREE_CODE (decl) != FUNCTION_DECL)
5381     {
5382       error ("%J%qE attribute applies only to functions", decl, name);
5383       *no_add_attrs = true;
5384     }
5385   else if (DECL_INITIAL (decl))
5386     {
5387       error ("%Jcan%'t set %qE attribute after definition", decl, name);
5388       *no_add_attrs = true;
5389     }
5390   else
5391     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5392
5393   return NULL_TREE;
5394 }
5395
5396 /* Handle a "malloc" attribute; arguments as in
5397    struct attribute_spec.handler.  */
5398
5399 static tree
5400 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5401                          int ARG_UNUSED (flags), bool *no_add_attrs)
5402 {
5403   if (TREE_CODE (*node) == FUNCTION_DECL
5404       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5405     DECL_IS_MALLOC (*node) = 1;
5406   else
5407     {
5408       warning (OPT_Wattributes, "%qE attribute ignored", name);
5409       *no_add_attrs = true;
5410     }
5411
5412   return NULL_TREE;
5413 }
5414
5415 /* Handle a "returns_twice" attribute; arguments as in
5416    struct attribute_spec.handler.  */
5417
5418 static tree
5419 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5420                          int ARG_UNUSED (flags), bool *no_add_attrs)
5421 {
5422   if (TREE_CODE (*node) == FUNCTION_DECL)
5423     DECL_IS_RETURNS_TWICE (*node) = 1;
5424   else
5425     {
5426       warning (OPT_Wattributes, "%qE attribute ignored", name);
5427       *no_add_attrs = true;
5428     }
5429
5430   return NULL_TREE;
5431 }
5432
5433 /* Handle a "no_limit_stack" attribute; arguments as in
5434    struct attribute_spec.handler.  */
5435
5436 static tree
5437 handle_no_limit_stack_attribute (tree *node, tree name,
5438                                  tree ARG_UNUSED (args),
5439                                  int ARG_UNUSED (flags),
5440                                  bool *no_add_attrs)
5441 {
5442   tree decl = *node;
5443
5444   if (TREE_CODE (decl) != FUNCTION_DECL)
5445     {
5446       error ("%J%qE attribute applies only to functions", decl, name);
5447       *no_add_attrs = true;
5448     }
5449   else if (DECL_INITIAL (decl))
5450     {
5451       error ("%Jcan%'t set %qE attribute after definition", decl, name);
5452       *no_add_attrs = true;
5453     }
5454   else
5455     DECL_NO_LIMIT_STACK (decl) = 1;
5456
5457   return NULL_TREE;
5458 }
5459
5460 /* Handle a "pure" attribute; arguments as in
5461    struct attribute_spec.handler.  */
5462
5463 static tree
5464 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5465                        int ARG_UNUSED (flags), bool *no_add_attrs)
5466 {
5467   if (TREE_CODE (*node) == FUNCTION_DECL)
5468     DECL_IS_PURE (*node) = 1;
5469   /* ??? TODO: Support types.  */
5470   else
5471     {
5472       warning (OPT_Wattributes, "%qE attribute ignored", name);
5473       *no_add_attrs = true;
5474     }
5475
5476   return NULL_TREE;
5477 }
5478
5479 /* Handle a "no vops" attribute; arguments as in
5480    struct attribute_spec.handler.  */
5481
5482 static tree
5483 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5484                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5485                          bool *ARG_UNUSED (no_add_attrs))
5486 {
5487   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5488   DECL_IS_NOVOPS (*node) = 1;
5489   return NULL_TREE;
5490 }
5491
5492 /* Handle a "deprecated" attribute; arguments as in
5493    struct attribute_spec.handler.  */
5494
5495 static tree
5496 handle_deprecated_attribute (tree *node, tree name,
5497                              tree ARG_UNUSED (args), int flags,
5498                              bool *no_add_attrs)
5499 {
5500   tree type = NULL_TREE;
5501   int warn = 0;
5502   tree what = NULL_TREE;
5503
5504   if (DECL_P (*node))
5505     {
5506       tree decl = *node;
5507       type = TREE_TYPE (decl);
5508
5509       if (TREE_CODE (decl) == TYPE_DECL
5510           || TREE_CODE (decl) == PARM_DECL
5511           || TREE_CODE (decl) == VAR_DECL
5512           || TREE_CODE (decl) == FUNCTION_DECL
5513           || TREE_CODE (decl) == FIELD_DECL)
5514         TREE_DEPRECATED (decl) = 1;
5515       else
5516         warn = 1;
5517     }
5518   else if (TYPE_P (*node))
5519     {
5520       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5521         *node = build_variant_type_copy (*node);
5522       TREE_DEPRECATED (*node) = 1;
5523       type = *node;
5524     }
5525   else
5526     warn = 1;
5527
5528   if (warn)
5529     {
5530       *no_add_attrs = true;
5531       if (type && TYPE_NAME (type))
5532         {
5533           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5534             what = TYPE_NAME (*node);
5535           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5536                    && DECL_NAME (TYPE_NAME (type)))
5537             what = DECL_NAME (TYPE_NAME (type));
5538         }
5539       if (what)
5540         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5541       else
5542         warning (OPT_Wattributes, "%qE attribute ignored", name);
5543     }
5544
5545   return NULL_TREE;
5546 }
5547
5548 /* Handle a "vector_size" attribute; arguments as in
5549    struct attribute_spec.handler.  */
5550
5551 static tree
5552 handle_vector_size_attribute (tree *node, tree name, tree args,
5553                               int ARG_UNUSED (flags),
5554                               bool *no_add_attrs)
5555 {
5556   unsigned HOST_WIDE_INT vecsize, nunits;
5557   enum machine_mode orig_mode;
5558   tree type = *node, new_type, size;
5559
5560   *no_add_attrs = true;
5561
5562   size = TREE_VALUE (args);
5563
5564   if (!host_integerp (size, 1))
5565     {
5566       warning (OPT_Wattributes, "%qE attribute ignored", name);
5567       return NULL_TREE;
5568     }
5569
5570   /* Get the vector size (in bytes).  */
5571   vecsize = tree_low_cst (size, 1);
5572
5573   /* We need to provide for vector pointers, vector arrays, and
5574      functions returning vectors.  For example:
5575
5576        __attribute__((vector_size(16))) short *foo;
5577
5578      In this case, the mode is SI, but the type being modified is
5579      HI, so we need to look further.  */
5580
5581   while (POINTER_TYPE_P (type)
5582          || TREE_CODE (type) == FUNCTION_TYPE
5583          || TREE_CODE (type) == METHOD_TYPE
5584          || TREE_CODE (type) == ARRAY_TYPE)
5585     type = TREE_TYPE (type);
5586
5587   /* Get the mode of the type being modified.  */
5588   orig_mode = TYPE_MODE (type);
5589
5590   if (TREE_CODE (type) == RECORD_TYPE
5591       || TREE_CODE (type) == UNION_TYPE
5592       || TREE_CODE (type) == VECTOR_TYPE
5593       || (!SCALAR_FLOAT_MODE_P (orig_mode)
5594           && GET_MODE_CLASS (orig_mode) != MODE_INT)
5595       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5596     {
5597       error ("invalid vector type for attribute %qE", name);
5598       return NULL_TREE;
5599     }
5600
5601   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5602     {
5603       error ("vector size not an integral multiple of component size");
5604       return NULL;
5605     }
5606
5607   if (vecsize == 0)
5608     {
5609       error ("zero vector size");
5610       return NULL;
5611     }
5612
5613   /* Calculate how many units fit in the vector.  */
5614   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5615   if (nunits & (nunits - 1))
5616     {
5617       error ("number of components of the vector not a power of two");
5618       return NULL_TREE;
5619     }
5620
5621   new_type = build_vector_type (type, nunits);
5622
5623   /* Build back pointers if needed.  */
5624   *node = reconstruct_complex_type (*node, new_type);
5625
5626   return NULL_TREE;
5627 }
5628
5629 /* Handle the "nonnull" attribute.  */
5630 static tree
5631 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5632                           tree args, int ARG_UNUSED (flags),
5633                           bool *no_add_attrs)
5634 {
5635   tree type = *node;
5636   unsigned HOST_WIDE_INT attr_arg_num;
5637
5638   /* If no arguments are specified, all pointer arguments should be
5639      non-null.  Verify a full prototype is given so that the arguments
5640      will have the correct types when we actually check them later.  */
5641   if (!args)
5642     {
5643       if (!TYPE_ARG_TYPES (type))
5644         {
5645           error ("nonnull attribute without arguments on a non-prototype");
5646           *no_add_attrs = true;
5647         }
5648       return NULL_TREE;
5649     }
5650
5651   /* Argument list specified.  Verify that each argument number references
5652      a pointer argument.  */
5653   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5654     {
5655       tree argument;
5656       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5657
5658       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5659         {
5660           error ("nonnull argument has invalid operand number (argument %lu)",
5661                  (unsigned long) attr_arg_num);
5662           *no_add_attrs = true;
5663           return NULL_TREE;
5664         }
5665
5666       argument = TYPE_ARG_TYPES (type);
5667       if (argument)
5668         {
5669           for (ck_num = 1; ; ck_num++)
5670             {
5671               if (!argument || ck_num == arg_num)
5672                 break;
5673               argument = TREE_CHAIN (argument);
5674             }
5675
5676           if (!argument
5677               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5678             {
5679               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5680                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
5681               *no_add_attrs = true;
5682               return NULL_TREE;
5683             }
5684
5685           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5686             {
5687               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5688                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
5689               *no_add_attrs = true;
5690               return NULL_TREE;
5691             }
5692         }
5693     }
5694
5695   return NULL_TREE;
5696 }
5697
5698 /* Check the argument list of a function call for null in argument slots
5699    that are marked as requiring a non-null pointer argument.  */
5700
5701 static void
5702 check_function_nonnull (tree attrs, tree params)
5703 {
5704   tree a, args, param;
5705   int param_num;
5706
5707   for (a = attrs; a; a = TREE_CHAIN (a))
5708     {
5709       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5710         {
5711           args = TREE_VALUE (a);
5712
5713           /* Walk the argument list.  If we encounter an argument number we
5714              should check for non-null, do it.  If the attribute has no args,
5715              then every pointer argument is checked (in which case the check
5716              for pointer type is done in check_nonnull_arg).  */
5717           for (param = params, param_num = 1; ;
5718                param_num++, param = TREE_CHAIN (param))
5719             {
5720               if (!param)
5721                 break;
5722               if (!args || nonnull_check_p (args, param_num))
5723                 check_function_arguments_recurse (check_nonnull_arg, NULL,
5724                                                   TREE_VALUE (param),
5725                                                   param_num);
5726             }
5727         }
5728     }
5729 }
5730
5731 /* Check that the Nth argument of a function call (counting backwards
5732    from the end) is a (pointer)0.  */
5733
5734 static void
5735 check_function_sentinel (tree attrs, tree params, tree typelist)
5736 {
5737   tree attr = lookup_attribute ("sentinel", attrs);
5738
5739   if (attr)
5740     {
5741       /* Skip over the named arguments.  */
5742       while (typelist && params)
5743       {
5744         typelist = TREE_CHAIN (typelist);
5745         params = TREE_CHAIN (params);
5746       }
5747
5748       if (typelist || !params)
5749         warning (OPT_Wformat,
5750                  "not enough variable arguments to fit a sentinel");
5751       else
5752         {
5753           tree sentinel, end;
5754           unsigned pos = 0;
5755
5756           if (TREE_VALUE (attr))
5757             {
5758               tree p = TREE_VALUE (TREE_VALUE (attr));
5759               pos = TREE_INT_CST_LOW (p);
5760             }
5761
5762           sentinel = end = params;
5763
5764           /* Advance `end' ahead of `sentinel' by `pos' positions.  */
5765           while (pos > 0 && TREE_CHAIN (end))
5766             {
5767               pos--;
5768               end = TREE_CHAIN (end);
5769             }
5770           if (pos > 0)
5771             {
5772               warning (OPT_Wformat,
5773                        "not enough variable arguments to fit a sentinel");
5774               return;
5775             }
5776
5777           /* Now advance both until we find the last parameter.  */
5778           while (TREE_CHAIN (end))
5779             {
5780               end = TREE_CHAIN (end);
5781               sentinel = TREE_CHAIN (sentinel);
5782             }
5783
5784           /* Validate the sentinel.  */
5785           if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5786                || !integer_zerop (TREE_VALUE (sentinel)))
5787               /* Although __null (in C++) is only an integer we allow it
5788                  nevertheless, as we are guaranteed that it's exactly
5789                  as wide as a pointer, and we don't want to force
5790                  users to cast the NULL they have written there.
5791                  We warn with -Wstrict-null-sentinel, though.  */
5792               && (warn_strict_null_sentinel
5793                   || null_node != TREE_VALUE (sentinel)))
5794             warning (OPT_Wformat, "missing sentinel in function call");
5795         }
5796     }
5797 }
5798
5799 /* Helper for check_function_nonnull; given a list of operands which
5800    must be non-null in ARGS, determine if operand PARAM_NUM should be
5801    checked.  */
5802
5803 static bool
5804 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5805 {
5806   unsigned HOST_WIDE_INT arg_num = 0;
5807
5808   for (; args; args = TREE_CHAIN (args))
5809     {
5810       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5811
5812       gcc_assert (found);
5813
5814       if (arg_num == param_num)
5815         return true;
5816     }
5817   return false;
5818 }
5819
5820 /* Check that the function argument PARAM (which is operand number
5821    PARAM_NUM) is non-null.  This is called by check_function_nonnull
5822    via check_function_arguments_recurse.  */
5823
5824 static void
5825 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5826                    unsigned HOST_WIDE_INT param_num)
5827 {
5828   /* Just skip checking the argument if it's not a pointer.  This can
5829      happen if the "nonnull" attribute was given without an operand
5830      list (which means to check every pointer argument).  */
5831
5832   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5833     return;
5834
5835   if (integer_zerop (param))
5836     warning (OPT_Wnonnull, "null argument where non-null required "
5837              "(argument %lu)", (unsigned long) param_num);
5838 }
5839
5840 /* Helper for nonnull attribute handling; fetch the operand number
5841    from the attribute argument list.  */
5842
5843 static bool
5844 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5845 {
5846   /* Verify the arg number is a constant.  */
5847   if (TREE_CODE (arg_num_expr) != INTEGER_CST
5848       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5849     return false;
5850
5851   *valp = TREE_INT_CST_LOW (arg_num_expr);
5852   return true;
5853 }
5854
5855 /* Handle a "nothrow" attribute; arguments as in
5856    struct attribute_spec.handler.  */
5857
5858 static tree
5859 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5860                           int ARG_UNUSED (flags), bool *no_add_attrs)
5861 {
5862   if (TREE_CODE (*node) == FUNCTION_DECL)
5863     TREE_NOTHROW (*node) = 1;
5864   /* ??? TODO: Support types.  */
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 "cleanup" attribute; arguments as in
5875    struct attribute_spec.handler.  */
5876
5877 static tree
5878 handle_cleanup_attribute (tree *node, tree name, tree args,
5879                           int ARG_UNUSED (flags), bool *no_add_attrs)
5880 {
5881   tree decl = *node;
5882   tree cleanup_id, cleanup_decl;
5883
5884   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5885      for global destructors in C++.  This requires infrastructure that
5886      we don't have generically at the moment.  It's also not a feature
5887      we'd be missing too much, since we do have attribute constructor.  */
5888   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5889     {
5890       warning (OPT_Wattributes, "%qE attribute ignored", name);
5891       *no_add_attrs = true;
5892       return NULL_TREE;
5893     }
5894
5895   /* Verify that the argument is a function in scope.  */
5896   /* ??? We could support pointers to functions here as well, if
5897      that was considered desirable.  */
5898   cleanup_id = TREE_VALUE (args);
5899   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5900     {
5901       error ("cleanup argument not an identifier");
5902       *no_add_attrs = true;
5903       return NULL_TREE;
5904     }
5905   cleanup_decl = lookup_name (cleanup_id);
5906   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5907     {
5908       error ("cleanup argument not a function");
5909       *no_add_attrs = true;
5910       return NULL_TREE;
5911     }
5912
5913   /* That the function has proper type is checked with the
5914      eventual call to build_function_call.  */
5915
5916   return NULL_TREE;
5917 }
5918
5919 /* Handle a "warn_unused_result" attribute.  No special handling.  */
5920
5921 static tree
5922 handle_warn_unused_result_attribute (tree *node, tree name,
5923                                tree ARG_UNUSED (args),
5924                                int ARG_UNUSED (flags), bool *no_add_attrs)
5925 {
5926   /* Ignore the attribute for functions not returning any value.  */
5927   if (VOID_TYPE_P (TREE_TYPE (*node)))
5928     {
5929       warning (OPT_Wattributes, "%qE attribute ignored", name);
5930       *no_add_attrs = true;
5931     }
5932
5933   return NULL_TREE;
5934 }
5935
5936 /* Handle a "sentinel" attribute.  */
5937
5938 static tree
5939 handle_sentinel_attribute (tree *node, tree name, tree args,
5940                            int ARG_UNUSED (flags), bool *no_add_attrs)
5941 {
5942   tree params = TYPE_ARG_TYPES (*node);
5943
5944   if (!params)
5945     {
5946       warning (OPT_Wattributes,
5947                "%qE attribute requires prototypes with named arguments", name);
5948       *no_add_attrs = true;
5949     }
5950   else
5951     {
5952       while (TREE_CHAIN (params))
5953         params = TREE_CHAIN (params);
5954
5955       if (VOID_TYPE_P (TREE_VALUE (params)))
5956         {
5957           warning (OPT_Wattributes,
5958                    "%qE attribute only applies to variadic functions", name);
5959           *no_add_attrs = true;
5960         }
5961     }
5962
5963   if (args)
5964     {
5965       tree position = TREE_VALUE (args);
5966
5967       if (TREE_CODE (position) != INTEGER_CST)
5968         {
5969           warning (0, "requested position is not an integer constant");
5970           *no_add_attrs = true;
5971         }
5972       else
5973         {
5974           if (tree_int_cst_lt (position, integer_zero_node))
5975             {
5976               warning (0, "requested position is less than zero");
5977               *no_add_attrs = true;
5978             }
5979         }
5980     }
5981
5982   return NULL_TREE;
5983 }
5984 \f
5985 /* Check for valid arguments being passed to a function.  */
5986 void
5987 check_function_arguments (tree attrs, tree params, tree typelist)
5988 {
5989   /* Check for null being passed in a pointer argument that must be
5990      non-null.  We also need to do this if format checking is enabled.  */
5991
5992   if (warn_nonnull)
5993     check_function_nonnull (attrs, params);
5994
5995   /* Check for errors in format strings.  */
5996
5997   if (warn_format || warn_missing_format_attribute)
5998       check_function_format (attrs, params);
5999
6000   if (warn_format)
6001     check_function_sentinel (attrs, params, typelist);
6002 }
6003
6004 /* Generic argument checking recursion routine.  PARAM is the argument to
6005    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
6006    once the argument is resolved.  CTX is context for the callback.  */
6007 void
6008 check_function_arguments_recurse (void (*callback)
6009                                   (void *, tree, unsigned HOST_WIDE_INT),
6010                                   void *ctx, tree param,
6011                                   unsigned HOST_WIDE_INT param_num)
6012 {
6013   if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6014       && (TYPE_PRECISION (TREE_TYPE (param))
6015           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6016     {
6017       /* Strip coercion.  */
6018       check_function_arguments_recurse (callback, ctx,
6019                                         TREE_OPERAND (param, 0), param_num);
6020       return;
6021     }
6022
6023   if (TREE_CODE (param) == CALL_EXPR)
6024     {
6025       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6026       tree attrs;
6027       bool found_format_arg = false;
6028
6029       /* See if this is a call to a known internationalization function
6030          that modifies a format arg.  Such a function may have multiple
6031          format_arg attributes (for example, ngettext).  */
6032
6033       for (attrs = TYPE_ATTRIBUTES (type);
6034            attrs;
6035            attrs = TREE_CHAIN (attrs))
6036         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6037           {
6038             tree inner_arg;
6039             tree format_num_expr;
6040             int format_num;
6041             int i;
6042             call_expr_arg_iterator iter;
6043
6044             /* Extract the argument number, which was previously checked
6045                to be valid.  */
6046             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6047
6048             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6049                         && !TREE_INT_CST_HIGH (format_num_expr));
6050
6051             format_num = TREE_INT_CST_LOW (format_num_expr);
6052
6053             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6054                  inner_arg != 0;
6055                  inner_arg = next_call_expr_arg (&iter), i++)
6056               if (i == format_num)
6057                 {
6058                   check_function_arguments_recurse (callback, ctx,
6059                                                     inner_arg, param_num);
6060                   found_format_arg = true;
6061                   break;
6062                 }
6063           }
6064
6065       /* If we found a format_arg attribute and did a recursive check,
6066          we are done with checking this argument.  Otherwise, we continue
6067          and this will be considered a non-literal.  */
6068       if (found_format_arg)
6069         return;
6070     }
6071
6072   if (TREE_CODE (param) == COND_EXPR)
6073     {
6074       /* Check both halves of the conditional expression.  */
6075       check_function_arguments_recurse (callback, ctx,
6076                                         TREE_OPERAND (param, 1), param_num);
6077       check_function_arguments_recurse (callback, ctx,
6078                                         TREE_OPERAND (param, 2), param_num);
6079       return;
6080     }
6081
6082   (*callback) (ctx, param, param_num);
6083 }
6084
6085 /* Function to help qsort sort FIELD_DECLs by name order.  */
6086
6087 int
6088 field_decl_cmp (const void *x_p, const void *y_p)
6089 {
6090   const tree *const x = (const tree *const) x_p;
6091   const tree *const y = (const tree *const) y_p;
6092
6093   if (DECL_NAME (*x) == DECL_NAME (*y))
6094     /* A nontype is "greater" than a type.  */
6095     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6096   if (DECL_NAME (*x) == NULL_TREE)
6097     return -1;
6098   if (DECL_NAME (*y) == NULL_TREE)
6099     return 1;
6100   if (DECL_NAME (*x) < DECL_NAME (*y))
6101     return -1;
6102   return 1;
6103 }
6104
6105 static struct {
6106   gt_pointer_operator new_value;
6107   void *cookie;
6108 } resort_data;
6109
6110 /* This routine compares two fields like field_decl_cmp but using the
6111 pointer operator in resort_data.  */
6112
6113 static int
6114 resort_field_decl_cmp (const void *x_p, const void *y_p)
6115 {
6116   const tree *const x = (const tree *const) x_p;
6117   const tree *const y = (const tree *const) y_p;
6118
6119   if (DECL_NAME (*x) == DECL_NAME (*y))
6120     /* A nontype is "greater" than a type.  */
6121     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6122   if (DECL_NAME (*x) == NULL_TREE)
6123     return -1;
6124   if (DECL_NAME (*y) == NULL_TREE)
6125     return 1;
6126   {
6127     tree d1 = DECL_NAME (*x);
6128     tree d2 = DECL_NAME (*y);
6129     resort_data.new_value (&d1, resort_data.cookie);
6130     resort_data.new_value (&d2, resort_data.cookie);
6131     if (d1 < d2)
6132       return -1;
6133   }
6134   return 1;
6135 }
6136
6137 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
6138
6139 void
6140 resort_sorted_fields (void *obj,
6141                       void * ARG_UNUSED (orig_obj),
6142                       gt_pointer_operator new_value,
6143                       void *cookie)
6144 {
6145   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6146   resort_data.new_value = new_value;
6147   resort_data.cookie = cookie;
6148   qsort (&sf->elts[0], sf->len, sizeof (tree),
6149          resort_field_decl_cmp);
6150 }
6151
6152 /* Subroutine of c_parse_error.
6153    Return the result of concatenating LHS and RHS. RHS is really
6154    a string literal, its first character is indicated by RHS_START and
6155    RHS_SIZE is its length (including the terminating NUL character).
6156
6157    The caller is responsible for deleting the returned pointer.  */
6158
6159 static char *
6160 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6161 {
6162   const int lhs_size = strlen (lhs);
6163   char *result = XNEWVEC (char, lhs_size + rhs_size);
6164   strncpy (result, lhs, lhs_size);
6165   strncpy (result + lhs_size, rhs_start, rhs_size);
6166   return result;
6167 }
6168
6169 /* Issue the error given by GMSGID, indicating that it occurred before
6170    TOKEN, which had the associated VALUE.  */
6171
6172 void
6173 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6174 {
6175 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6176
6177   char *message = NULL;
6178
6179   if (token == CPP_EOF)
6180     message = catenate_messages (gmsgid, " at end of input");
6181   else if (token == CPP_CHAR || token == CPP_WCHAR)
6182     {
6183       unsigned int val = TREE_INT_CST_LOW (value);
6184       const char *const ell = (token == CPP_CHAR) ? "" : "L";
6185       if (val <= UCHAR_MAX && ISGRAPH (val))
6186         message = catenate_messages (gmsgid, " before %s'%c'");
6187       else
6188         message = catenate_messages (gmsgid, " before %s'\\x%x'");
6189
6190       error (message, ell, val);
6191       free (message);
6192       message = NULL;
6193     }
6194   else if (token == CPP_STRING || token == CPP_WSTRING)
6195     message = catenate_messages (gmsgid, " before string constant");
6196   else if (token == CPP_NUMBER)
6197     message = catenate_messages (gmsgid, " before numeric constant");
6198   else if (token == CPP_NAME)
6199     {
6200       message = catenate_messages (gmsgid, " before %qE");
6201       error (message, value);
6202       free (message);
6203       message = NULL;
6204     }
6205   else if (token == CPP_PRAGMA)
6206     message = catenate_messages (gmsgid, " before %<#pragma%>");
6207   else if (token == CPP_PRAGMA_EOL)
6208     message = catenate_messages (gmsgid, " before end of line");
6209   else if (token < N_TTYPES)
6210     {
6211       message = catenate_messages (gmsgid, " before %qs token");
6212       error (message, cpp_type2name (token));
6213       free (message);
6214       message = NULL;
6215     }
6216   else
6217     error (gmsgid);
6218
6219   if (message)
6220     {
6221       error (message);
6222       free (message);
6223     }
6224 #undef catenate_messages
6225 }
6226
6227 /* Walk a gimplified function and warn for functions whose return value is
6228    ignored and attribute((warn_unused_result)) is set.  This is done before
6229    inlining, so we don't have to worry about that.  */
6230
6231 void
6232 c_warn_unused_result (tree *top_p)
6233 {
6234   tree t = *top_p;
6235   tree_stmt_iterator i;
6236   tree fdecl, ftype;
6237
6238   switch (TREE_CODE (t))
6239     {
6240     case STATEMENT_LIST:
6241       for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6242         c_warn_unused_result (tsi_stmt_ptr (i));
6243       break;
6244
6245     case COND_EXPR:
6246       c_warn_unused_result (&COND_EXPR_THEN (t));
6247       c_warn_unused_result (&COND_EXPR_ELSE (t));
6248       break;
6249     case BIND_EXPR:
6250       c_warn_unused_result (&BIND_EXPR_BODY (t));
6251       break;
6252     case TRY_FINALLY_EXPR:
6253     case TRY_CATCH_EXPR:
6254       c_warn_unused_result (&TREE_OPERAND (t, 0));
6255       c_warn_unused_result (&TREE_OPERAND (t, 1));
6256       break;
6257     case CATCH_EXPR:
6258       c_warn_unused_result (&CATCH_BODY (t));
6259       break;
6260     case EH_FILTER_EXPR:
6261       c_warn_unused_result (&EH_FILTER_FAILURE (t));
6262       break;
6263
6264     case CALL_EXPR:
6265       if (TREE_USED (t))
6266         break;
6267
6268       /* This is a naked call, as opposed to a CALL_EXPR nested inside
6269          a MODIFY_EXPR.  All calls whose value is ignored should be
6270          represented like this.  Look for the attribute.  */
6271       fdecl = get_callee_fndecl (t);
6272       if (fdecl)
6273         ftype = TREE_TYPE (fdecl);
6274       else
6275         {
6276           ftype = TREE_TYPE (CALL_EXPR_FN (t));
6277           /* Look past pointer-to-function to the function type itself.  */
6278           ftype = TREE_TYPE (ftype);
6279         }
6280
6281       if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6282         {
6283           if (fdecl)
6284             warning (0, "%Hignoring return value of %qD, "
6285                      "declared with attribute warn_unused_result",
6286                      EXPR_LOCUS (t), fdecl);
6287           else
6288             warning (0, "%Hignoring return value of function "
6289                      "declared with attribute warn_unused_result",
6290                      EXPR_LOCUS (t));
6291         }
6292       break;
6293
6294     default:
6295       /* Not a container, not a call, or a call whose value is used.  */
6296       break;
6297     }
6298 }
6299
6300 /* Convert a character from the host to the target execution character
6301    set.  cpplib handles this, mostly.  */
6302
6303 HOST_WIDE_INT
6304 c_common_to_target_charset (HOST_WIDE_INT c)
6305 {
6306   /* Character constants in GCC proper are sign-extended under -fsigned-char,
6307      zero-extended under -fno-signed-char.  cpplib insists that characters
6308      and character constants are always unsigned.  Hence we must convert
6309      back and forth.  */
6310   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6311
6312   uc = cpp_host_to_exec_charset (parse_in, uc);
6313
6314   if (flag_signed_char)
6315     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6316                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6317   else
6318     return uc;
6319 }
6320
6321 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
6322    component references, with STOP_REF, or alternatively an INDIRECT_REF of
6323    NULL, at the bottom; much like the traditional rendering of offsetof as a
6324    macro.  Returns the folded and properly cast result.  */
6325
6326 static tree
6327 fold_offsetof_1 (tree expr, tree stop_ref)
6328 {
6329   enum tree_code code = PLUS_EXPR;
6330   tree base, off, t;
6331
6332   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6333     return size_zero_node;
6334
6335   switch (TREE_CODE (expr))
6336     {
6337     case ERROR_MARK:
6338       return expr;
6339
6340     case VAR_DECL:
6341       error ("cannot apply %<offsetof%> to static data member %qD", expr);
6342       return error_mark_node;
6343
6344     case CALL_EXPR:
6345       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6346       return error_mark_node;
6347
6348     case INTEGER_CST:
6349       gcc_assert (integer_zerop (expr));
6350       return size_zero_node;
6351
6352     case NOP_EXPR:
6353     case INDIRECT_REF:
6354       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6355       gcc_assert (base == error_mark_node || base == size_zero_node);
6356       return base;
6357
6358     case COMPONENT_REF:
6359       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6360       if (base == error_mark_node)
6361         return base;
6362
6363       t = TREE_OPERAND (expr, 1);
6364       if (DECL_C_BIT_FIELD (t))
6365         {
6366           error ("attempt to take address of bit-field structure "
6367                  "member %qD", t);
6368           return error_mark_node;
6369         }
6370       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6371                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6372                                   / BITS_PER_UNIT));
6373       break;
6374
6375     case ARRAY_REF:
6376       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6377       if (base == error_mark_node)
6378         return base;
6379
6380       t = TREE_OPERAND (expr, 1);
6381       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6382         {
6383           code = MINUS_EXPR;
6384           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6385         }
6386       t = convert (sizetype, t);
6387       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6388       break;
6389
6390     default:
6391       gcc_unreachable ();
6392     }
6393
6394   return size_binop (code, base, off);
6395 }
6396
6397 tree
6398 fold_offsetof (tree expr, tree stop_ref)
6399 {
6400   /* Convert back from the internal sizetype to size_t.  */
6401   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6402 }
6403
6404 /* Print an error message for an invalid lvalue.  USE says
6405    how the lvalue is being used and so selects the error message.  */
6406
6407 void
6408 lvalue_error (enum lvalue_use use)
6409 {
6410   switch (use)
6411     {
6412     case lv_assign:
6413       error ("lvalue required as left operand of assignment");
6414       break;
6415     case lv_increment:
6416       error ("lvalue required as increment operand");
6417       break;
6418     case lv_decrement:
6419       error ("lvalue required as decrement operand");
6420       break;
6421     case lv_addressof:
6422       error ("lvalue required as unary %<&%> operand");
6423       break;
6424     case lv_asm:
6425       error ("lvalue required in asm statement");
6426       break;
6427     default:
6428       gcc_unreachable ();
6429     }
6430 }
6431 \f
6432 /* *PTYPE is an incomplete array.  Complete it with a domain based on
6433    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6434    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6435    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
6436
6437 int
6438 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6439 {
6440   tree maxindex, type, main_type, elt, unqual_elt;
6441   int failure = 0, quals;
6442   hashval_t hashcode = 0;
6443
6444   maxindex = size_zero_node;
6445   if (initial_value)
6446     {
6447       if (TREE_CODE (initial_value) == STRING_CST)
6448         {
6449           int eltsize
6450             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6451           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6452         }
6453       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6454         {
6455           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6456
6457           if (VEC_empty (constructor_elt, v))
6458             {
6459               if (pedantic)
6460                 failure = 3;
6461               maxindex = integer_minus_one_node;
6462             }
6463           else
6464             {
6465               tree curindex;
6466               unsigned HOST_WIDE_INT cnt;
6467               constructor_elt *ce;
6468
6469               if (VEC_index (constructor_elt, v, 0)->index)
6470                 maxindex = fold_convert (sizetype,
6471                                          VEC_index (constructor_elt,
6472                                                     v, 0)->index);
6473               curindex = maxindex;
6474
6475               for (cnt = 1;
6476                    VEC_iterate (constructor_elt, v, cnt, ce);
6477                    cnt++)
6478                 {
6479                   if (ce->index)
6480                     curindex = fold_convert (sizetype, ce->index);
6481                   else
6482                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6483
6484                   if (tree_int_cst_lt (maxindex, curindex))
6485                     maxindex = curindex;
6486                 }
6487             }
6488         }
6489       else
6490         {
6491           /* Make an error message unless that happened already.  */
6492           if (initial_value != error_mark_node)
6493             failure = 1;
6494         }
6495     }
6496   else
6497     {
6498       failure = 2;
6499       if (!do_default)
6500         return failure;
6501     }
6502
6503   type = *ptype;
6504   elt = TREE_TYPE (type);
6505   quals = TYPE_QUALS (strip_array_types (elt));
6506   if (quals == 0)
6507     unqual_elt = elt;
6508   else
6509     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6510
6511   /* Using build_distinct_type_copy and modifying things afterward instead
6512      of using build_array_type to create a new type preserves all of the
6513      TYPE_LANG_FLAG_? bits that the front end may have set.  */
6514   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6515   TREE_TYPE (main_type) = unqual_elt;
6516   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6517   layout_type (main_type);
6518
6519   /* Make sure we have the canonical MAIN_TYPE. */
6520   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
6521   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6522                                     hashcode);
6523   main_type = type_hash_canon (hashcode, main_type);
6524
6525   if (quals == 0)
6526     type = main_type;
6527   else
6528     type = c_build_qualified_type (main_type, quals);
6529
6530   *ptype = type;
6531   return failure;
6532 }
6533
6534 \f
6535 /* Used to help initialize the builtin-types.def table.  When a type of
6536    the correct size doesn't exist, use error_mark_node instead of NULL.
6537    The later results in segfaults even when a decl using the type doesn't
6538    get invoked.  */
6539
6540 tree
6541 builtin_type_for_size (int size, bool unsignedp)
6542 {
6543   tree type = lang_hooks.types.type_for_size (size, unsignedp);
6544   return type ? type : error_mark_node;
6545 }
6546
6547 /* A helper function for resolve_overloaded_builtin in resolving the
6548    overloaded __sync_ builtins.  Returns a positive power of 2 if the
6549    first operand of PARAMS is a pointer to a supported data type.
6550    Returns 0 if an error is encountered.  */
6551
6552 static int
6553 sync_resolve_size (tree function, tree params)
6554 {
6555   tree type;
6556   int size;
6557
6558   if (params == NULL)
6559     {
6560       error ("too few arguments to function %qE", function);
6561       return 0;
6562     }
6563
6564   type = TREE_TYPE (TREE_VALUE (params));
6565   if (TREE_CODE (type) != POINTER_TYPE)
6566     goto incompatible;
6567
6568   type = TREE_TYPE (type);
6569   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6570     goto incompatible;
6571
6572   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6573   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6574     return size;
6575
6576  incompatible:
6577   error ("incompatible type for argument %d of %qE", 1, function);
6578   return 0;
6579 }
6580
6581 /* A helper function for resolve_overloaded_builtin.  Adds casts to
6582    PARAMS to make arguments match up with those of FUNCTION.  Drops
6583    the variadic arguments at the end.  Returns false if some error
6584    was encountered; true on success.  */
6585
6586 static bool
6587 sync_resolve_params (tree orig_function, tree function, tree params)
6588 {
6589   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6590   tree ptype;
6591   int number;
6592
6593   /* We've declared the implementation functions to use "volatile void *"
6594      as the pointer parameter, so we shouldn't get any complaints from the
6595      call to check_function_arguments what ever type the user used.  */
6596   arg_types = TREE_CHAIN (arg_types);
6597   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6598   number = 2;
6599
6600   /* For the rest of the values, we need to cast these to FTYPE, so that we
6601      don't get warnings for passing pointer types, etc.  */
6602   while (arg_types != void_list_node)
6603     {
6604       tree val;
6605
6606       params = TREE_CHAIN (params);
6607       if (params == NULL)
6608         {
6609           error ("too few arguments to function %qE", orig_function);
6610           return false;
6611         }
6612
6613       /* ??? Ideally for the first conversion we'd use convert_for_assignment
6614          so that we get warnings for anything that doesn't match the pointer
6615          type.  This isn't portable across the C and C++ front ends atm.  */
6616       val = TREE_VALUE (params);
6617       val = convert (ptype, val);
6618       val = convert (TREE_VALUE (arg_types), val);
6619       TREE_VALUE (params) = val;
6620
6621       arg_types = TREE_CHAIN (arg_types);
6622       number++;
6623     }
6624
6625   /* The definition of these primitives is variadic, with the remaining
6626      being "an optional list of variables protected by the memory barrier".
6627      No clue what that's supposed to mean, precisely, but we consider all
6628      call-clobbered variables to be protected so we're safe.  */
6629   TREE_CHAIN (params) = NULL;
6630
6631   return true;
6632 }
6633
6634 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
6635    RESULT to make it match the type of the first pointer argument in
6636    PARAMS.  */
6637
6638 static tree
6639 sync_resolve_return (tree params, tree result)
6640 {
6641   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6642   ptype = TYPE_MAIN_VARIANT (ptype);
6643   return convert (ptype, result);
6644 }
6645
6646 /* Some builtin functions are placeholders for other expressions.  This
6647    function should be called immediately after parsing the call expression
6648    before surrounding code has committed to the type of the expression.
6649
6650    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6651    PARAMS is the argument list for the call.  The return value is non-null
6652    when expansion is complete, and null if normal processing should
6653    continue.  */
6654
6655 tree
6656 resolve_overloaded_builtin (tree function, tree params)
6657 {
6658   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6659   switch (DECL_BUILT_IN_CLASS (function))
6660     {
6661     case BUILT_IN_NORMAL:
6662       break;
6663     case BUILT_IN_MD:
6664       if (targetm.resolve_overloaded_builtin)
6665         return targetm.resolve_overloaded_builtin (function, params);
6666       else
6667         return NULL_TREE;
6668     default:
6669       return NULL_TREE;
6670     }
6671
6672   /* Handle BUILT_IN_NORMAL here.  */
6673   switch (orig_code)
6674     {
6675     case BUILT_IN_FETCH_AND_ADD_N:
6676     case BUILT_IN_FETCH_AND_SUB_N:
6677     case BUILT_IN_FETCH_AND_OR_N:
6678     case BUILT_IN_FETCH_AND_AND_N:
6679     case BUILT_IN_FETCH_AND_XOR_N:
6680     case BUILT_IN_FETCH_AND_NAND_N:
6681     case BUILT_IN_ADD_AND_FETCH_N:
6682     case BUILT_IN_SUB_AND_FETCH_N:
6683     case BUILT_IN_OR_AND_FETCH_N:
6684     case BUILT_IN_AND_AND_FETCH_N:
6685     case BUILT_IN_XOR_AND_FETCH_N:
6686     case BUILT_IN_NAND_AND_FETCH_N:
6687     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6688     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6689     case BUILT_IN_LOCK_TEST_AND_SET_N:
6690     case BUILT_IN_LOCK_RELEASE_N:
6691       {
6692         int n = sync_resolve_size (function, params);
6693         tree new_function, result;
6694
6695         if (n == 0)
6696           return error_mark_node;
6697
6698         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6699         if (!sync_resolve_params (function, new_function, params))
6700           return error_mark_node;
6701
6702         result = build_function_call (new_function, params);
6703         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6704             && orig_code != BUILT_IN_LOCK_RELEASE_N)
6705           result = sync_resolve_return (params, result);
6706
6707         return result;
6708       }
6709
6710     default:
6711       return NULL_TREE;
6712     }
6713 }
6714
6715 /* Ignoring their sign, return true if two scalar types are the same.  */
6716 bool
6717 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6718 {
6719   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6720
6721   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6722               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6723
6724   /* Equality works here because c_common_signed_type uses
6725      TYPE_MAIN_VARIANT.  */
6726   return lang_hooks.types.signed_type (t1)
6727     == lang_hooks.types.signed_type (t2);
6728 }
6729
6730 /* Check for missing format attributes on function pointers.  LTYPE is
6731    the new type or left-hand side type.  RTYPE is the old type or
6732    right-hand side type.  Returns TRUE if LTYPE is missing the desired
6733    attribute.  */
6734
6735 bool
6736 check_missing_format_attribute (tree ltype, tree rtype)
6737 {
6738   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6739   tree ra;
6740
6741   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6742     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6743       break;
6744   if (ra)
6745     {
6746       tree la;
6747       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6748         if (is_attribute_p ("format", TREE_PURPOSE (la)))
6749           break;
6750       return !la;
6751     }
6752   else
6753     return false;
6754 }
6755
6756 /* Subscripting with type char is likely to lose on a machine where
6757    chars are signed.  So warn on any machine, but optionally.  Don't
6758    warn for unsigned char since that type is safe.  Don't warn for
6759    signed char because anyone who uses that must have done so
6760    deliberately. Furthermore, we reduce the false positive load by
6761    warning only for non-constant value of type char.  */
6762
6763 void
6764 warn_array_subscript_with_type_char (tree index)
6765 {
6766   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6767       && TREE_CODE (index) != INTEGER_CST)
6768     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6769 }
6770
6771 /* Implement -Wparentheses for the unexpected C precedence rules, to
6772    cover cases like x + y << z which readers are likely to
6773    misinterpret.  We have seen an expression in which CODE is a binary
6774    operator used to combine expressions headed by CODE_LEFT and
6775    CODE_RIGHT.  CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6776    means that that side of the expression was not formed using a
6777    binary operator, or it was enclosed in parentheses.  */
6778
6779 void
6780 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6781                         enum tree_code code_right)
6782 {
6783   if (!warn_parentheses)
6784     return;
6785
6786   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
6787     {
6788       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6789           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6790         warning (OPT_Wparentheses,
6791                  "suggest parentheses around + or - inside shift");
6792     }
6793
6794   if (code == TRUTH_ORIF_EXPR)
6795     {
6796       if (code_left == TRUTH_ANDIF_EXPR
6797           || code_right == TRUTH_ANDIF_EXPR)
6798         warning (OPT_Wparentheses,
6799                  "suggest parentheses around && within ||");
6800     }
6801
6802   if (code == BIT_IOR_EXPR)
6803     {
6804       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
6805           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6806           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
6807           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6808         warning (OPT_Wparentheses,
6809                  "suggest parentheses around arithmetic in operand of |");
6810       /* Check cases like x|y==z */
6811       if (TREE_CODE_CLASS (code_left) == tcc_comparison
6812           || TREE_CODE_CLASS (code_right) == tcc_comparison)
6813         warning (OPT_Wparentheses,
6814                  "suggest parentheses around comparison in operand of |");
6815     }
6816
6817   if (code == BIT_XOR_EXPR)
6818     {
6819       if (code_left == BIT_AND_EXPR
6820           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6821           || code_right == BIT_AND_EXPR
6822           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6823         warning (OPT_Wparentheses,
6824                  "suggest parentheses around arithmetic in operand of ^");
6825       /* Check cases like x^y==z */
6826       if (TREE_CODE_CLASS (code_left) == tcc_comparison
6827           || TREE_CODE_CLASS (code_right) == tcc_comparison)
6828         warning (OPT_Wparentheses,
6829                  "suggest parentheses around comparison in operand of ^");
6830     }
6831
6832   if (code == BIT_AND_EXPR)
6833     {
6834       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6835           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6836         warning (OPT_Wparentheses,
6837                  "suggest parentheses around + or - in operand of &");
6838       /* Check cases like x&y==z */
6839       if (TREE_CODE_CLASS (code_left) == tcc_comparison
6840           || TREE_CODE_CLASS (code_right) == tcc_comparison)
6841         warning (OPT_Wparentheses,
6842                  "suggest parentheses around comparison in operand of &");
6843     }
6844
6845   if (code == EQ_EXPR || code == NE_EXPR)
6846     {
6847       if (TREE_CODE_CLASS (code_left) == tcc_comparison
6848           || TREE_CODE_CLASS (code_right) == tcc_comparison)
6849         warning (OPT_Wparentheses,
6850                  "suggest parentheses around comparison in operand of %s",
6851                  code == EQ_EXPR ? "==" : "!=");
6852     }
6853   else if (TREE_CODE_CLASS (code) == tcc_comparison)
6854     {
6855       if ((TREE_CODE_CLASS (code_left) == tcc_comparison
6856            && code_left != NE_EXPR && code_left != EQ_EXPR)
6857           || (TREE_CODE_CLASS (code_right) == tcc_comparison
6858               && code_right != NE_EXPR && code_right != EQ_EXPR))
6859         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
6860                  "have their mathematical meaning");
6861     }
6862 }
6863
6864 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
6865
6866 void
6867 warn_for_unused_label (tree label)
6868 {
6869   if (!TREE_USED (label))
6870     {
6871       if (DECL_INITIAL (label))
6872         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
6873       else
6874         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
6875     }
6876 }
6877
6878 #include "gt-c-common.h"