gcc/c-common.c

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