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