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