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