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