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