gcc/c-common.c

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