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