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, 2005, 2006, 2007, 2008 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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "intl.h"
  26 #include "tree.h"
  27 #include "flags.h"
  28 #include "output.h"
  29 #include "c-pragma.h"
  30 #include "rtl.h"
  31 #include "ggc.h"
  32 #include "varray.h"
  33 #include "expr.h"
  34 #include "c-common.h"
  35 #include "diagnostic.h"
  36 #include "tm_p.h"
  37 #include "obstack.h"
  38 #include "cpplib.h"
  39 #include "target.h"
  40 #include "langhooks.h"
  41 #include "tree-inline.h"
  42 #include "c-tree.h"
  43 #include "toplev.h"
  44 #include "tree-iterator.h"
  45 #include "hashtab.h"
  46 #include "tree-mudflap.h"
  47 #include "opts.h"
  48 #include "real.h"
  49 #include "cgraph.h"
  50 #include "target-def.h"
  51 #include "fixed-value.h"
  52
  53 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  54
  55 /* We let tm.h override the types used here, to handle trivial differences
  56    such as the choice of unsigned int or long unsigned int for size_t.
  57    When machines start needing nontrivial differences in the size type,
  58    it would be best to do something here to figure out automatically
  59    from other information what type to use.  */
  60
  61 #ifndef SIZE_TYPE
  62 #define SIZE_TYPE "long unsigned int"
  63 #endif
  64
  65 #ifndef PID_TYPE
  66 #define PID_TYPE "int"
  67 #endif
  68
  69 #ifndef CHAR16_TYPE
  70 #define CHAR16_TYPE "short unsigned int"
  71 #endif
  72
  73 #ifndef CHAR32_TYPE
  74 #define CHAR32_TYPE "unsigned int"
  75 #endif
  76
  77 #ifndef WCHAR_TYPE
  78 #define WCHAR_TYPE "int"
  79 #endif
  80
  81 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  82 #define MODIFIED_WCHAR_TYPE \
  83         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  84
  85 #ifndef PTRDIFF_TYPE
  86 #define PTRDIFF_TYPE "long int"
  87 #endif
  88
  89 #ifndef WINT_TYPE
  90 #define WINT_TYPE "unsigned int"
  91 #endif
  92
  93 #ifndef INTMAX_TYPE
  94 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  95                      ? "int"                                    \
  96                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  97                         ? "long int"                            \
  98                         : "long long int"))
  99 #endif
 100
 101 #ifndef UINTMAX_TYPE
 102 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
 103                      ? "unsigned int"                           \
 104                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
 105                         ? "long unsigned int"                   \
 106                         : "long long unsigned int"))
 107 #endif
 108
 109 /* The following symbols are subsumed in the c_global_trees array, and
 110    listed here individually for documentation purposes.
 111
 112    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
 113
 114         tree short_integer_type_node;
 115         tree long_integer_type_node;
 116         tree long_long_integer_type_node;
 117
 118         tree short_unsigned_type_node;
 119         tree long_unsigned_type_node;
 120         tree long_long_unsigned_type_node;
 121
 122         tree truthvalue_type_node;
 123         tree truthvalue_false_node;
 124         tree truthvalue_true_node;
 125
 126         tree ptrdiff_type_node;
 127
 128         tree unsigned_char_type_node;
 129         tree signed_char_type_node;
 130         tree wchar_type_node;
 131         tree signed_wchar_type_node;
 132         tree unsigned_wchar_type_node;
 133
 134         tree char16_type_node;
 135         tree char32_type_node;
 136
 137         tree float_type_node;
 138         tree double_type_node;
 139         tree long_double_type_node;
 140
 141         tree complex_integer_type_node;
 142         tree complex_float_type_node;
 143         tree complex_double_type_node;
 144         tree complex_long_double_type_node;
 145
 146         tree dfloat32_type_node;
 147         tree dfloat64_type_node;
 148         tree_dfloat128_type_node;
 149
 150         tree intQI_type_node;
 151         tree intHI_type_node;
 152         tree intSI_type_node;
 153         tree intDI_type_node;
 154         tree intTI_type_node;
 155
 156         tree unsigned_intQI_type_node;
 157         tree unsigned_intHI_type_node;
 158         tree unsigned_intSI_type_node;
 159         tree unsigned_intDI_type_node;
 160         tree unsigned_intTI_type_node;
 161
 162         tree widest_integer_literal_type_node;
 163         tree widest_unsigned_literal_type_node;
 164
 165    Nodes for types `void *' and `const void *'.
 166
 167         tree ptr_type_node, const_ptr_type_node;
 168
 169    Nodes for types `char *' and `const char *'.
 170
 171         tree string_type_node, const_string_type_node;
 172
 173    Type `char[SOMENUMBER]'.
 174    Used when an array of char is needed and the size is irrelevant.
 175
 176         tree char_array_type_node;
 177
 178    Type `int[SOMENUMBER]' or something like it.
 179    Used when an array of int needed and the size is irrelevant.
 180
 181         tree int_array_type_node;
 182
 183    Type `wchar_t[SOMENUMBER]' or something like it.
 184    Used when a wide string literal is created.
 185
 186         tree wchar_array_type_node;
 187
 188    Type `char16_t[SOMENUMBER]' or something like it.
 189    Used when a UTF-16 string literal is created.
 190
 191         tree char16_array_type_node;
 192
 193    Type `char32_t[SOMENUMBER]' or something like it.
 194    Used when a UTF-32 string literal is created.
 195
 196         tree char32_array_type_node;
 197
 198    Type `int ()' -- used for implicit declaration of functions.
 199
 200         tree default_function_type;
 201
 202    A VOID_TYPE node, packaged in a TREE_LIST.
 203
 204         tree void_list_node;
 205
 206   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 207   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 208   VAR_DECLS, but C++ does.)
 209
 210         tree function_name_decl_node;
 211         tree pretty_function_name_decl_node;
 212         tree c99_function_name_decl_node;
 213
 214   Stack of nested function name VAR_DECLs.
 215
 216         tree saved_function_name_decls;
 217
 218 */
 219
 220 tree c_global_trees[CTI_MAX];
 221 \f
 222 /* Switches common to the C front ends.  */
 223
 224 /* Nonzero if prepreprocessing only.  */
 225
 226 int flag_preprocess_only;
 227
 228 /* Nonzero means don't output line number information.  */
 229
 230 char flag_no_line_commands;
 231
 232 /* Nonzero causes -E output not to be done, but directives such as
 233    #define that have side effects are still obeyed.  */
 234
 235 char flag_no_output;
 236
 237 /* Nonzero means dump macros in some fashion.  */
 238
 239 char flag_dump_macros;
 240
 241 /* Nonzero means pass #include lines through to the output.  */
 242
 243 char flag_dump_includes;
 244
 245 /* Nonzero means process PCH files while preprocessing.  */
 246
 247 bool flag_pch_preprocess;
 248
 249 /* The file name to which we should write a precompiled header, or
 250    NULL if no header will be written in this compile.  */
 251
 252 const char *pch_file;
 253
 254 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 255    user's namespace.  */
 256 int flag_iso;
 257
 258 /* Nonzero if -undef was given.  It suppresses target built-in macros
 259    and assertions.  */
 260 int flag_undef;
 261
 262 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 263
 264 int flag_no_builtin;
 265
 266 /* Nonzero means don't recognize the non-ANSI builtin functions.
 267    -ansi sets this.  */
 268
 269 int flag_no_nonansi_builtin;
 270
 271 /* Nonzero means give `double' the same size as `float'.  */
 272
 273 int flag_short_double;
 274
 275 /* Nonzero means give `wchar_t' the same size as `short'.  */
 276
 277 int flag_short_wchar;
 278
 279 /* Nonzero means allow implicit conversions between vectors with
 280    differing numbers of subparts and/or differing element types.  */
 281 int flag_lax_vector_conversions;
 282
 283 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
 284 int flag_ms_extensions;
 285
 286 /* Nonzero means don't recognize the keyword `asm'.  */
 287
 288 int flag_no_asm;
 289
 290 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
 291
 292 int flag_signed_bitfields = 1;
 293
 294 /* Warn about #pragma directives that are not recognized.  */
 295
 296 int warn_unknown_pragmas; /* Tri state variable.  */
 297
 298 /* Warn about format/argument anomalies in calls to formatted I/O functions
 299    (*printf, *scanf, strftime, strfmon, etc.).  */
 300
 301 int warn_format;
 302
 303 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
 304    with GCC this doesn't matter as __null is guaranteed to have the right
 305    size.  */
 306
 307 int warn_strict_null_sentinel;
 308
 309 /* Zero means that faster, ...NonNil variants of objc_msgSend...
 310    calls will be used in ObjC; passing nil receivers to such calls
 311    will most likely result in crashes.  */
 312 int flag_nil_receivers = 1;
 313
 314 /* Nonzero means that code generation will be altered to support
 315    "zero-link" execution.  This currently affects ObjC only, but may
 316    affect other languages in the future.  */
 317 int flag_zero_link = 0;
 318
 319 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
 320    unit.  It will inform the ObjC runtime that class definition(s) herein
 321    contained are to replace one(s) previously loaded.  */
 322 int flag_replace_objc_classes = 0;
 323
 324 /* C/ObjC language option variables.  */
 325
 326
 327 /* Nonzero means allow type mismatches in conditional expressions;
 328    just make their values `void'.  */
 329
 330 int flag_cond_mismatch;
 331
 332 /* Nonzero means enable C89 Amendment 1 features.  */
 333
 334 int flag_isoc94;
 335
 336 /* Nonzero means use the ISO C99 dialect of C.  */
 337
 338 int flag_isoc99;
 339
 340 /* Nonzero means that we have builtin functions, and main is an int.  */
 341
 342 int flag_hosted = 1;
 343
 344 /* Warn if main is suspicious.  */
 345
 346 int warn_main;
 347
 348
 349 /* ObjC language option variables.  */
 350
 351
 352 /* Open and close the file for outputting class declarations, if
 353    requested (ObjC).  */
 354
 355 int flag_gen_declaration;
 356
 357 /* Tells the compiler that this is a special run.  Do not perform any
 358    compiling, instead we are to test some platform dependent features
 359    and output a C header file with appropriate definitions.  */
 360
 361 int print_struct_values;
 362
 363 /* Tells the compiler what is the constant string class for Objc.  */
 364
 365 const char *constant_string_class_name;
 366
 367
 368 /* C++ language option variables.  */
 369
 370
 371 /* Nonzero means don't recognize any extension keywords.  */
 372
 373 int flag_no_gnu_keywords;
 374
 375 /* Nonzero means do emit exported implementations of functions even if
 376    they can be inlined.  */
 377
 378 int flag_implement_inlines = 1;
 379
 380 /* Nonzero means that implicit instantiations will be emitted if needed.  */
 381
 382 int flag_implicit_templates = 1;
 383
 384 /* Nonzero means that implicit instantiations of inline templates will be
 385    emitted if needed, even if instantiations of non-inline templates
 386    aren't.  */
 387
 388 int flag_implicit_inline_templates = 1;
 389
 390 /* Nonzero means generate separate instantiation control files and
 391    juggle them at link time.  */
 392
 393 int flag_use_repository;
 394
 395 /* Nonzero if we want to issue diagnostics that the standard says are not
 396    required.  */
 397
 398 int flag_optional_diags = 1;
 399
 400 /* Nonzero means we should attempt to elide constructors when possible.  */
 401
 402 int flag_elide_constructors = 1;
 403
 404 /* Nonzero means that member functions defined in class scope are
 405    inline by default.  */
 406
 407 int flag_default_inline = 1;
 408
 409 /* Controls whether compiler generates 'type descriptor' that give
 410    run-time type information.  */
 411
 412 int flag_rtti = 1;
 413
 414 /* Nonzero if we want to conserve space in the .o files.  We do this
 415    by putting uninitialized data and runtime initialized data into
 416    .common instead of .data at the expense of not flagging multiple
 417    definitions.  */
 418
 419 int flag_conserve_space;
 420
 421 /* Nonzero if we want to obey access control semantics.  */
 422
 423 int flag_access_control = 1;
 424
 425 /* Nonzero if we want to check the return value of new and avoid calling
 426    constructors if it is a null pointer.  */
 427
 428 int flag_check_new;
 429
 430 /* The C++ dialect being used. C++98 is the default.  */
 431
 432 enum cxx_dialect cxx_dialect = cxx98;
 433
 434 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
 435    initialization variables.
 436    0: Old rules, set by -fno-for-scope.
 437    2: New ISO rules, set by -ffor-scope.
 438    1: Try to implement new ISO rules, but with backup compatibility
 439    (and warnings).  This is the default, for now.  */
 440
 441 int flag_new_for_scope = 1;
 442
 443 /* Nonzero if we want to emit defined symbols with common-like linkage as
 444    weak symbols where possible, in order to conform to C++ semantics.
 445    Otherwise, emit them as local symbols.  */
 446
 447 int flag_weak = 1;
 448
 449 /* 0 means we want the preprocessor to not emit line directives for
 450    the current working directory.  1 means we want it to do it.  -1
 451    means we should decide depending on whether debugging information
 452    is being emitted or not.  */
 453
 454 int flag_working_directory = -1;
 455
 456 /* Nonzero to use __cxa_atexit, rather than atexit, to register
 457    destructors for local statics and global objects.  '2' means it has been
 458    set nonzero as a default, not by a command-line flag.  */
 459
 460 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
 461
 462 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
 463    code.  '2' means it has not been set explicitly on the command line.  */
 464
 465 int flag_use_cxa_get_exception_ptr = 2;
 466
 467 /* Nonzero means to implement standard semantics for exception
 468    specifications, calling unexpected if an exception is thrown that
 469    doesn't match the specification.  Zero means to treat them as
 470    assertions and optimize accordingly, but not check them.  */
 471
 472 int flag_enforce_eh_specs = 1;
 473
 474 /* Nonzero means to generate thread-safe code for initializing local
 475    statics.  */
 476
 477 int flag_threadsafe_statics = 1;
 478
 479 /* Nonzero means warn about implicit declarations.  */
 480
 481 int warn_implicit = 1;
 482
 483 /* Maximum template instantiation depth.  This limit is rather
 484    arbitrary, but it exists to limit the time it takes to notice
 485    infinite template instantiations.  */
 486
 487 int max_tinst_depth = 500;
 488
 489
 490
 491 /* The elements of `ridpointers' are identifier nodes for the reserved
 492    type names and storage classes.  It is indexed by a RID_... value.  */
 493 tree *ridpointers;
 494
 495 tree (*make_fname_decl) (tree, int);
 496
 497 /* Nonzero means the expression being parsed will never be evaluated.
 498    This is a count, since unevaluated expressions can nest.  */
 499 int skip_evaluation;
 500
 501 /* Information about how a function name is generated.  */
 502 struct fname_var_t
 503 {
 504   tree *const decl;     /* pointer to the VAR_DECL.  */
 505   const unsigned rid;   /* RID number for the identifier.  */
 506   const int pretty;     /* How pretty is it? */
 507 };
 508
 509 /* The three ways of getting then name of the current function.  */
 510
 511 const struct fname_var_t fname_vars[] =
 512 {
 513   /* C99 compliant __func__, must be first.  */
 514   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 515   /* GCC __FUNCTION__ compliant.  */
 516   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 517   /* GCC __PRETTY_FUNCTION__ compliant.  */
 518   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 519   {NULL, 0, 0},
 520 };
 521
 522 static tree check_case_value (tree);
 523 static bool check_case_bounds (tree, tree, tree *, tree *);
 524
 525 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
 526 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
 527 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
 528 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
 529 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
 530 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
 531 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
 532 static tree handle_always_inline_attribute (tree *, tree, tree, int,
 533                                             bool *);
 534 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
 535 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
 536 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
 537 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
 538 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
 539 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
 540 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
 541                                                  bool *);
 542 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
 543 static tree handle_transparent_union_attribute (tree *, tree, tree,
 544                                                 int, bool *);
 545 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
 546 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
 547 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
 548 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
 549 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
 550 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
 551 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
 552 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
 553 static tree handle_visibility_attribute (tree *, tree, tree, int,
 554                                          bool *);
 555 static tree handle_tls_model_attribute (tree *, tree, tree, int,
 556                                         bool *);
 557 static tree handle_no_instrument_function_attribute (tree *, tree,
 558                                                      tree, int, bool *);
 559 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
 560 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
 561 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
 562                                              bool *);
 563 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
 564 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
 565 static tree handle_deprecated_attribute (tree *, tree, tree, int,
 566                                          bool *);
 567 static tree handle_vector_size_attribute (tree *, tree, tree, int,
 568                                           bool *);
 569 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
 570 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
 571 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
 572 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
 573                                                  bool *);
 574 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
 575 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
 576 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
 577
 578 static void check_function_nonnull (tree, int, tree *);
 579 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
 580 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
 581 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
 582 static int resort_field_decl_cmp (const void *, const void *);
 583
 584 /* Table of machine-independent attributes common to all C-like languages.  */
 585 const struct attribute_spec c_common_attribute_table[] =
 586 {
 587   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 588   { "packed",                 0, 0, false, false, false,
 589                               handle_packed_attribute },
 590   { "nocommon",               0, 0, true,  false, false,
 591                               handle_nocommon_attribute },
 592   { "common",                 0, 0, true,  false, false,
 593                               handle_common_attribute },
 594   /* FIXME: logically, noreturn attributes should be listed as
 595      "false, true, true" and apply to function types.  But implementing this
 596      would require all the places in the compiler that use TREE_THIS_VOLATILE
 597      on a decl to identify non-returning functions to be located and fixed
 598      to check the function type instead.  */
 599   { "noreturn",               0, 0, true,  false, false,
 600                               handle_noreturn_attribute },
 601   { "volatile",               0, 0, true,  false, false,
 602                               handle_noreturn_attribute },
 603   { "noinline",               0, 0, true,  false, false,
 604                               handle_noinline_attribute },
 605   { "always_inline",          0, 0, true,  false, false,
 606                               handle_always_inline_attribute },
 607   { "gnu_inline",             0, 0, true,  false, false,
 608                               handle_gnu_inline_attribute },
 609   { "artificial",             0, 0, true,  false, false,
 610                               handle_artificial_attribute },
 611   { "flatten",                0, 0, true,  false, false,
 612                               handle_flatten_attribute },
 613   { "used",                   0, 0, true,  false, false,
 614                               handle_used_attribute },
 615   { "unused",                 0, 0, false, false, false,
 616                               handle_unused_attribute },
 617   { "externally_visible",     0, 0, true,  false, false,
 618                               handle_externally_visible_attribute },
 619   /* The same comments as for noreturn attributes apply to const ones.  */
 620   { "const",                  0, 0, true,  false, false,
 621                               handle_const_attribute },
 622   { "transparent_union",      0, 0, false, false, false,
 623                               handle_transparent_union_attribute },
 624   { "constructor",            0, 1, true,  false, false,
 625                               handle_constructor_attribute },
 626   { "destructor",             0, 1, true,  false, false,
 627                               handle_destructor_attribute },
 628   { "mode",                   1, 1, false,  true, false,
 629                               handle_mode_attribute },
 630   { "section",                1, 1, true,  false, false,
 631                               handle_section_attribute },
 632   { "aligned",                0, 1, false, false, false,
 633                               handle_aligned_attribute },
 634   { "weak",                   0, 0, true,  false, false,
 635                               handle_weak_attribute },
 636   { "alias",                  1, 1, true,  false, false,
 637                               handle_alias_attribute },
 638   { "weakref",                0, 1, true,  false, false,
 639                               handle_weakref_attribute },
 640   { "no_instrument_function", 0, 0, true,  false, false,
 641                               handle_no_instrument_function_attribute },
 642   { "malloc",                 0, 0, true,  false, false,
 643                               handle_malloc_attribute },
 644   { "returns_twice",          0, 0, true,  false, false,
 645                               handle_returns_twice_attribute },
 646   { "no_stack_limit",         0, 0, true,  false, false,
 647                               handle_no_limit_stack_attribute },
 648   { "pure",                   0, 0, true,  false, false,
 649                               handle_pure_attribute },
 650   /* For internal use (marking of builtins) only.  The name contains space
 651      to prevent its usage in source code.  */
 652   { "no vops",                0, 0, true,  false, false,
 653                               handle_novops_attribute },
 654   { "deprecated",             0, 0, false, false, false,
 655                               handle_deprecated_attribute },
 656   { "vector_size",            1, 1, false, true, false,
 657                               handle_vector_size_attribute },
 658   { "visibility",             1, 1, false, false, false,
 659                               handle_visibility_attribute },
 660   { "tls_model",              1, 1, true,  false, false,
 661                               handle_tls_model_attribute },
 662   { "nonnull",                0, -1, false, true, true,
 663                               handle_nonnull_attribute },
 664   { "nothrow",                0, 0, true,  false, false,
 665                               handle_nothrow_attribute },
 666   { "may_alias",              0, 0, false, true, false, NULL },
 667   { "cleanup",                1, 1, true, false, false,
 668                               handle_cleanup_attribute },
 669   { "warn_unused_result",     0, 0, false, true, true,
 670                               handle_warn_unused_result_attribute },
 671   { "sentinel",               0, 1, false, true, true,
 672                               handle_sentinel_attribute },
 673   /* For internal use (marking of builtins) only.  The name contains space
 674      to prevent its usage in source code.  */
 675   { "type generic",           0, 0, false, true, true,
 676                               handle_type_generic_attribute },
 677   { "alloc_size",             1, 2, false, true, true,
 678                               handle_alloc_size_attribute },
 679   { "cold",                   0, 0, true,  false, false,
 680                               handle_cold_attribute },
 681   { "hot",                    0, 0, true,  false, false,
 682                               handle_hot_attribute },
 683   { "warning",                1, 1, true,  false, false,
 684                               handle_error_attribute },
 685   { "error",                  1, 1, true,  false, false,
 686                               handle_error_attribute },
 687   { NULL,                     0, 0, false, false, false, NULL }
 688 };
 689
 690 /* Give the specifications for the format attributes, used by C and all
 691    descendants.  */
 692
 693 const struct attribute_spec c_common_format_attribute_table[] =
 694 {
 695   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 696   { "format",                 3, 3, false, true,  true,
 697                               handle_format_attribute },
 698   { "format_arg",             1, 1, false, true,  true,
 699                               handle_format_arg_attribute },
 700   { NULL,                     0, 0, false, false, false, NULL }
 701 };
 702
 703 /* Push current bindings for the function name VAR_DECLS.  */
 704
 705 void
 706 start_fname_decls (void)
 707 {
 708   unsigned ix;
 709   tree saved = NULL_TREE;
 710
 711   for (ix = 0; fname_vars[ix].decl; ix++)
 712     {
 713       tree decl = *fname_vars[ix].decl;
 714
 715       if (decl)
 716         {
 717           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
 718           *fname_vars[ix].decl = NULL_TREE;
 719         }
 720     }
 721   if (saved || saved_function_name_decls)
 722     /* Normally they'll have been NULL, so only push if we've got a
 723        stack, or they are non-NULL.  */
 724     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 725                                            saved_function_name_decls);
 726 }
 727
 728 /* Finish up the current bindings, adding them into the current function's
 729    statement tree.  This must be done _before_ finish_stmt_tree is called.
 730    If there is no current function, we must be at file scope and no statements
 731    are involved. Pop the previous bindings.  */
 732
 733 void
 734 finish_fname_decls (void)
 735 {
 736   unsigned ix;
 737   tree stmts = NULL_TREE;
 738   tree stack = saved_function_name_decls;
 739
 740   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 741     append_to_statement_list (TREE_VALUE (stack), &stmts);
 742
 743   if (stmts)
 744     {
 745       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
 746
 747       if (TREE_CODE (*bodyp) == BIND_EXPR)
 748         bodyp = &BIND_EXPR_BODY (*bodyp);
 749
 750       append_to_statement_list_force (*bodyp, &stmts);
 751       *bodyp = stmts;
 752     }
 753
 754   for (ix = 0; fname_vars[ix].decl; ix++)
 755     *fname_vars[ix].decl = NULL_TREE;
 756
 757   if (stack)
 758     {
 759       /* We had saved values, restore them.  */
 760       tree saved;
 761
 762       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 763         {
 764           tree decl = TREE_PURPOSE (saved);
 765           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 766
 767           *fname_vars[ix].decl = decl;
 768         }
 769       stack = TREE_CHAIN (stack);
 770     }
 771   saved_function_name_decls = stack;
 772 }
 773
 774 /* Return the text name of the current function, suitably prettified
 775    by PRETTY_P.  Return string must be freed by caller.  */
 776
 777 const char *
 778 fname_as_string (int pretty_p)
 779 {
 780   const char *name = "top level";
 781   char *namep;
 782   int vrb = 2, len;
 783   cpp_string cstr = { 0, 0 }, strname;
 784
 785   if (!pretty_p)
 786     {
 787       name = "";
 788       vrb = 0;
 789     }
 790
 791   if (current_function_decl)
 792     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
 793
 794   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
 795
 796   namep = XNEWVEC (char, len);
 797   snprintf (namep, len, "\"%s\"", name);
 798   strname.text = (unsigned char *) namep;
 799   strname.len = len - 1;
 800
 801   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
 802     {
 803       XDELETEVEC (namep);
 804       return (const char *) cstr.text;
 805     }
 806
 807   return namep;
 808 }
 809
 810 /* Expand DECL if it declares an entity not handled by the
 811    common code.  */
 812
 813 int
 814 c_expand_decl (tree decl)
 815 {
 816   if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
 817     {
 818       /* Let the back-end know about this variable.  */
 819       if (!anon_aggr_type_p (TREE_TYPE (decl)))
 820         emit_local_var (decl);
 821       else
 822         expand_anon_union_decl (decl, NULL_TREE,
 823                                 DECL_ANON_UNION_ELEMS (decl));
 824     }
 825   else
 826     return 0;
 827
 828   return 1;
 829 }
 830
 831
 832 /* Return the VAR_DECL for a const char array naming the current
 833    function. If the VAR_DECL has not yet been created, create it
 834    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 835    ID is its name (unfortunately C and C++ hold the RID values of
 836    keywords in different places, so we can't derive RID from ID in
 837    this language independent code.  */
 838
 839 tree
 840 fname_decl (unsigned int rid, tree id)
 841 {
 842   unsigned ix;
 843   tree decl = NULL_TREE;
 844
 845   for (ix = 0; fname_vars[ix].decl; ix++)
 846     if (fname_vars[ix].rid == rid)
 847       break;
 848
 849   decl = *fname_vars[ix].decl;
 850   if (!decl)
 851     {
 852       /* If a tree is built here, it would normally have the lineno of
 853          the current statement.  Later this tree will be moved to the
 854          beginning of the function and this line number will be wrong.
 855          To avoid this problem set the lineno to 0 here; that prevents
 856          it from appearing in the RTL.  */
 857       tree stmts;
 858       location_t saved_location = input_location;
 859       input_location = UNKNOWN_LOCATION;
 860
 861       stmts = push_stmt_list ();
 862       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 863       stmts = pop_stmt_list (stmts);
 864       if (!IS_EMPTY_STMT (stmts))
 865         saved_function_name_decls
 866           = tree_cons (decl, stmts, saved_function_name_decls);
 867       *fname_vars[ix].decl = decl;
 868       input_location = saved_location;
 869     }
 870   if (!ix && !current_function_decl)
 871     pedwarn ("%qD is not defined outside of function scope", decl);
 872
 873   return decl;
 874 }
 875
 876 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
 877
 878 tree
 879 fix_string_type (tree value)
 880 {
 881   int length = TREE_STRING_LENGTH (value);
 882   int nchars;
 883   tree e_type, i_type, a_type;
 884
 885   /* Compute the number of elements, for the array type.  */
 886   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
 887     {
 888       nchars = length;
 889       e_type = char_type_node;
 890     }
 891   else if (TREE_TYPE (value) == char16_array_type_node)
 892     {
 893       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
 894       e_type = char16_type_node;
 895     }
 896   else if (TREE_TYPE (value) == char32_array_type_node)
 897     {
 898       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
 899       e_type = char32_type_node;
 900     }
 901   else
 902     {
 903       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
 904       e_type = wchar_type_node;
 905     }
 906
 907   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
 908      limit in C++98 Annex B is very large (65536) and is not normative,
 909      so we do not diagnose it (warn_overlength_strings is forced off
 910      in c_common_post_options).  */
 911   if (warn_overlength_strings)
 912     {
 913       const int nchars_max = flag_isoc99 ? 4095 : 509;
 914       const int relevant_std = flag_isoc99 ? 99 : 90;
 915       if (nchars - 1 > nchars_max)
 916         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
 917            separate the %d from the 'C'.  'ISO' should not be
 918            translated, but it may be moved after 'C%d' in languages
 919            where modifiers follow nouns.  */
 920         pedwarn ("string length %qd is greater than the length %qd "
 921                  "ISO C%d compilers are required to support",
 922                  nchars - 1, nchars_max, relevant_std);
 923     }
 924
 925   /* Create the array type for the string constant.  The ISO C++
 926      standard says that a string literal has type `const char[N]' or
 927      `const wchar_t[N]'.  We use the same logic when invoked as a C
 928      front-end with -Wwrite-strings.
 929      ??? We should change the type of an expression depending on the
 930      state of a warning flag.  We should just be warning -- see how
 931      this is handled in the C++ front-end for the deprecated implicit
 932      conversion from string literals to `char*' or `wchar_t*'.
 933
 934      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
 935      array type being the unqualified version of that type.
 936      Therefore, if we are constructing an array of const char, we must
 937      construct the matching unqualified array type first.  The C front
 938      end does not require this, but it does no harm, so we do it
 939      unconditionally.  */
 940   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
 941   a_type = build_array_type (e_type, i_type);
 942   if (c_dialect_cxx() || warn_write_strings)
 943     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
 944
 945   TREE_TYPE (value) = a_type;
 946   TREE_CONSTANT (value) = 1;
 947   TREE_INVARIANT (value) = 1;
 948   TREE_READONLY (value) = 1;
 949   TREE_STATIC (value) = 1;
 950   return value;
 951 }
 952 \f
 953 /* Print a warning if a constant expression had overflow in folding.
 954    Invoke this function on every expression that the language
 955    requires to be a constant expression.
 956    Note the ANSI C standard says it is erroneous for a
 957    constant expression to overflow.  */
 958
 959 void
 960 constant_expression_warning (tree value)
 961 {
 962   if (warn_overflow && pedantic
 963       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
 964           || TREE_CODE (value) == FIXED_CST
 965           || TREE_CODE (value) == VECTOR_CST
 966           || TREE_CODE (value) == COMPLEX_CST)
 967       && TREE_OVERFLOW (value))
 968     pedwarn ("overflow in constant expression");
 969 }
 970
 971 /* The same as above but print an unconditional error.  */
 972 void
 973 constant_expression_error (tree value)
 974 {
 975   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
 976        || TREE_CODE (value) == FIXED_CST
 977        || TREE_CODE (value) == VECTOR_CST
 978        || TREE_CODE (value) == COMPLEX_CST)
 979       && TREE_OVERFLOW (value))
 980     error ("overflow in constant expression");
 981 }
 982
 983 /* Print a warning if an expression had overflow in folding and its
 984    operands hadn't.
 985
 986    Invoke this function on every expression that
 987    (1) appears in the source code, and
 988    (2) is a constant expression that overflowed, and
 989    (3) is not already checked by convert_and_check;
 990    however, do not invoke this function on operands of explicit casts
 991    or when the expression is the result of an operator and any operand
 992    already overflowed.  */
 993
 994 void
 995 overflow_warning (tree value)
 996 {
 997   if (skip_evaluation) return;
 998
 999   switch (TREE_CODE (value))
1000     {
1001     case INTEGER_CST:
1002       warning (OPT_Woverflow, "integer overflow in expression");
1003       break;
1004
1005     case REAL_CST:
1006       warning (OPT_Woverflow, "floating point overflow in expression");
1007       break;
1008
1009     case FIXED_CST:
1010       warning (OPT_Woverflow, "fixed-point overflow in expression");
1011       break;
1012
1013     case VECTOR_CST:
1014       warning (OPT_Woverflow, "vector overflow in expression");
1015       break;
1016
1017     case COMPLEX_CST:
1018       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1019         warning (OPT_Woverflow, "complex integer overflow in expression");
1020       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1021         warning (OPT_Woverflow, "complex floating point overflow in expression");
1022       break;
1023
1024     default:
1025       break;
1026     }
1027 }
1028
1029
1030 /* Warn about use of a logical || / && operator being used in a
1031    context where it is likely that the bitwise equivalent was intended
1032    by the programmer. CODE is the TREE_CODE of the operator, ARG1
1033    and ARG2 the arguments.  */
1034
1035 void
1036 warn_logical_operator (enum tree_code code, tree arg1, tree
1037     arg2)
1038 {
1039   switch (code)
1040     {
1041       case TRUTH_ANDIF_EXPR:
1042       case TRUTH_ORIF_EXPR:
1043       case TRUTH_OR_EXPR:
1044       case TRUTH_AND_EXPR:
1045         if (!TREE_NO_WARNING (arg1)
1046             && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1047             && !CONSTANT_CLASS_P (arg1)
1048             && TREE_CODE (arg2) == INTEGER_CST
1049             && !integer_zerop (arg2))
1050           {
1051             warning (OPT_Wlogical_op,
1052                      "logical %<%s%> with non-zero constant "
1053                      "will always evaluate as true",
1054                      ((code == TRUTH_ANDIF_EXPR)
1055                       || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1056             TREE_NO_WARNING (arg1) = true;
1057           }
1058         break;
1059       default:
1060         break;
1061     }
1062 }
1063
1064
1065 /* Print a warning about casts that might indicate violation
1066    of strict aliasing rules if -Wstrict-aliasing is used and
1067    strict aliasing mode is in effect. OTYPE is the original
1068    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1069
1070 bool
1071 strict_aliasing_warning (tree otype, tree type, tree expr)
1072 {
1073   if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1074         && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1075     return false;
1076
1077   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1078       && (DECL_P (TREE_OPERAND (expr, 0))
1079           || handled_component_p (TREE_OPERAND (expr, 0))))
1080     {
1081       /* Casting the address of an object to non void pointer. Warn
1082          if the cast breaks type based aliasing.  */
1083       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1084         {
1085           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1086                    "might break strict-aliasing rules");
1087           return true;
1088         }
1089       else
1090         {
1091           /* warn_strict_aliasing >= 3.   This includes the default (3).
1092              Only warn if the cast is dereferenced immediately.  */
1093           alias_set_type set1 =
1094             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1095           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1096
1097           if (!alias_sets_conflict_p (set1, set2))
1098             {
1099               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1100                        "pointer will break strict-aliasing rules");
1101               return true;
1102             }
1103           else if (warn_strict_aliasing == 2
1104                    && !alias_sets_must_conflict_p (set1, set2))
1105             {
1106               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1107                        "pointer might break strict-aliasing rules");
1108               return true;
1109             }
1110         }
1111     }
1112   else
1113     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1114       {
1115         /* At this level, warn for any conversions, even if an address is
1116            not taken in the same statement.  This will likely produce many
1117            false positives, but could be useful to pinpoint problems that
1118            are not revealed at higher levels.  */
1119         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1120         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1121         if (!COMPLETE_TYPE_P (type)
1122             || !alias_sets_must_conflict_p (set1, set2))
1123           {
1124             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1125                      "pointer might break strict-aliasing rules");
1126             return true;
1127           }
1128       }
1129
1130   return false;
1131 }
1132
1133 /* Print a warning about if (); or if () .. else; constructs
1134    via the special empty statement node that we create.  INNER_THEN
1135    and INNER_ELSE are the statement lists of the if and the else
1136    block.  */
1137
1138 void
1139 empty_if_body_warning (tree inner_then, tree inner_else)
1140 {
1141   if (TREE_CODE (inner_then) == STATEMENT_LIST
1142       && STATEMENT_LIST_TAIL (inner_then))
1143     inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1144
1145   if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1146       && STATEMENT_LIST_TAIL (inner_else))
1147     inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1148
1149   if (IS_EMPTY_STMT (inner_then) && !inner_else)
1150     warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1151              "in an %<if%> statement", EXPR_LOCUS (inner_then));
1152
1153   else if (inner_else && IS_EMPTY_STMT (inner_else))
1154     warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1155              "in an %<else%> statement", EXPR_LOCUS (inner_else));
1156 }
1157
1158 /* Warn for unlikely, improbable, or stupid DECL declarations
1159    of `main'.  */
1160
1161 void
1162 check_main_parameter_types (tree decl)
1163 {
1164   tree args;
1165   int argct = 0;
1166
1167   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1168       args = TREE_CHAIN (args))
1169    {
1170      tree type = args ? TREE_VALUE (args) : 0;
1171
1172      if (type == void_type_node || type == error_mark_node )
1173        break;
1174
1175      ++argct;
1176      switch (argct)
1177        {
1178        case 1:
1179          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1180            pedwarn ("first argument of %q+D should be %<int%>", decl);
1181          break;
1182
1183        case 2:
1184          if (TREE_CODE (type) != POINTER_TYPE
1185              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1186              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1187                  != char_type_node))
1188            pedwarn ("second argument of %q+D should be %<char **%>",
1189                     decl);
1190          break;
1191
1192        case 3:
1193          if (TREE_CODE (type) != POINTER_TYPE
1194              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1195              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1196                  != char_type_node))
1197            pedwarn ("third argument of %q+D should probably be "
1198                     "%<char **%>", decl);
1199          break;
1200        }
1201    }
1202
1203   /* It is intentional that this message does not mention the third
1204     argument because it's only mentioned in an appendix of the
1205     standard.  */
1206   if (argct > 0 && (argct < 2 || argct > 3))
1207    pedwarn ("%q+D takes only zero or two arguments", decl);
1208 }
1209
1210 /* True if vector types T1 and T2 can be converted to each other
1211    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1212    can only be converted with -flax-vector-conversions yet that is not
1213    in effect, emit a note telling the user about that option if such
1214    a note has not previously been emitted.  */
1215 bool
1216 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1217 {
1218   static bool emitted_lax_note = false;
1219   bool convertible_lax;
1220
1221   if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1222       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1223     return true;
1224
1225   convertible_lax =
1226     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1227      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1228          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1229      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1230          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1231
1232   if (!convertible_lax || flag_lax_vector_conversions)
1233     return convertible_lax;
1234
1235   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1236       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1237     return true;
1238
1239   if (emit_lax_note && !emitted_lax_note)
1240     {
1241       emitted_lax_note = true;
1242       inform ("use -flax-vector-conversions to permit "
1243               "conversions between vectors with differing "
1244               "element types or numbers of subparts");
1245     }
1246
1247   return false;
1248 }
1249
1250 /* Warns if the conversion of EXPR to TYPE may alter a value.
1251    This is a helper function for warnings_for_convert_and_check.  */
1252
1253 static void
1254 conversion_warning (tree type, tree expr)
1255 {
1256   bool give_warning = false;
1257
1258   unsigned int formal_prec = TYPE_PRECISION (type);
1259
1260   if (!warn_conversion && !warn_sign_conversion)
1261     return;
1262
1263   if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1264     {
1265       /* Warn for real constant that is not an exact integer converted
1266          to integer type.  */
1267       if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1268           && TREE_CODE (type) == INTEGER_TYPE)
1269         {
1270           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1271             give_warning = true;
1272         }
1273       /* Warn for an integer constant that does not fit into integer type.  */
1274       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1275                && TREE_CODE (type) == INTEGER_TYPE
1276                && !int_fits_type_p (expr, type))
1277         {
1278           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1279             warning (OPT_Wsign_conversion,
1280                      "negative integer implicitly converted to unsigned type");
1281           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (TREE_TYPE (expr)))
1282             warning (OPT_Wsign_conversion,
1283                      "conversion of unsigned constant value to negative integer");
1284           else
1285             give_warning = true;
1286         }
1287       else if (TREE_CODE (type) == REAL_TYPE)
1288         {
1289           /* Warn for an integer constant that does not fit into real type.  */
1290           if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1291             {
1292               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1293               if (!exact_real_truncate (TYPE_MODE (type), &a))
1294                 give_warning = true;
1295             }
1296           /* Warn for a real constant that does not fit into a smaller
1297              real type.  */
1298           else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1299                    && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1300             {
1301               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1302               if (!exact_real_truncate (TYPE_MODE (type), &a))
1303                 give_warning = true;
1304             }
1305         }
1306
1307       if (give_warning)
1308         warning (OPT_Wconversion,
1309                  "conversion to %qT alters %qT constant value",
1310                  type, TREE_TYPE (expr));
1311     }
1312   else /* 'expr' is not a constant.  */
1313     {
1314       /* Warn for real types converted to integer types.  */
1315       if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1316           && TREE_CODE (type) == INTEGER_TYPE)
1317         give_warning = true;
1318
1319       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1320                && TREE_CODE (type) == INTEGER_TYPE)
1321         {
1322           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
1323           expr = get_unwidened (expr, 0);
1324
1325           /* Warn for integer types converted to smaller integer types.  */
1326           if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1327             give_warning = true;
1328
1329           /* When they are the same width but different signedness,
1330              then the value may change.  */
1331           else if ((formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1332                     && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1333                    /* Even when converted to a bigger type, if the type is
1334                       unsigned but expr is signed, then negative values
1335                       will be changed.  */
1336                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1337             warning (OPT_Wsign_conversion,
1338                      "conversion to %qT from %qT may change the sign of the result",
1339                      type, TREE_TYPE (expr));
1340         }
1341
1342       /* Warn for integer types converted to real types if and only if
1343          all the range of values of the integer type cannot be
1344          represented by the real type.  */
1345       else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1346                && TREE_CODE (type) == REAL_TYPE)
1347         {
1348           tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1349           tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1350           REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1351           REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1352
1353           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1354               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1355             give_warning = true;
1356         }
1357
1358       /* Warn for real types converted to smaller real types.  */
1359       else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1360                && TREE_CODE (type) == REAL_TYPE
1361                && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1362         give_warning = true;
1363
1364
1365       if (give_warning)
1366         warning (OPT_Wconversion,
1367                  "conversion to %qT from %qT may alter its value",
1368                  type, TREE_TYPE (expr));
1369     }
1370 }
1371
1372 /* Produce warnings after a conversion. RESULT is the result of
1373    converting EXPR to TYPE.  This is a helper function for
1374    convert_and_check and cp_convert_and_check.  */
1375
1376 void
1377 warnings_for_convert_and_check (tree type, tree expr, tree result)
1378 {
1379   if (TREE_CODE (expr) == INTEGER_CST
1380       && (TREE_CODE (type) == INTEGER_TYPE
1381           || TREE_CODE (type) == ENUMERAL_TYPE)
1382       && !int_fits_type_p (expr, type))
1383     {
1384       /* Do not diagnose overflow in a constant expression merely
1385          because a conversion overflowed.  */
1386       if (TREE_OVERFLOW (result))
1387         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1388
1389       if (TYPE_UNSIGNED (type))
1390         {
1391           /* This detects cases like converting -129 or 256 to
1392              unsigned char.  */
1393           if (!int_fits_type_p (expr, c_common_signed_type (type)))
1394             warning (OPT_Woverflow,
1395                      "large integer implicitly truncated to unsigned type");
1396           else
1397             conversion_warning (type, expr);
1398         }
1399       else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1400         warning (OPT_Woverflow,
1401                  "overflow in implicit constant conversion");
1402       /* No warning for converting 0x80000000 to int.  */
1403       else if (pedantic
1404                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1405                    || TYPE_PRECISION (TREE_TYPE (expr))
1406                    != TYPE_PRECISION (type)))
1407         warning (OPT_Woverflow,
1408                  "overflow in implicit constant conversion");
1409
1410       else
1411         conversion_warning (type, expr);
1412     }
1413   else if ((TREE_CODE (result) == INTEGER_CST
1414             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1415     warning (OPT_Woverflow,
1416              "overflow in implicit constant conversion");
1417   else
1418     conversion_warning (type, expr);
1419 }
1420
1421
1422 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1423    Invoke this function on every expression that is converted implicitly,
1424    i.e. because of language rules and not because of an explicit cast.  */
1425
1426 tree
1427 convert_and_check (tree type, tree expr)
1428 {
1429   tree result;
1430
1431   if (TREE_TYPE (expr) == type)
1432     return expr;
1433
1434   result = convert (type, expr);
1435
1436   if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1437     warnings_for_convert_and_check (type, expr, result);
1438
1439   return result;
1440 }
1441 \f
1442 /* A node in a list that describes references to variables (EXPR), which are
1443    either read accesses if WRITER is zero, or write accesses, in which case
1444    WRITER is the parent of EXPR.  */
1445 struct tlist
1446 {
1447   struct tlist *next;
1448   tree expr, writer;
1449 };
1450
1451 /* Used to implement a cache the results of a call to verify_tree.  We only
1452    use this for SAVE_EXPRs.  */
1453 struct tlist_cache
1454 {
1455   struct tlist_cache *next;
1456   struct tlist *cache_before_sp;
1457   struct tlist *cache_after_sp;
1458   tree expr;
1459 };
1460
1461 /* Obstack to use when allocating tlist structures, and corresponding
1462    firstobj.  */
1463 static struct obstack tlist_obstack;
1464 static char *tlist_firstobj = 0;
1465
1466 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1467    warnings.  */
1468 static struct tlist *warned_ids;
1469 /* SAVE_EXPRs need special treatment.  We process them only once and then
1470    cache the results.  */
1471 static struct tlist_cache *save_expr_cache;
1472
1473 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1474 static void merge_tlist (struct tlist **, struct tlist *, int);
1475 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1476 static int warning_candidate_p (tree);
1477 static void warn_for_collisions (struct tlist *);
1478 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1479 static struct tlist *new_tlist (struct tlist *, tree, tree);
1480
1481 /* Create a new struct tlist and fill in its fields.  */
1482 static struct tlist *
1483 new_tlist (struct tlist *next, tree t, tree writer)
1484 {
1485   struct tlist *l;
1486   l = XOBNEW (&tlist_obstack, struct tlist);
1487   l->next = next;
1488   l->expr = t;
1489   l->writer = writer;
1490   return l;
1491 }
1492
1493 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1494    is nonnull, we ignore any node we find which has a writer equal to it.  */
1495
1496 static void
1497 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1498 {
1499   while (add)
1500     {
1501       struct tlist *next = add->next;
1502       if (!copy)
1503         add->next = *to;
1504       if (!exclude_writer || add->writer != exclude_writer)
1505         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1506       add = next;
1507     }
1508 }
1509
1510 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1511    each variable that already exists in TO, no new node is added; however if
1512    there is a write access recorded in ADD, and an occurrence on TO is only
1513    a read access, then the occurrence in TO will be modified to record the
1514    write.  */
1515
1516 static void
1517 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1518 {
1519   struct tlist **end = to;
1520
1521   while (*end)
1522     end = &(*end)->next;
1523
1524   while (add)
1525     {
1526       int found = 0;
1527       struct tlist *tmp2;
1528       struct tlist *next = add->next;
1529
1530       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1531         if (tmp2->expr == add->expr)
1532           {
1533             found = 1;
1534             if (!tmp2->writer)
1535               tmp2->writer = add->writer;
1536           }
1537       if (!found)
1538         {
1539           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1540           end = &(*end)->next;
1541           *end = 0;
1542         }
1543       add = next;
1544     }
1545 }
1546
1547 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1548    references in list LIST conflict with it, excluding reads if ONLY writers
1549    is nonzero.  */
1550
1551 static void
1552 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1553                        int only_writes)
1554 {
1555   struct tlist *tmp;
1556
1557   /* Avoid duplicate warnings.  */
1558   for (tmp = warned_ids; tmp; tmp = tmp->next)
1559     if (tmp->expr == written)
1560       return;
1561
1562   while (list)
1563     {
1564       if (list->expr == written
1565           && list->writer != writer
1566           && (!only_writes || list->writer)
1567           && DECL_NAME (list->expr))
1568         {
1569           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1570           warning (OPT_Wsequence_point, "operation on %qE may be undefined",
1571                    list->expr);
1572         }
1573       list = list->next;
1574     }
1575 }
1576
1577 /* Given a list LIST of references to variables, find whether any of these
1578    can cause conflicts due to missing sequence points.  */
1579
1580 static void
1581 warn_for_collisions (struct tlist *list)
1582 {
1583   struct tlist *tmp;
1584
1585   for (tmp = list; tmp; tmp = tmp->next)
1586     {
1587       if (tmp->writer)
1588         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1589     }
1590 }
1591
1592 /* Return nonzero if X is a tree that can be verified by the sequence point
1593    warnings.  */
1594 static int
1595 warning_candidate_p (tree x)
1596 {
1597   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1598 }
1599
1600 /* Walk the tree X, and record accesses to variables.  If X is written by the
1601    parent tree, WRITER is the parent.
1602    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1603    expression or its only operand forces a sequence point, then everything up
1604    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1605    in PNO_SP.
1606    Once we return, we will have emitted warnings if any subexpression before
1607    such a sequence point could be undefined.  On a higher level, however, the
1608    sequence point may not be relevant, and we'll merge the two lists.
1609
1610    Example: (b++, a) + b;
1611    The call that processes the COMPOUND_EXPR will store the increment of B
1612    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1613    processes the PLUS_EXPR will need to merge the two lists so that
1614    eventually, all accesses end up on the same list (and we'll warn about the
1615    unordered subexpressions b++ and b.
1616
1617    A note on merging.  If we modify the former example so that our expression
1618    becomes
1619      (b++, b) + a
1620    care must be taken not simply to add all three expressions into the final
1621    PNO_SP list.  The function merge_tlist takes care of that by merging the
1622    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1623    way, so that no more than one access to B is recorded.  */
1624
1625 static void
1626 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1627              tree writer)
1628 {
1629   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1630   enum tree_code code;
1631   enum tree_code_class cl;
1632
1633   /* X may be NULL if it is the operand of an empty statement expression
1634      ({ }).  */
1635   if (x == NULL)
1636     return;
1637
1638  restart:
1639   code = TREE_CODE (x);
1640   cl = TREE_CODE_CLASS (code);
1641
1642   if (warning_candidate_p (x))
1643     {
1644       *pno_sp = new_tlist (*pno_sp, x, writer);
1645       return;
1646     }
1647
1648   switch (code)
1649     {
1650     case CONSTRUCTOR:
1651       return;
1652
1653     case COMPOUND_EXPR:
1654     case TRUTH_ANDIF_EXPR:
1655     case TRUTH_ORIF_EXPR:
1656       tmp_before = tmp_nosp = tmp_list3 = 0;
1657       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1658       warn_for_collisions (tmp_nosp);
1659       merge_tlist (pbefore_sp, tmp_before, 0);
1660       merge_tlist (pbefore_sp, tmp_nosp, 0);
1661       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1662       merge_tlist (pbefore_sp, tmp_list3, 0);
1663       return;
1664
1665     case COND_EXPR:
1666       tmp_before = tmp_list2 = 0;
1667       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1668       warn_for_collisions (tmp_list2);
1669       merge_tlist (pbefore_sp, tmp_before, 0);
1670       merge_tlist (pbefore_sp, tmp_list2, 1);
1671
1672       tmp_list3 = tmp_nosp = 0;
1673       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1674       warn_for_collisions (tmp_nosp);
1675       merge_tlist (pbefore_sp, tmp_list3, 0);
1676
1677       tmp_list3 = tmp_list2 = 0;
1678       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1679       warn_for_collisions (tmp_list2);
1680       merge_tlist (pbefore_sp, tmp_list3, 0);
1681       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1682          two first, to avoid warning for (a ? b++ : b++).  */
1683       merge_tlist (&tmp_nosp, tmp_list2, 0);
1684       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1685       return;
1686
1687     case PREDECREMENT_EXPR:
1688     case PREINCREMENT_EXPR:
1689     case POSTDECREMENT_EXPR:
1690     case POSTINCREMENT_EXPR:
1691       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1692       return;
1693
1694     case MODIFY_EXPR:
1695       tmp_before = tmp_nosp = tmp_list3 = 0;
1696       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1697       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1698       /* Expressions inside the LHS are not ordered wrt. the sequence points
1699          in the RHS.  Example:
1700            *a = (a++, 2)
1701          Despite the fact that the modification of "a" is in the before_sp
1702          list (tmp_before), it conflicts with the use of "a" in the LHS.
1703          We can handle this by adding the contents of tmp_list3
1704          to those of tmp_before, and redoing the collision warnings for that
1705          list.  */
1706       add_tlist (&tmp_before, tmp_list3, x, 1);
1707       warn_for_collisions (tmp_before);
1708       /* Exclude the LHS itself here; we first have to merge it into the
1709          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1710          didn't exclude the LHS, we'd get it twice, once as a read and once
1711          as a write.  */
1712       add_tlist (pno_sp, tmp_list3, x, 0);
1713       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1714
1715       merge_tlist (pbefore_sp, tmp_before, 0);
1716       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1717         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1718       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1719       return;
1720
1721     case CALL_EXPR:
1722       /* We need to warn about conflicts among arguments and conflicts between
1723          args and the function address.  Side effects of the function address,
1724          however, are not ordered by the sequence point of the call.  */
1725       {
1726         call_expr_arg_iterator iter;
1727         tree arg;
1728         tmp_before = tmp_nosp = 0;
1729         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
1730         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
1731           {
1732             tmp_list2 = tmp_list3 = 0;
1733             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
1734             merge_tlist (&tmp_list3, tmp_list2, 0);
1735             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1736           }
1737         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1738         warn_for_collisions (tmp_before);
1739         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1740         return;
1741       }
1742
1743     case TREE_LIST:
1744       /* Scan all the list, e.g. indices of multi dimensional array.  */
1745       while (x)
1746         {
1747           tmp_before = tmp_nosp = 0;
1748           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1749           merge_tlist (&tmp_nosp, tmp_before, 0);
1750           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1751           x = TREE_CHAIN (x);
1752         }
1753       return;
1754
1755     case SAVE_EXPR:
1756       {
1757         struct tlist_cache *t;
1758         for (t = save_expr_cache; t; t = t->next)
1759           if (t->expr == x)
1760             break;
1761
1762         if (!t)
1763           {
1764             t = XOBNEW (&tlist_obstack, struct tlist_cache);
1765             t->next = save_expr_cache;
1766             t->expr = x;
1767             save_expr_cache = t;
1768
1769             tmp_before = tmp_nosp = 0;
1770             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1771             warn_for_collisions (tmp_nosp);
1772
1773             tmp_list3 = 0;
1774             while (tmp_nosp)
1775               {
1776                 struct tlist *t = tmp_nosp;
1777                 tmp_nosp = t->next;
1778                 merge_tlist (&tmp_list3, t, 0);
1779               }
1780             t->cache_before_sp = tmp_before;
1781             t->cache_after_sp = tmp_list3;
1782           }
1783         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1784         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1785         return;
1786       }
1787
1788     default:
1789       /* For other expressions, simply recurse on their operands.
1790          Manual tail recursion for unary expressions.
1791          Other non-expressions need not be processed.  */
1792       if (cl == tcc_unary)
1793         {
1794           x = TREE_OPERAND (x, 0);
1795           writer = 0;
1796           goto restart;
1797         }
1798       else if (IS_EXPR_CODE_CLASS (cl))
1799         {
1800           int lp;
1801           int max = TREE_OPERAND_LENGTH (x);
1802           for (lp = 0; lp < max; lp++)
1803             {
1804               tmp_before = tmp_nosp = 0;
1805               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1806               merge_tlist (&tmp_nosp, tmp_before, 0);
1807               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1808             }
1809         }
1810       return;
1811     }
1812 }
1813
1814 /* Try to warn for undefined behavior in EXPR due to missing sequence
1815    points.  */
1816
1817 void
1818 verify_sequence_points (tree expr)
1819 {
1820   struct tlist *before_sp = 0, *after_sp = 0;
1821
1822   warned_ids = 0;
1823   save_expr_cache = 0;
1824   if (tlist_firstobj == 0)
1825     {
1826       gcc_obstack_init (&tlist_obstack);
1827       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1828     }
1829
1830   verify_tree (expr, &before_sp, &after_sp, 0);
1831   warn_for_collisions (after_sp);
1832   obstack_free (&tlist_obstack, tlist_firstobj);
1833 }
1834 \f
1835 /* Validate the expression after `case' and apply default promotions.  */
1836
1837 static tree
1838 check_case_value (tree value)
1839 {
1840   if (value == NULL_TREE)
1841     return value;
1842
1843   /* ??? Can we ever get nops here for a valid case value?  We
1844      shouldn't for C.  */
1845   STRIP_TYPE_NOPS (value);
1846   /* In C++, the following is allowed:
1847
1848        const int i = 3;
1849        switch (...) { case i: ... }
1850
1851      So, we try to reduce the VALUE to a constant that way.  */
1852   if (c_dialect_cxx ())
1853     {
1854       value = decl_constant_value (value);
1855       STRIP_TYPE_NOPS (value);
1856       value = fold (value);
1857     }
1858
1859   if (TREE_CODE (value) == INTEGER_CST)
1860     /* Promote char or short to int.  */
1861     value = perform_integral_promotions (value);
1862   else if (value != error_mark_node)
1863     {
1864       error ("case label does not reduce to an integer constant");
1865       value = error_mark_node;
1866     }
1867
1868   constant_expression_warning (value);
1869
1870   return value;
1871 }
1872 \f
1873 /* See if the case values LOW and HIGH are in the range of the original
1874    type (i.e. before the default conversion to int) of the switch testing
1875    expression.
1876    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1877    the type before promoting it.  CASE_LOW_P is a pointer to the lower
1878    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1879    if the case is not a case range.
1880    The caller has to make sure that we are not called with NULL for
1881    CASE_LOW_P (i.e. the default case).
1882    Returns true if the case label is in range of ORIG_TYPE (saturated or
1883    untouched) or false if the label is out of range.  */
1884
1885 static bool
1886 check_case_bounds (tree type, tree orig_type,
1887                    tree *case_low_p, tree *case_high_p)
1888 {
1889   tree min_value, max_value;
1890   tree case_low = *case_low_p;
1891   tree case_high = case_high_p ? *case_high_p : case_low;
1892
1893   /* If there was a problem with the original type, do nothing.  */
1894   if (orig_type == error_mark_node)
1895     return true;
1896
1897   min_value = TYPE_MIN_VALUE (orig_type);
1898   max_value = TYPE_MAX_VALUE (orig_type);
1899
1900   /* Case label is less than minimum for type.  */
1901   if (tree_int_cst_compare (case_low, min_value) < 0
1902       && tree_int_cst_compare (case_high, min_value) < 0)
1903     {
1904       warning (0, "case label value is less than minimum value for type");
1905       return false;
1906     }
1907
1908   /* Case value is greater than maximum for type.  */
1909   if (tree_int_cst_compare (case_low, max_value) > 0
1910       && tree_int_cst_compare (case_high, max_value) > 0)
1911     {
1912       warning (0, "case label value exceeds maximum value for type");
1913       return false;
1914     }
1915
1916   /* Saturate lower case label value to minimum.  */
1917   if (tree_int_cst_compare (case_high, min_value) >= 0
1918       && tree_int_cst_compare (case_low, min_value) < 0)
1919     {
1920       warning (0, "lower value in case label range"
1921                " less than minimum value for type");
1922       case_low = min_value;
1923     }
1924
1925   /* Saturate upper case label value to maximum.  */
1926   if (tree_int_cst_compare (case_low, max_value) <= 0
1927       && tree_int_cst_compare (case_high, max_value) > 0)
1928     {
1929       warning (0, "upper value in case label range"
1930                " exceeds maximum value for type");
1931       case_high = max_value;
1932     }
1933
1934   if (*case_low_p != case_low)
1935     *case_low_p = convert (type, case_low);
1936   if (case_high_p && *case_high_p != case_high)
1937     *case_high_p = convert (type, case_high);
1938
1939   return true;
1940 }
1941 \f
1942 /* Return an integer type with BITS bits of precision,
1943    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1944
1945 tree
1946 c_common_type_for_size (unsigned int bits, int unsignedp)
1947 {
1948   if (bits == TYPE_PRECISION (integer_type_node))
1949     return unsignedp ? unsigned_type_node : integer_type_node;
1950
1951   if (bits == TYPE_PRECISION (signed_char_type_node))
1952     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1953
1954   if (bits == TYPE_PRECISION (short_integer_type_node))
1955     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1956
1957   if (bits == TYPE_PRECISION (long_integer_type_node))
1958     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1959
1960   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1961     return (unsignedp ? long_long_unsigned_type_node
1962             : long_long_integer_type_node);
1963
1964   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1965     return (unsignedp ? widest_unsigned_literal_type_node
1966             : widest_integer_literal_type_node);
1967
1968   if (bits <= TYPE_PRECISION (intQI_type_node))
1969     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1970
1971   if (bits <= TYPE_PRECISION (intHI_type_node))
1972     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1973
1974   if (bits <= TYPE_PRECISION (intSI_type_node))
1975     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1976
1977   if (bits <= TYPE_PRECISION (intDI_type_node))
1978     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1979
1980   return 0;
1981 }
1982
1983 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
1984    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
1985    and saturating if SATP is nonzero, otherwise not saturating.  */
1986
1987 tree
1988 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
1989                                     int unsignedp, int satp)
1990 {
1991   enum machine_mode mode;
1992   if (ibit == 0)
1993     mode = unsignedp ? UQQmode : QQmode;
1994   else
1995     mode = unsignedp ? UHAmode : HAmode;
1996
1997   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
1998     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
1999       break;
2000
2001   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2002     {
2003       sorry ("GCC cannot support operators with integer types and "
2004              "fixed-point types that have too many integral and "
2005              "fractional bits together");
2006       return 0;
2007     }
2008
2009   return c_common_type_for_mode (mode, satp);
2010 }
2011
2012 /* Used for communication between c_common_type_for_mode and
2013    c_register_builtin_type.  */
2014 static GTY(()) tree registered_builtin_types;
2015
2016 /* Return a data type that has machine mode MODE.
2017    If the mode is an integer,
2018    then UNSIGNEDP selects between signed and unsigned types.
2019    If the mode is a fixed-point mode,
2020    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2021
2022 tree
2023 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2024 {
2025   tree t;
2026
2027   if (mode == TYPE_MODE (integer_type_node))
2028     return unsignedp ? unsigned_type_node : integer_type_node;
2029
2030   if (mode == TYPE_MODE (signed_char_type_node))
2031     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2032
2033   if (mode == TYPE_MODE (short_integer_type_node))
2034     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2035
2036   if (mode == TYPE_MODE (long_integer_type_node))
2037     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2038
2039   if (mode == TYPE_MODE (long_long_integer_type_node))
2040     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2041
2042   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2043     return unsignedp ? widest_unsigned_literal_type_node
2044                      : widest_integer_literal_type_node;
2045
2046   if (mode == QImode)
2047     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2048
2049   if (mode == HImode)
2050     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2051
2052   if (mode == SImode)
2053     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2054
2055   if (mode == DImode)
2056     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2057
2058 #if HOST_BITS_PER_WIDE_INT >= 64
2059   if (mode == TYPE_MODE (intTI_type_node))
2060     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2061 #endif
2062
2063   if (mode == TYPE_MODE (float_type_node))
2064     return float_type_node;
2065
2066   if (mode == TYPE_MODE (double_type_node))
2067     return double_type_node;
2068
2069   if (mode == TYPE_MODE (long_double_type_node))
2070     return long_double_type_node;
2071
2072   if (mode == TYPE_MODE (void_type_node))
2073     return void_type_node;
2074
2075   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2076     return (unsignedp
2077             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2078             : make_signed_type (GET_MODE_PRECISION (mode)));
2079
2080   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2081     return (unsignedp
2082             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2083             : make_signed_type (GET_MODE_PRECISION (mode)));
2084
2085   if (COMPLEX_MODE_P (mode))
2086     {
2087       enum machine_mode inner_mode;
2088       tree inner_type;
2089
2090       if (mode == TYPE_MODE (complex_float_type_node))
2091         return complex_float_type_node;
2092       if (mode == TYPE_MODE (complex_double_type_node))
2093         return complex_double_type_node;
2094       if (mode == TYPE_MODE (complex_long_double_type_node))
2095         return complex_long_double_type_node;
2096
2097       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2098         return complex_integer_type_node;
2099
2100       inner_mode = GET_MODE_INNER (mode);
2101       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2102       if (inner_type != NULL_TREE)
2103         return build_complex_type (inner_type);
2104     }
2105   else if (VECTOR_MODE_P (mode))
2106     {
2107       enum machine_mode inner_mode = GET_MODE_INNER (mode);
2108       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2109       if (inner_type != NULL_TREE)
2110         return build_vector_type_for_mode (inner_type, mode);
2111     }
2112
2113   if (mode == TYPE_MODE (dfloat32_type_node))
2114     return dfloat32_type_node;
2115   if (mode == TYPE_MODE (dfloat64_type_node))
2116     return dfloat64_type_node;
2117   if (mode == TYPE_MODE (dfloat128_type_node))
2118     return dfloat128_type_node;
2119
2120   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2121     {
2122       if (mode == TYPE_MODE (short_fract_type_node))
2123         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2124       if (mode == TYPE_MODE (fract_type_node))
2125         return unsignedp ? sat_fract_type_node : fract_type_node;
2126       if (mode == TYPE_MODE (long_fract_type_node))
2127         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2128       if (mode == TYPE_MODE (long_long_fract_type_node))
2129         return unsignedp ? sat_long_long_fract_type_node
2130                          : long_long_fract_type_node;
2131
2132       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2133         return unsignedp ? sat_unsigned_short_fract_type_node
2134                          : unsigned_short_fract_type_node;
2135       if (mode == TYPE_MODE (unsigned_fract_type_node))
2136         return unsignedp ? sat_unsigned_fract_type_node
2137                          : unsigned_fract_type_node;
2138       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2139         return unsignedp ? sat_unsigned_long_fract_type_node
2140                          : unsigned_long_fract_type_node;
2141       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2142         return unsignedp ? sat_unsigned_long_long_fract_type_node
2143                          : unsigned_long_long_fract_type_node;
2144
2145       if (mode == TYPE_MODE (short_accum_type_node))
2146         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2147       if (mode == TYPE_MODE (accum_type_node))
2148         return unsignedp ? sat_accum_type_node : accum_type_node;
2149       if (mode == TYPE_MODE (long_accum_type_node))
2150         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2151       if (mode == TYPE_MODE (long_long_accum_type_node))
2152         return unsignedp ? sat_long_long_accum_type_node
2153                          : long_long_accum_type_node;
2154
2155       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2156         return unsignedp ? sat_unsigned_short_accum_type_node
2157                          : unsigned_short_accum_type_node;
2158       if (mode == TYPE_MODE (unsigned_accum_type_node))
2159         return unsignedp ? sat_unsigned_accum_type_node
2160                          : unsigned_accum_type_node;
2161       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2162         return unsignedp ? sat_unsigned_long_accum_type_node
2163                          : unsigned_long_accum_type_node;
2164       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2165         return unsignedp ? sat_unsigned_long_long_accum_type_node
2166                          : unsigned_long_long_accum_type_node;
2167
2168       if (mode == QQmode)
2169         return unsignedp ? sat_qq_type_node : qq_type_node;
2170       if (mode == HQmode)
2171         return unsignedp ? sat_hq_type_node : hq_type_node;
2172       if (mode == SQmode)
2173         return unsignedp ? sat_sq_type_node : sq_type_node;
2174       if (mode == DQmode)
2175         return unsignedp ? sat_dq_type_node : dq_type_node;
2176       if (mode == TQmode)
2177         return unsignedp ? sat_tq_type_node : tq_type_node;
2178
2179       if (mode == UQQmode)
2180         return unsignedp ? sat_uqq_type_node : uqq_type_node;
2181       if (mode == UHQmode)
2182         return unsignedp ? sat_uhq_type_node : uhq_type_node;
2183       if (mode == USQmode)
2184         return unsignedp ? sat_usq_type_node : usq_type_node;
2185       if (mode == UDQmode)
2186         return unsignedp ? sat_udq_type_node : udq_type_node;
2187       if (mode == UTQmode)
2188         return unsignedp ? sat_utq_type_node : utq_type_node;
2189
2190       if (mode == HAmode)
2191         return unsignedp ? sat_ha_type_node : ha_type_node;
2192       if (mode == SAmode)
2193         return unsignedp ? sat_sa_type_node : sa_type_node;
2194       if (mode == DAmode)
2195         return unsignedp ? sat_da_type_node : da_type_node;
2196       if (mode == TAmode)
2197         return unsignedp ? sat_ta_type_node : ta_type_node;
2198
2199       if (mode == UHAmode)
2200         return unsignedp ? sat_uha_type_node : uha_type_node;
2201       if (mode == USAmode)
2202         return unsignedp ? sat_usa_type_node : usa_type_node;
2203       if (mode == UDAmode)
2204         return unsignedp ? sat_uda_type_node : uda_type_node;
2205       if (mode == UTAmode)
2206         return unsignedp ? sat_uta_type_node : uta_type_node;
2207     }
2208
2209   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2210     if (TYPE_MODE (TREE_VALUE (t)) == mode)
2211       return TREE_VALUE (t);
2212
2213   return 0;
2214 }
2215
2216 tree
2217 c_common_unsigned_type (tree type)
2218 {
2219   return c_common_signed_or_unsigned_type (1, type);
2220 }
2221
2222 /* Return a signed type the same as TYPE in other respects.  */
2223
2224 tree
2225 c_common_signed_type (tree type)
2226 {
2227   return c_common_signed_or_unsigned_type (0, type);
2228 }
2229
2230 /* Return a type the same as TYPE except unsigned or
2231    signed according to UNSIGNEDP.  */
2232
2233 tree
2234 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2235 {
2236   tree type1;
2237
2238   /* This block of code emulates the behavior of the old
2239      c_common_unsigned_type. In particular, it returns
2240      long_unsigned_type_node if passed a long, even when a int would
2241      have the same size. This is necessary for warnings to work
2242      correctly in archs where sizeof(int) == sizeof(long) */
2243
2244   type1 = TYPE_MAIN_VARIANT (type);
2245   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2246     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2247   if (type1 == integer_type_node || type1 == unsigned_type_node)
2248     return unsignedp ? unsigned_type_node : integer_type_node;
2249   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2250     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2251   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2252     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2253   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2254     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2255   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2256     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2257 #if HOST_BITS_PER_WIDE_INT >= 64
2258   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2259     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2260 #endif
2261   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2262     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2263   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2264     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2265   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2266     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2267   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2268     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2269
2270 #define C_COMMON_FIXED_TYPES(SAT,NAME) \
2271   if (type1 == SAT ## short_ ## NAME ## _type_node \
2272       || type1 == SAT ## unsigned_short_ ## NAME ## _type_node) \
2273     return unsignedp ? SAT ## unsigned_short_ ## NAME ## _type_node \
2274                      : SAT ## short_ ## NAME ## _type_node; \
2275   if (type1 == SAT ## NAME ## _type_node \
2276       || type1 == SAT ## unsigned_ ## NAME ## _type_node) \
2277     return unsignedp ? SAT ## unsigned_ ## NAME ## _type_node \
2278                      : SAT ## NAME ## _type_node; \
2279   if (type1 == SAT ## long_ ## NAME ## _type_node \
2280       || type1 == SAT ## unsigned_long_ ## NAME ## _type_node) \
2281     return unsignedp ? SAT ## unsigned_long_ ## NAME ## _type_node \
2282                      : SAT ## long_ ## NAME ## _type_node; \
2283   if (type1 == SAT ## long_long_ ## NAME ## _type_node \
2284       || type1 == SAT ## unsigned_long_long_ ## NAME ## _type_node) \
2285     return unsignedp ? SAT ## unsigned_long_long_ ## NAME ## _type_node \
2286                      : SAT ## long_long_ ## NAME ## _type_node;
2287
2288 #define C_COMMON_FIXED_MODE_TYPES(SAT,NAME) \
2289   if (type1 == SAT ## NAME ## _type_node \
2290       || type1 == SAT ## u ## NAME ## _type_node) \
2291     return unsignedp ? SAT ## u ## NAME ## _type_node \
2292                      : SAT ## NAME ## _type_node;
2293
2294   C_COMMON_FIXED_TYPES (, fract);
2295   C_COMMON_FIXED_TYPES (sat_, fract);
2296   C_COMMON_FIXED_TYPES (, accum);
2297   C_COMMON_FIXED_TYPES (sat_, accum);
2298
2299   C_COMMON_FIXED_MODE_TYPES (, qq);
2300   C_COMMON_FIXED_MODE_TYPES (, hq);
2301   C_COMMON_FIXED_MODE_TYPES (, sq);
2302   C_COMMON_FIXED_MODE_TYPES (, dq);
2303   C_COMMON_FIXED_MODE_TYPES (, tq);
2304   C_COMMON_FIXED_MODE_TYPES (sat_, qq);
2305   C_COMMON_FIXED_MODE_TYPES (sat_, hq);
2306   C_COMMON_FIXED_MODE_TYPES (sat_, sq);
2307   C_COMMON_FIXED_MODE_TYPES (sat_, dq);
2308   C_COMMON_FIXED_MODE_TYPES (sat_, tq);
2309   C_COMMON_FIXED_MODE_TYPES (, ha);
2310   C_COMMON_FIXED_MODE_TYPES (, sa);
2311   C_COMMON_FIXED_MODE_TYPES (, da);
2312   C_COMMON_FIXED_MODE_TYPES (, ta);
2313   C_COMMON_FIXED_MODE_TYPES (sat_, ha);
2314   C_COMMON_FIXED_MODE_TYPES (sat_, sa);
2315   C_COMMON_FIXED_MODE_TYPES (sat_, da);
2316   C_COMMON_FIXED_MODE_TYPES (sat_, ta);
2317
2318   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2319      the precision; they have precision set to match their range, but
2320      may use a wider mode to match an ABI.  If we change modes, we may
2321      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
2322      the precision as well, so as to yield correct results for
2323      bit-field types.  C++ does not have these separate bit-field
2324      types, and producing a signed or unsigned variant of an
2325      ENUMERAL_TYPE may cause other problems as well.  */
2326
2327   if (!INTEGRAL_TYPE_P (type)
2328       || TYPE_UNSIGNED (type) == unsignedp)
2329     return type;
2330
2331 #define TYPE_OK(node)                                                       \
2332   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
2333    && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2334   if (TYPE_OK (signed_char_type_node))
2335     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2336   if (TYPE_OK (integer_type_node))
2337     return unsignedp ? unsigned_type_node : integer_type_node;
2338   if (TYPE_OK (short_integer_type_node))
2339     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2340   if (TYPE_OK (long_integer_type_node))
2341     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2342   if (TYPE_OK (long_long_integer_type_node))
2343     return (unsignedp ? long_long_unsigned_type_node
2344             : long_long_integer_type_node);
2345   if (TYPE_OK (widest_integer_literal_type_node))
2346     return (unsignedp ? widest_unsigned_literal_type_node
2347             : widest_integer_literal_type_node);
2348
2349 #if HOST_BITS_PER_WIDE_INT >= 64
2350   if (TYPE_OK (intTI_type_node))
2351     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2352 #endif
2353   if (TYPE_OK (intDI_type_node))
2354     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2355   if (TYPE_OK (intSI_type_node))
2356     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2357   if (TYPE_OK (intHI_type_node))
2358     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2359   if (TYPE_OK (intQI_type_node))
2360     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2361 #undef TYPE_OK
2362
2363   if (c_dialect_cxx ())
2364     return type;
2365   else
2366     return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2367 }
2368
2369 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
2370
2371 tree
2372 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2373 {
2374   /* Extended integer types of the same width as a standard type have
2375      lesser rank, so those of the same width as int promote to int or
2376      unsigned int and are valid for printf formats expecting int or
2377      unsigned int.  To avoid such special cases, avoid creating
2378      extended integer types for bit-fields if a standard integer type
2379      is available.  */
2380   if (width == TYPE_PRECISION (integer_type_node))
2381     return unsignedp ? unsigned_type_node : integer_type_node;
2382   if (width == TYPE_PRECISION (signed_char_type_node))
2383     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2384   if (width == TYPE_PRECISION (short_integer_type_node))
2385     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2386   if (width == TYPE_PRECISION (long_integer_type_node))
2387     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2388   if (width == TYPE_PRECISION (long_long_integer_type_node))
2389     return (unsignedp ? long_long_unsigned_type_node
2390             : long_long_integer_type_node);
2391   return build_nonstandard_integer_type (width, unsignedp);
2392 }
2393
2394 /* The C version of the register_builtin_type langhook.  */
2395
2396 void
2397 c_register_builtin_type (tree type, const char* name)
2398 {
2399   tree decl;
2400
2401   decl = build_decl (TYPE_DECL, get_identifier (name), type);
2402   DECL_ARTIFICIAL (decl) = 1;
2403   if (!TYPE_NAME (type))
2404     TYPE_NAME (type) = decl;
2405   pushdecl (decl);
2406
2407   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2408 }
2409
2410 \f
2411 /* Return the minimum number of bits needed to represent VALUE in a
2412    signed or unsigned type, UNSIGNEDP says which.  */
2413
2414 unsigned int
2415 min_precision (tree value, int unsignedp)
2416 {
2417   int log;
2418
2419   /* If the value is negative, compute its negative minus 1.  The latter
2420      adjustment is because the absolute value of the largest negative value
2421      is one larger than the largest positive value.  This is equivalent to
2422      a bit-wise negation, so use that operation instead.  */
2423
2424   if (tree_int_cst_sgn (value) < 0)
2425     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2426
2427   /* Return the number of bits needed, taking into account the fact
2428      that we need one more bit for a signed than unsigned type.  */
2429
2430   if (integer_zerop (value))
2431     log = 0;
2432   else
2433     log = tree_floor_log2 (value);
2434
2435   return log + 1 + !unsignedp;
2436 }
2437 \f
2438 /* Print an error message for invalid operands to arith operation
2439    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.  */
2440
2441 void
2442 binary_op_error (enum tree_code code, tree type0, tree type1)
2443 {
2444   const char *opname;
2445
2446   switch (code)
2447     {
2448     case PLUS_EXPR:
2449       opname = "+"; break;
2450     case MINUS_EXPR:
2451       opname = "-"; break;
2452     case MULT_EXPR:
2453       opname = "*"; break;
2454     case MAX_EXPR:
2455       opname = "max"; break;
2456     case MIN_EXPR:
2457       opname = "min"; break;
2458     case EQ_EXPR:
2459       opname = "=="; break;
2460     case NE_EXPR:
2461       opname = "!="; break;
2462     case LE_EXPR:
2463       opname = "<="; break;
2464     case GE_EXPR:
2465       opname = ">="; break;
2466     case LT_EXPR:
2467       opname = "<"; break;
2468     case GT_EXPR:
2469       opname = ">"; break;
2470     case LSHIFT_EXPR:
2471       opname = "<<"; break;
2472     case RSHIFT_EXPR:
2473       opname = ">>"; break;
2474     case TRUNC_MOD_EXPR:
2475     case FLOOR_MOD_EXPR:
2476       opname = "%"; break;
2477     case TRUNC_DIV_EXPR:
2478     case FLOOR_DIV_EXPR:
2479       opname = "/"; break;
2480     case BIT_AND_EXPR:
2481       opname = "&"; break;
2482     case BIT_IOR_EXPR:
2483       opname = "|"; break;
2484     case TRUTH_ANDIF_EXPR:
2485       opname = "&&"; break;
2486     case TRUTH_ORIF_EXPR:
2487       opname = "||"; break;
2488     case BIT_XOR_EXPR:
2489       opname = "^"; break;
2490     default:
2491       gcc_unreachable ();
2492     }
2493   error ("invalid operands to binary %s (have %qT and %qT)", opname,
2494          type0, type1);
2495 }
2496 \f
2497 /* Subroutine of build_binary_op, used for comparison operations.
2498    See if the operands have both been converted from subword integer types
2499    and, if so, perhaps change them both back to their original type.
2500    This function is also responsible for converting the two operands
2501    to the proper common type for comparison.
2502
2503    The arguments of this function are all pointers to local variables
2504    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2505    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2506
2507    If this function returns nonzero, it means that the comparison has
2508    a constant value.  What this function returns is an expression for
2509    that value.  */
2510
2511 tree
2512 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2513                  enum tree_code *rescode_ptr)
2514 {
2515   tree type;
2516   tree op0 = *op0_ptr;
2517   tree op1 = *op1_ptr;
2518   int unsignedp0, unsignedp1;
2519   int real1, real2;
2520   tree primop0, primop1;
2521   enum tree_code code = *rescode_ptr;
2522
2523   /* Throw away any conversions to wider types
2524      already present in the operands.  */
2525
2526   primop0 = get_narrower (op0, &unsignedp0);
2527   primop1 = get_narrower (op1, &unsignedp1);
2528
2529   /* Handle the case that OP0 does not *contain* a conversion
2530      but it *requires* conversion to FINAL_TYPE.  */
2531
2532   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2533     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2534   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2535     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2536
2537   /* If one of the operands must be floated, we cannot optimize.  */
2538   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2539   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2540
2541   /* If first arg is constant, swap the args (changing operation
2542      so value is preserved), for canonicalization.  Don't do this if
2543      the second arg is 0.  */
2544
2545   if (TREE_CONSTANT (primop0)
2546       && !integer_zerop (primop1) && !real_zerop (primop1)
2547       && !fixed_zerop (primop1))
2548     {
2549       tree tem = primop0;
2550       int temi = unsignedp0;
2551       primop0 = primop1;
2552       primop1 = tem;
2553       tem = op0;
2554       op0 = op1;
2555       op1 = tem;
2556       *op0_ptr = op0;
2557       *op1_ptr = op1;
2558       unsignedp0 = unsignedp1;
2559       unsignedp1 = temi;
2560       temi = real1;
2561       real1 = real2;
2562       real2 = temi;
2563
2564       switch (code)
2565         {
2566         case LT_EXPR:
2567           code = GT_EXPR;
2568           break;
2569         case GT_EXPR:
2570           code = LT_EXPR;
2571           break;
2572         case LE_EXPR:
2573           code = GE_EXPR;
2574           break;
2575         case GE_EXPR:
2576           code = LE_EXPR;
2577           break;
2578         default:
2579           break;
2580         }
2581       *rescode_ptr = code;
2582     }
2583
2584   /* If comparing an integer against a constant more bits wide,
2585      maybe we can deduce a value of 1 or 0 independent of the data.
2586      Or else truncate the constant now
2587      rather than extend the variable at run time.
2588
2589      This is only interesting if the constant is the wider arg.
2590      Also, it is not safe if the constant is unsigned and the
2591      variable arg is signed, since in this case the variable
2592      would be sign-extended and then regarded as unsigned.
2593      Our technique fails in this case because the lowest/highest
2594      possible unsigned results don't follow naturally from the
2595      lowest/highest possible values of the variable operand.
2596      For just EQ_EXPR and NE_EXPR there is another technique that
2597      could be used: see if the constant can be faithfully represented
2598      in the other operand's type, by truncating it and reextending it
2599      and see if that preserves the constant's value.  */
2600
2601   if (!real1 && !real2
2602       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2603       && TREE_CODE (primop1) == INTEGER_CST
2604       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2605     {
2606       int min_gt, max_gt, min_lt, max_lt;
2607       tree maxval, minval;
2608       /* 1 if comparison is nominally unsigned.  */
2609       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2610       tree val;
2611
2612       type = c_common_signed_or_unsigned_type (unsignedp0,
2613                                                TREE_TYPE (primop0));
2614
2615       maxval = TYPE_MAX_VALUE (type);
2616       minval = TYPE_MIN_VALUE (type);
2617
2618       if (unsignedp && !unsignedp0)
2619         *restype_ptr = c_common_signed_type (*restype_ptr);
2620
2621       if (TREE_TYPE (primop1) != *restype_ptr)
2622         {
2623           /* Convert primop1 to target type, but do not introduce
2624              additional overflow.  We know primop1 is an int_cst.  */
2625           primop1 = force_fit_type_double (*restype_ptr,
2626                                            TREE_INT_CST_LOW (primop1),
2627                                            TREE_INT_CST_HIGH (primop1), 0,
2628                                            TREE_OVERFLOW (primop1));
2629         }
2630       if (type != *restype_ptr)
2631         {
2632           minval = convert (*restype_ptr, minval);
2633           maxval = convert (*restype_ptr, maxval);
2634         }
2635
2636       if (unsignedp && unsignedp0)
2637         {
2638           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2639           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2640           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2641           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2642         }
2643       else
2644         {
2645           min_gt = INT_CST_LT (primop1, minval);
2646           max_gt = INT_CST_LT (primop1, maxval);
2647           min_lt = INT_CST_LT (minval, primop1);
2648           max_lt = INT_CST_LT (maxval, primop1);
2649         }
2650
2651       val = 0;
2652       /* This used to be a switch, but Genix compiler can't handle that.  */
2653       if (code == NE_EXPR)
2654         {
2655           if (max_lt || min_gt)
2656             val = truthvalue_true_node;
2657         }
2658       else if (code == EQ_EXPR)
2659         {
2660           if (max_lt || min_gt)
2661             val = truthvalue_false_node;
2662         }
2663       else if (code == LT_EXPR)
2664         {
2665           if (max_lt)
2666             val = truthvalue_true_node;
2667           if (!min_lt)
2668             val = truthvalue_false_node;
2669         }
2670       else if (code == GT_EXPR)
2671         {
2672           if (min_gt)
2673             val = truthvalue_true_node;
2674           if (!max_gt)
2675             val = truthvalue_false_node;
2676         }
2677       else if (code == LE_EXPR)
2678         {
2679           if (!max_gt)
2680             val = truthvalue_true_node;
2681           if (min_gt)
2682             val = truthvalue_false_node;
2683         }
2684       else if (code == GE_EXPR)
2685         {
2686           if (!min_lt)
2687             val = truthvalue_true_node;
2688           if (max_lt)
2689             val = truthvalue_false_node;
2690         }
2691
2692       /* If primop0 was sign-extended and unsigned comparison specd,
2693          we did a signed comparison above using the signed type bounds.
2694          But the comparison we output must be unsigned.
2695
2696          Also, for inequalities, VAL is no good; but if the signed
2697          comparison had *any* fixed result, it follows that the
2698          unsigned comparison just tests the sign in reverse
2699          (positive values are LE, negative ones GE).
2700          So we can generate an unsigned comparison
2701          against an extreme value of the signed type.  */
2702
2703       if (unsignedp && !unsignedp0)
2704         {
2705           if (val != 0)
2706             switch (code)
2707               {
2708               case LT_EXPR:
2709               case GE_EXPR:
2710                 primop1 = TYPE_MIN_VALUE (type);
2711                 val = 0;
2712                 break;
2713
2714               case LE_EXPR:
2715               case GT_EXPR:
2716                 primop1 = TYPE_MAX_VALUE (type);
2717                 val = 0;
2718                 break;
2719
2720               default:
2721                 break;
2722               }
2723           type = c_common_unsigned_type (type);
2724         }
2725
2726       if (TREE_CODE (primop0) != INTEGER_CST)
2727         {
2728           if (val == truthvalue_false_node)
2729             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
2730           if (val == truthvalue_true_node)
2731             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
2732         }
2733
2734       if (val != 0)
2735         {
2736           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2737           if (TREE_SIDE_EFFECTS (primop0))
2738             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2739           return val;
2740         }
2741
2742       /* Value is not predetermined, but do the comparison
2743          in the type of the operand that is not constant.
2744          TYPE is already properly set.  */
2745     }
2746
2747   /* If either arg is decimal float and the other is float, find the
2748      proper common type to use for comparison.  */
2749   else if (real1 && real2
2750            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2751                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2752     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2753
2754   else if (real1 && real2
2755            && (TYPE_PRECISION (TREE_TYPE (primop0))
2756                == TYPE_PRECISION (TREE_TYPE (primop1))))
2757     type = TREE_TYPE (primop0);
2758
2759   /* If args' natural types are both narrower than nominal type
2760      and both extend in the same manner, compare them
2761      in the type of the wider arg.
2762      Otherwise must actually extend both to the nominal
2763      common type lest different ways of extending
2764      alter the result.
2765      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2766
2767   else if (unsignedp0 == unsignedp1 && real1 == real2
2768            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2769            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2770     {
2771       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2772       type = c_common_signed_or_unsigned_type (unsignedp0
2773                                                || TYPE_UNSIGNED (*restype_ptr),
2774                                                type);
2775       /* Make sure shorter operand is extended the right way
2776          to match the longer operand.  */
2777       primop0
2778         = convert (c_common_signed_or_unsigned_type (unsignedp0,
2779                                                      TREE_TYPE (primop0)),
2780                    primop0);
2781       primop1
2782         = convert (c_common_signed_or_unsigned_type (unsignedp1,
2783                                                      TREE_TYPE (primop1)),
2784                    primop1);
2785     }
2786   else
2787     {
2788       /* Here we must do the comparison on the nominal type
2789          using the args exactly as we received them.  */
2790       type = *restype_ptr;
2791       primop0 = op0;
2792       primop1 = op1;
2793
2794       if (!real1 && !real2 && integer_zerop (primop1)
2795           && TYPE_UNSIGNED (*restype_ptr))
2796         {
2797           tree value = 0;
2798           switch (code)
2799             {
2800             case GE_EXPR:
2801               /* All unsigned values are >= 0, so we warn.  However,
2802                  if OP0 is a constant that is >= 0, the signedness of
2803                  the comparison isn't an issue, so suppress the
2804                  warning.  */
2805               if (warn_type_limits && !in_system_header
2806                   && !(TREE_CODE (primop0) == INTEGER_CST
2807                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2808                                                    primop0))))
2809                 warning (OPT_Wtype_limits,
2810                          "comparison of unsigned expression >= 0 is always true");
2811               value = truthvalue_true_node;
2812               break;
2813
2814             case LT_EXPR:
2815               if (warn_type_limits && !in_system_header
2816                   && !(TREE_CODE (primop0) == INTEGER_CST
2817                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2818                                                    primop0))))
2819                 warning (OPT_Wtype_limits,
2820                          "comparison of unsigned expression < 0 is always false");
2821               value = truthvalue_false_node;
2822               break;
2823
2824             default:
2825               break;
2826             }
2827
2828           if (value != 0)
2829             {
2830               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2831               if (TREE_SIDE_EFFECTS (primop0))
2832                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2833                                primop0, value);
2834               return value;
2835             }
2836         }
2837     }
2838
2839   *op0_ptr = convert (type, primop0);
2840   *op1_ptr = convert (type, primop1);
2841
2842   *restype_ptr = truthvalue_type_node;
2843
2844   return 0;
2845 }
2846 \f
2847 /* Return a tree for the sum or difference (RESULTCODE says which)
2848    of pointer PTROP and integer INTOP.  */
2849
2850 tree
2851 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2852 {
2853   tree size_exp, ret;
2854
2855   /* The result is a pointer of the same type that is being added.  */
2856   tree result_type = TREE_TYPE (ptrop);
2857
2858   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2859     {
2860       if (pedantic || warn_pointer_arith)
2861         pedwarn ("pointer of type %<void *%> used in arithmetic");
2862       size_exp = integer_one_node;
2863     }
2864   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2865     {
2866       if (pedantic || warn_pointer_arith)
2867         pedwarn ("pointer to a function used in arithmetic");
2868       size_exp = integer_one_node;
2869     }
2870   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2871     {
2872       if (pedantic || warn_pointer_arith)
2873         pedwarn ("pointer to member function used in arithmetic");
2874       size_exp = integer_one_node;
2875     }
2876   else
2877     size_exp = size_in_bytes (TREE_TYPE (result_type));
2878
2879   /* We are manipulating pointer values, so we don't need to warn
2880      about relying on undefined signed overflow.  We disable the
2881      warning here because we use integer types so fold won't know that
2882      they are really pointers.  */
2883   fold_defer_overflow_warnings ();
2884
2885   /* If what we are about to multiply by the size of the elements
2886      contains a constant term, apply distributive law
2887      and multiply that constant term separately.
2888      This helps produce common subexpressions.  */
2889   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2890       && !TREE_CONSTANT (intop)
2891       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2892       && TREE_CONSTANT (size_exp)
2893       /* If the constant comes from pointer subtraction,
2894          skip this optimization--it would cause an error.  */
2895       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2896       /* If the constant is unsigned, and smaller than the pointer size,
2897          then we must skip this optimization.  This is because it could cause
2898          an overflow error if the constant is negative but INTOP is not.  */
2899       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2900           || (TYPE_PRECISION (TREE_TYPE (intop))
2901               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2902     {
2903       enum tree_code subcode = resultcode;
2904       tree int_type = TREE_TYPE (intop);
2905       if (TREE_CODE (intop) == MINUS_EXPR)
2906         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2907       /* Convert both subexpression types to the type of intop,
2908          because weird cases involving pointer arithmetic
2909          can result in a sum or difference with different type args.  */
2910       ptrop = build_binary_op (subcode, ptrop,
2911                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2912       intop = convert (int_type, TREE_OPERAND (intop, 0));
2913     }
2914
2915   /* Convert the integer argument to a type the same size as sizetype
2916      so the multiply won't overflow spuriously.  */
2917   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2918       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2919     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2920                                              TYPE_UNSIGNED (sizetype)), intop);
2921
2922   /* Replace the integer argument with a suitable product by the object size.
2923      Do this multiplication as signed, then convert to the appropriate
2924      type for the pointer operation.  */
2925   intop = convert (sizetype,
2926                    build_binary_op (MULT_EXPR, intop,
2927                                     convert (TREE_TYPE (intop), size_exp), 1));
2928
2929   /* Create the sum or difference.  */
2930   if (resultcode == MINUS_EXPR)
2931     intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
2932
2933   ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
2934
2935   fold_undefer_and_ignore_overflow_warnings ();
2936
2937   return ret;
2938 }
2939 \f
2940 /* Return whether EXPR is a declaration whose address can never be
2941    NULL.  */
2942
2943 bool
2944 decl_with_nonnull_addr_p (const_tree expr)
2945 {
2946   return (DECL_P (expr)
2947           && (TREE_CODE (expr) == PARM_DECL
2948               || TREE_CODE (expr) == LABEL_DECL
2949               || !DECL_WEAK (expr)));
2950 }
2951
2952 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2953    or for an `if' or `while' statement or ?..: exp.  It should already
2954    have been validated to be of suitable type; otherwise, a bad
2955    diagnostic may result.
2956
2957    This preparation consists of taking the ordinary
2958    representation of an expression expr and producing a valid tree
2959    boolean expression describing whether expr is nonzero.  We could
2960    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2961    but we optimize comparisons, &&, ||, and !.
2962
2963    The resulting type should always be `truthvalue_type_node'.  */
2964
2965 tree
2966 c_common_truthvalue_conversion (tree expr)
2967 {
2968   switch (TREE_CODE (expr))
2969     {
2970     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
2971     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
2972     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2973     case ORDERED_EXPR: case UNORDERED_EXPR:
2974       if (TREE_TYPE (expr) == truthvalue_type_node)
2975         return expr;
2976       return build2 (TREE_CODE (expr), truthvalue_type_node,
2977                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2978
2979     case TRUTH_ANDIF_EXPR:
2980     case TRUTH_ORIF_EXPR:
2981     case TRUTH_AND_EXPR:
2982     case TRUTH_OR_EXPR:
2983     case TRUTH_XOR_EXPR:
2984       if (TREE_TYPE (expr) == truthvalue_type_node)
2985         return expr;
2986       return build2 (TREE_CODE (expr), truthvalue_type_node,
2987                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2988                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2989
2990     case TRUTH_NOT_EXPR:
2991       if (TREE_TYPE (expr) == truthvalue_type_node)
2992         return expr;
2993       return build1 (TREE_CODE (expr), truthvalue_type_node,
2994                  c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2995
2996     case ERROR_MARK:
2997       return expr;
2998
2999     case INTEGER_CST:
3000       return integer_zerop (expr) ? truthvalue_false_node
3001                                   : truthvalue_true_node;
3002
3003     case REAL_CST:
3004       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3005              ? truthvalue_true_node
3006              : truthvalue_false_node;
3007
3008     case FIXED_CST:
3009       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3010                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3011              ? truthvalue_true_node
3012              : truthvalue_false_node;
3013
3014     case FUNCTION_DECL:
3015       expr = build_unary_op (ADDR_EXPR, expr, 0);
3016       /* Fall through.  */
3017
3018     case ADDR_EXPR:
3019       {
3020         tree inner = TREE_OPERAND (expr, 0);
3021         if (decl_with_nonnull_addr_p (inner))
3022           {
3023             /* Common Ada/Pascal programmer's mistake.  */
3024             warning (OPT_Waddress,
3025                      "the address of %qD will always evaluate as %<true%>",
3026                      inner);
3027             return truthvalue_true_node;
3028           }
3029
3030         /* If we still have a decl, it is possible for its address to
3031            be NULL, so we cannot optimize.  */
3032         if (DECL_P (inner))
3033           {
3034             gcc_assert (DECL_WEAK (inner));
3035             break;
3036           }
3037
3038         if (TREE_SIDE_EFFECTS (inner))
3039           return build2 (COMPOUND_EXPR, truthvalue_type_node,
3040                          inner, truthvalue_true_node);
3041         else
3042           return truthvalue_true_node;
3043       }
3044
3045     case COMPLEX_EXPR:
3046       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3047                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3048                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
3049                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
3050                               0);
3051
3052     case NEGATE_EXPR:
3053     case ABS_EXPR:
3054     case FLOAT_EXPR:
3055       /* These don't change whether an object is nonzero or zero.  */
3056       return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3057
3058     case LROTATE_EXPR:
3059     case RROTATE_EXPR:
3060       /* These don't change whether an object is zero or nonzero, but
3061          we can't ignore them if their second arg has side-effects.  */
3062       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3063         return build2 (COMPOUND_EXPR, truthvalue_type_node,
3064                        TREE_OPERAND (expr, 1),
3065                        c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
3066       else
3067         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3068
3069     case COND_EXPR:
3070       /* Distribute the conversion into the arms of a COND_EXPR.  */
3071       return fold_build3 (COND_EXPR, truthvalue_type_node,
3072                 TREE_OPERAND (expr, 0),
3073                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
3074                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
3075
3076     case CONVERT_EXPR:
3077     case NOP_EXPR:
3078       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3079          since that affects how `default_conversion' will behave.  */
3080       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3081           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3082         break;
3083       /* If this is widening the argument, we can ignore it.  */
3084       if (TYPE_PRECISION (TREE_TYPE (expr))
3085           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3086         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3087       break;
3088
3089     case MODIFY_EXPR:
3090       if (!TREE_NO_WARNING (expr)
3091           && warn_parentheses)
3092         {
3093           warning (OPT_Wparentheses,
3094                    "suggest parentheses around assignment used as truth value");
3095           TREE_NO_WARNING (expr) = 1;
3096         }
3097       break;
3098
3099     default:
3100       break;
3101     }
3102
3103   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3104     {
3105       tree t = save_expr (expr);
3106       return (build_binary_op
3107               ((TREE_SIDE_EFFECTS (expr)
3108                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3109         c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
3110         c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
3111                0));
3112     }
3113
3114   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3115     {
3116       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3117                                           FCONST0 (TYPE_MODE
3118                                                    (TREE_TYPE (expr))));
3119       return build_binary_op (NE_EXPR, expr, fixed_zero_node, 1);
3120     }
3121
3122   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3123 }
3124 \f
3125 static void def_builtin_1  (enum built_in_function fncode,
3126                             const char *name,
3127                             enum built_in_class fnclass,
3128                             tree fntype, tree libtype,
3129                             bool both_p, bool fallback_p, bool nonansi_p,
3130                             tree fnattrs, bool implicit_p);
3131
3132
3133 /* Apply the TYPE_QUALS to the new DECL.  */
3134
3135 void
3136 c_apply_type_quals_to_decl (int type_quals, tree decl)
3137 {
3138   tree type = TREE_TYPE (decl);
3139
3140   if (type == error_mark_node)
3141     return;
3142
3143   if (((type_quals & TYPE_QUAL_CONST)
3144        || (type && TREE_CODE (type) == REFERENCE_TYPE))
3145       /* An object declared 'const' is only readonly after it is
3146          initialized.  We don't have any way of expressing this currently,
3147          so we need to be conservative and unset TREE_READONLY for types
3148          with constructors.  Otherwise aliasing code will ignore stores in
3149          an inline constructor.  */
3150       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3151     TREE_READONLY (decl) = 1;
3152   if (type_quals & TYPE_QUAL_VOLATILE)
3153     {
3154       TREE_SIDE_EFFECTS (decl) = 1;
3155       TREE_THIS_VOLATILE (decl) = 1;
3156     }
3157   if (type_quals & TYPE_QUAL_RESTRICT)
3158     {
3159       while (type && TREE_CODE (type) == ARRAY_TYPE)
3160         /* Allow 'restrict' on arrays of pointers.
3161            FIXME currently we just ignore it.  */
3162         type = TREE_TYPE (type);
3163       if (!type
3164           || !POINTER_TYPE_P (type)
3165           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3166         error ("invalid use of %<restrict%>");
3167       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3168         /* Indicate we need to make a unique alias set for this pointer.
3169            We can't do it here because it might be pointing to an
3170            incomplete type.  */
3171         DECL_POINTER_ALIAS_SET (decl) = -2;
3172     }
3173 }
3174
3175 /* Hash function for the problem of multiple type definitions in
3176    different files.  This must hash all types that will compare
3177    equal via comptypes to the same value.  In practice it hashes
3178    on some of the simple stuff and leaves the details to comptypes.  */
3179
3180 static hashval_t
3181 c_type_hash (const void *p)
3182 {
3183   int i = 0;
3184   int shift, size;
3185   const_tree const t = (const_tree) p;
3186   tree t2;
3187   switch (TREE_CODE (t))
3188     {
3189     /* For pointers, hash on pointee type plus some swizzling.  */
3190     case POINTER_TYPE:
3191       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3192     /* Hash on number of elements and total size.  */
3193     case ENUMERAL_TYPE:
3194       shift = 3;
3195       t2 = TYPE_VALUES (t);
3196       break;
3197     case RECORD_TYPE:
3198       shift = 0;
3199       t2 = TYPE_FIELDS (t);
3200       break;
3201     case QUAL_UNION_TYPE:
3202       shift = 1;
3203       t2 = TYPE_FIELDS (t);
3204       break;
3205     case UNION_TYPE:
3206       shift = 2;
3207       t2 = TYPE_FIELDS (t);
3208       break;
3209     default:
3210       gcc_unreachable ();
3211     }
3212   for (; t2; t2 = TREE_CHAIN (t2))
3213     i++;
3214   /* We might have a VLA here.  */
3215   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3216     size = 0;
3217   else
3218     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3219   return ((size << 24) | (i << shift));
3220 }
3221
3222 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3223
3224 /* Return the typed-based alias set for T, which may be an expression
3225    or a type.  Return -1 if we don't do anything special.  */
3226
3227 alias_set_type
3228 c_common_get_alias_set (tree t)
3229 {
3230   tree u;
3231   PTR *slot;
3232
3233   /* Permit type-punning when accessing a union, provided the access
3234      is directly through the union.  For example, this code does not
3235      permit taking the address of a union member and then storing
3236      through it.  Even the type-punning allowed here is a GCC
3237      extension, albeit a common and useful one; the C standard says
3238      that such accesses have implementation-defined behavior.  */
3239   for (u = t;
3240        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3241        u = TREE_OPERAND (u, 0))
3242     if (TREE_CODE (u) == COMPONENT_REF
3243         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3244       return 0;
3245
3246   /* That's all the expressions we handle specially.  */
3247   if (!TYPE_P (t))
3248     return -1;
3249
3250   /* The C standard guarantees that any object may be accessed via an
3251      lvalue that has character type.  */
3252   if (t == char_type_node
3253       || t == signed_char_type_node
3254       || t == unsigned_char_type_node)
3255     return 0;
3256
3257   /* If it has the may_alias attribute, it can alias anything.  */
3258   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3259     return 0;
3260
3261   /* The C standard specifically allows aliasing between signed and
3262      unsigned variants of the same type.  We treat the signed
3263      variant as canonical.  */
3264   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3265     {
3266       tree t1 = c_common_signed_type (t);
3267
3268       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3269       if (t1 != t)
3270         return get_alias_set (t1);
3271     }
3272   else if (POINTER_TYPE_P (t))
3273     {
3274       tree t1;
3275
3276       /* Unfortunately, there is no canonical form of a pointer type.
3277          In particular, if we have `typedef int I', then `int *', and
3278          `I *' are different types.  So, we have to pick a canonical
3279          representative.  We do this below.
3280
3281          Technically, this approach is actually more conservative that
3282          it needs to be.  In particular, `const int *' and `int *'
3283          should be in different alias sets, according to the C and C++
3284          standard, since their types are not the same, and so,
3285          technically, an `int **' and `const int **' cannot point at
3286          the same thing.
3287
3288          But, the standard is wrong.  In particular, this code is
3289          legal C++:
3290
3291             int *ip;
3292             int **ipp = &ip;
3293             const int* const* cipp = ipp;
3294
3295          And, it doesn't make sense for that to be legal unless you
3296          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3297          the pointed-to types.  This issue has been reported to the
3298          C++ committee.  */
3299       t1 = build_type_no_quals (t);
3300       if (t1 != t)
3301         return get_alias_set (t1);
3302     }
3303
3304   /* Handle the case of multiple type nodes referring to "the same" type,
3305      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
3306      C90 is handled.  (In C99 type compatibility is not transitive, which
3307      complicates things mightily. The alias set splay trees can theoretically
3308      represent this, but insertion is tricky when you consider all the
3309      different orders things might arrive in.) */
3310
3311   if (c_language != clk_c || flag_isoc99)
3312     return -1;
3313
3314   /* Save time if there's only one input file.  */
3315   if (num_in_fnames == 1)
3316     return -1;
3317
3318   /* Pointers need special handling if they point to any type that
3319      needs special handling (below).  */
3320   if (TREE_CODE (t) == POINTER_TYPE)
3321     {
3322       tree t2;
3323       /* Find bottom type under any nested POINTERs.  */
3324       for (t2 = TREE_TYPE (t);
3325            TREE_CODE (t2) == POINTER_TYPE;
3326            t2 = TREE_TYPE (t2))
3327         ;
3328       if (TREE_CODE (t2) != RECORD_TYPE
3329           && TREE_CODE (t2) != ENUMERAL_TYPE
3330           && TREE_CODE (t2) != QUAL_UNION_TYPE
3331           && TREE_CODE (t2) != UNION_TYPE)
3332         return -1;
3333       if (TYPE_SIZE (t2) == 0)
3334         return -1;
3335     }
3336   /* These are the only cases that need special handling.  */
3337   if (TREE_CODE (t) != RECORD_TYPE
3338       && TREE_CODE (t) != ENUMERAL_TYPE
3339       && TREE_CODE (t) != QUAL_UNION_TYPE
3340       && TREE_CODE (t) != UNION_TYPE
3341       && TREE_CODE (t) != POINTER_TYPE)
3342     return -1;
3343   /* Undefined? */
3344   if (TYPE_SIZE (t) == 0)
3345     return -1;
3346
3347   /* Look up t in hash table.  Only one of the compatible types within each
3348      alias set is recorded in the table.  */
3349   if (!type_hash_table)
3350     type_hash_table = htab_create_ggc (1021, c_type_hash,
3351             (htab_eq) lang_hooks.types_compatible_p,
3352             NULL);
3353   slot = htab_find_slot (type_hash_table, t, INSERT);
3354   if (*slot != NULL)
3355     {
3356       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3357       return TYPE_ALIAS_SET ((tree)*slot);
3358     }
3359   else
3360     /* Our caller will assign and record (in t) a new alias set; all we need
3361        to do is remember t in the hash table.  */
3362     *slot = t;
3363
3364   return -1;
3365 }
3366 \f
3367 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3368    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
3369    flag controls whether we should diagnose possibly ill-formed
3370    constructs or not.  */
3371
3372 tree
3373 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3374 {
3375   const char *op_name;
3376   tree value = NULL;
3377   enum tree_code type_code = TREE_CODE (type);
3378
3379   op_name = is_sizeof ? "sizeof" : "__alignof__";
3380
3381   if (type_code == FUNCTION_TYPE)
3382     {
3383       if (is_sizeof)
3384         {
3385           if (complain && (pedantic || warn_pointer_arith))
3386             pedwarn ("invalid application of %<sizeof%> to a function type");
3387           else if (!complain)
3388             return error_mark_node;
3389           value = size_one_node;
3390         }
3391       else
3392         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3393     }
3394   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3395     {
3396       if (type_code == VOID_TYPE
3397           && complain && (pedantic || warn_pointer_arith))
3398         pedwarn ("invalid application of %qs to a void type", op_name);
3399       else if (!complain)
3400         return error_mark_node;
3401       value = size_one_node;
3402     }
3403   else if (!COMPLETE_TYPE_P (type))
3404     {
3405       if (complain)
3406         error ("invalid application of %qs to incomplete type %qT ",
3407                op_name, type);
3408       value = size_zero_node;
3409     }
3410   else
3411     {
3412       if (is_sizeof)
3413         /* Convert in case a char is more than one unit.  */
3414         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3415                             size_int (TYPE_PRECISION (char_type_node)
3416                                       / BITS_PER_UNIT));
3417       else
3418         value = size_int (TYPE_ALIGN_UNIT (type));
3419     }
3420
3421   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3422      TYPE_IS_SIZETYPE means that certain things (like overflow) will
3423      never happen.  However, this node should really have type
3424      `size_t', which is just a typedef for an ordinary integer type.  */
3425   value = fold_convert (size_type_node, value);
3426   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3427
3428   return value;
3429 }
3430
3431 /* Implement the __alignof keyword: Return the minimum required
3432    alignment of EXPR, measured in bytes.  For VAR_DECLs,
3433    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3434    from an "aligned" __attribute__ specification).  */
3435
3436 tree
3437 c_alignof_expr (tree expr)
3438 {
3439   tree t;
3440
3441   if (VAR_OR_FUNCTION_DECL_P (expr))
3442     t = size_int (DECL_ALIGN_UNIT (expr));
3443
3444   else if (TREE_CODE (expr) == COMPONENT_REF
3445            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3446     {
3447       error ("%<__alignof%> applied to a bit-field");
3448       t = size_one_node;
3449     }
3450   else if (TREE_CODE (expr) == COMPONENT_REF
3451            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3452     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3453
3454   else if (TREE_CODE (expr) == INDIRECT_REF)
3455     {
3456       tree t = TREE_OPERAND (expr, 0);
3457       tree best = t;
3458       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3459
3460       while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3461              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3462         {
3463           int thisalign;
3464
3465           t = TREE_OPERAND (t, 0);
3466           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3467           if (thisalign > bestalign)
3468             best = t, bestalign = thisalign;
3469         }
3470       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3471     }
3472   else
3473     return c_alignof (TREE_TYPE (expr));
3474
3475   return fold_convert (size_type_node, t);
3476 }
3477 \f
3478 /* Handle C and C++ default attributes.  */
3479
3480 enum built_in_attribute
3481 {
3482 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3483 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3484 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3485 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3486 #include "builtin-attrs.def"
3487 #undef DEF_ATTR_NULL_TREE
3488 #undef DEF_ATTR_INT
3489 #undef DEF_ATTR_IDENT
3490 #undef DEF_ATTR_TREE_LIST
3491   ATTR_LAST
3492 };
3493
3494 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3495
3496 static void c_init_attributes (void);
3497
3498 enum c_builtin_type