gcc/c-common.c

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