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