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