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