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