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