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