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