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