gcc/c-common.c

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