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, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 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 "tm_p.h"
  34 #include "obstack.h"
  35 #include "cpplib.h"
  36 #include "target.h"
  37 cpp_reader *parse_in;           /* Declared in c-lex.h.  */
  38
  39 #undef WCHAR_TYPE_SIZE
  40 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  41
  42 /* We let tm.h override the types used here, to handle trivial differences
  43    such as the choice of unsigned int or long unsigned int for size_t.
  44    When machines start needing nontrivial differences in the size type,
  45    it would be best to do something here to figure out automatically
  46    from other information what type to use.  */
  47
  48 #ifndef SIZE_TYPE
  49 #define SIZE_TYPE "long unsigned int"
  50 #endif
  51
  52 #ifndef WCHAR_TYPE
  53 #define WCHAR_TYPE "int"
  54 #endif
  55
  56 #ifndef PTRDIFF_TYPE
  57 #define PTRDIFF_TYPE "long int"
  58 #endif
  59
  60 #ifndef WINT_TYPE
  61 #define WINT_TYPE "unsigned int"
  62 #endif
  63
  64 #ifndef INTMAX_TYPE
  65 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  66                      ? "int"                                    \
  67                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  68                         ? "long int"                            \
  69                         : "long long int"))
  70 #endif
  71
  72 #ifndef UINTMAX_TYPE
  73 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  74                      ? "unsigned int"                           \
  75                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  76                         ? "long unsigned int"                   \
  77                         : "long long unsigned int"))
  78 #endif
  79
  80 /* The following symbols are subsumed in the c_global_trees array, and
  81    listed here individually for documentation purposes.
  82
  83    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  84
  85         tree short_integer_type_node;
  86         tree long_integer_type_node;
  87         tree long_long_integer_type_node;
  88
  89         tree short_unsigned_type_node;
  90         tree long_unsigned_type_node;
  91         tree long_long_unsigned_type_node;
  92
  93         tree boolean_type_node;
  94         tree boolean_false_node;
  95         tree boolean_true_node;
  96
  97         tree ptrdiff_type_node;
  98
  99         tree unsigned_char_type_node;
 100         tree signed_char_type_node;
 101         tree wchar_type_node;
 102         tree signed_wchar_type_node;
 103         tree unsigned_wchar_type_node;
 104
 105         tree float_type_node;
 106         tree double_type_node;
 107         tree long_double_type_node;
 108
 109         tree complex_integer_type_node;
 110         tree complex_float_type_node;
 111         tree complex_double_type_node;
 112         tree complex_long_double_type_node;
 113
 114         tree intQI_type_node;
 115         tree intHI_type_node;
 116         tree intSI_type_node;
 117         tree intDI_type_node;
 118         tree intTI_type_node;
 119
 120         tree unsigned_intQI_type_node;
 121         tree unsigned_intHI_type_node;
 122         tree unsigned_intSI_type_node;
 123         tree unsigned_intDI_type_node;
 124         tree unsigned_intTI_type_node;
 125
 126         tree widest_integer_literal_type_node;
 127         tree widest_unsigned_literal_type_node;
 128
 129    Nodes for types `void *' and `const void *'.
 130
 131         tree ptr_type_node, const_ptr_type_node;
 132
 133    Nodes for types `char *' and `const char *'.
 134
 135         tree string_type_node, const_string_type_node;
 136
 137    Type `char[SOMENUMBER]'.
 138    Used when an array of char is needed and the size is irrelevant.
 139
 140         tree char_array_type_node;
 141
 142    Type `int[SOMENUMBER]' or something like it.
 143    Used when an array of int needed and the size is irrelevant.
 144
 145         tree int_array_type_node;
 146
 147    Type `wchar_t[SOMENUMBER]' or something like it.
 148    Used when a wide string literal is created.
 149
 150         tree wchar_array_type_node;
 151
 152    Type `int ()' -- used for implicit declaration of functions.
 153
 154         tree default_function_type;
 155
 156    A VOID_TYPE node, packaged in a TREE_LIST.
 157
 158         tree void_list_node;
 159
 160   The lazily created VAR_DECLS for __FUNCTION__, __PRETTY_FUNCTION__,
 161   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 162   VAR_DECLS, but C++ does.)
 163
 164         tree function_name_decl_node;
 165         tree pretty_function_name_declnode;
 166         tree c99_function_name_decl_node;
 167
 168   Stack of nested function name VAR_DECLs.
 169
 170         tree saved_function_name_decls;
 171
 172 */
 173
 174 tree c_global_trees[CTI_MAX];
 175
 176 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 177
 178 int flag_no_builtin;
 179
 180 /* Nonzero means don't recognize the non-ANSI builtin functions.
 181    -ansi sets this.  */
 182
 183 int flag_no_nonansi_builtin;
 184
 185 /* Nonzero means give `double' the same size as `float'.  */
 186
 187 int flag_short_double;
 188
 189 /* Nonzero means give `wchar_t' the same size as `short'.  */
 190
 191 int flag_short_wchar;
 192
 193 /* Nonzero means warn about possible violations of sequence point rules.  */
 194
 195 int warn_sequence_point;
 196
 197 /* The elements of `ridpointers' are identifier nodes for the reserved
 198    type names and storage classes.  It is indexed by a RID_... value.  */
 199 tree *ridpointers;
 200
 201 tree (*make_fname_decl)                PARAMS ((tree, int));
 202
 203 /* If non-NULL, the address of a language-specific function that
 204    returns 1 for language-specific statement codes.  */
 205 int (*lang_statement_code_p)           PARAMS ((enum tree_code));
 206
 207 /* If non-NULL, the address of a language-specific function that takes
 208    any action required right before expand_function_end is called.  */
 209 void (*lang_expand_function_end)       PARAMS ((void));
 210
 211 /* If this variable is defined to a non-NULL value, it will be called
 212    after the file has been completely parsed.  */
 213 void (*back_end_hook) PARAMS ((tree));
 214
 215 /* Nonzero means the expression being parsed will never be evaluated.
 216    This is a count, since unevaluated expressions can nest.  */
 217 int skip_evaluation;
 218
 219 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
 220             A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
 221             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
 222             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS, A_MALLOC,
 223             A_NO_LIMIT_STACK, A_PURE};
 224
 225 /* Information about how a function name is generated. */
 226 struct fname_var_t
 227 {
 228   tree *decl;   /* pointer to the VAR_DECL. */
 229   unsigned rid; /* RID number for the identifier. */
 230   int pretty;   /* How pretty is it? */
 231 };
 232
 233 /* The three ways of getting then name of the current function. */
 234
 235 const struct fname_var_t fname_vars[] =
 236 {
 237   /* C99 compliant __func__, must be first. */
 238   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 239   /* GCC __FUNCTION__ compliant. */
 240   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 241   /* GCC __PRETTY_FUNCTION__ compliant. */
 242   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 243   {NULL, 0, 0},
 244 };
 245
 246 static void add_attribute               PARAMS ((enum attrs, const char *,
 247                                                  int, int, int));
 248 static void init_attributes             PARAMS ((void));
 249 static int default_valid_lang_attribute PARAMS ((tree, tree, tree, tree));
 250 static int constant_fits_type_p         PARAMS ((tree, tree));
 251
 252 /* Keep a stack of if statements.  We record the number of compound
 253    statements seen up to the if keyword, as well as the line number
 254    and file of the if.  If a potentially ambiguous else is seen, that
 255    fact is recorded; the warning is issued when we can be sure that
 256    the enclosing if statement does not have an else branch.  */
 257 typedef struct
 258 {
 259   int compstmt_count;
 260   int line;
 261   const char *file;
 262   int needs_warning;
 263   tree if_stmt;
 264 } if_elt;
 265
 266 static if_elt *if_stack;
 267
 268 /* Amount of space in the if statement stack.  */
 269 static int if_stack_space = 0;
 270
 271 /* Stack pointer.  */
 272 static int if_stack_pointer = 0;
 273
 274 /* Record the start of an if-then, and record the start of it
 275    for ambiguous else detection.  */
 276
 277 void
 278 c_expand_start_cond (cond, compstmt_count)
 279      tree cond;
 280      int compstmt_count;
 281 {
 282   tree if_stmt;
 283
 284   /* Make sure there is enough space on the stack.  */
 285   if (if_stack_space == 0)
 286     {
 287       if_stack_space = 10;
 288       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 289     }
 290   else if (if_stack_space == if_stack_pointer)
 291     {
 292       if_stack_space += 10;
 293       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 294     }
 295
 296   if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 297   IF_COND (if_stmt) = cond;
 298   add_stmt (if_stmt);
 299
 300   /* Record this if statement.  */
 301   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 302   if_stack[if_stack_pointer].file = input_filename;
 303   if_stack[if_stack_pointer].line = lineno;
 304   if_stack[if_stack_pointer].needs_warning = 0;
 305   if_stack[if_stack_pointer].if_stmt = if_stmt;
 306   if_stack_pointer++;
 307 }
 308
 309 /* Called after the then-clause for an if-statement is processed.  */
 310
 311 void
 312 c_finish_then ()
 313 {
 314   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 315   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 316 }
 317
 318 /* Record the end of an if-then.  Optionally warn if a nested
 319    if statement had an ambiguous else clause.  */
 320
 321 void
 322 c_expand_end_cond ()
 323 {
 324   if_stack_pointer--;
 325   if (if_stack[if_stack_pointer].needs_warning)
 326     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 327                                 if_stack[if_stack_pointer].line,
 328                                 "suggest explicit braces to avoid ambiguous `else'");
 329   last_expr_type = NULL_TREE;
 330 }
 331
 332 /* Called between the then-clause and the else-clause
 333    of an if-then-else.  */
 334
 335 void
 336 c_expand_start_else ()
 337 {
 338   /* An ambiguous else warning must be generated for the enclosing if
 339      statement, unless we see an else branch for that one, too.  */
 340   if (warn_parentheses
 341       && if_stack_pointer > 1
 342       && (if_stack[if_stack_pointer - 1].compstmt_count
 343           == if_stack[if_stack_pointer - 2].compstmt_count))
 344     if_stack[if_stack_pointer - 2].needs_warning = 1;
 345
 346   /* Even if a nested if statement had an else branch, it can't be
 347      ambiguous if this one also has an else.  So don't warn in that
 348      case.  Also don't warn for any if statements nested in this else.  */
 349   if_stack[if_stack_pointer - 1].needs_warning = 0;
 350   if_stack[if_stack_pointer - 1].compstmt_count--;
 351 }
 352
 353 /* Called after the else-clause for an if-statement is processed.  */
 354
 355 void
 356 c_finish_else ()
 357 {
 358   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 359   RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 360 }
 361
 362 /* Push current bindings for the function name VAR_DECLS. */
 363
 364 void
 365 start_fname_decls ()
 366 {
 367   unsigned ix;
 368   tree saved = NULL_TREE;
 369
 370   for (ix = 0; fname_vars[ix].decl; ix++)
 371     {
 372       tree decl = *fname_vars[ix].decl;
 373
 374       if (decl)
 375         {
 376           saved = tree_cons (decl, build_int_2 (ix, 0), saved);
 377           *fname_vars[ix].decl = NULL_TREE;
 378         }
 379     }
 380   if (saved || saved_function_name_decls)
 381     /* Normally they'll have been NULL, so only push if we've got a
 382        stack, or they are non-NULL.  */
 383     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 384                                            saved_function_name_decls);
 385 }
 386
 387 /* Finish up the current bindings, adding them into the
 388    current function's statement tree. This is done by wrapping the
 389    function's body in a COMPOUND_STMT containing these decls too. This
 390    must be done _before_ finish_stmt_tree is called. If there is no
 391    current function, we must be at file scope and no statements are
 392    involved. Pop the previous bindings. */
 393
 394 void
 395 finish_fname_decls ()
 396 {
 397   unsigned ix;
 398   tree body = NULL_TREE;
 399   tree stack = saved_function_name_decls;
 400
 401   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 402     body = chainon (TREE_VALUE (stack), body);
 403
 404   if (body)
 405     {
 406       /* They were called into existance, so add to statement tree. */
 407       body = chainon (body,
 408                       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
 409       body = build_stmt (COMPOUND_STMT, body);
 410
 411       COMPOUND_STMT_NO_SCOPE (body) = 1;
 412       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
 413     }
 414
 415   for (ix = 0; fname_vars[ix].decl; ix++)
 416     *fname_vars[ix].decl = NULL_TREE;
 417
 418   if (stack)
 419     {
 420       /* We had saved values, restore them. */
 421       tree saved;
 422
 423       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 424         {
 425           tree decl = TREE_PURPOSE (saved);
 426           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 427
 428           *fname_vars[ix].decl = decl;
 429         }
 430       stack = TREE_CHAIN (stack);
 431     }
 432   saved_function_name_decls = stack;
 433 }
 434
 435 /* Return the text name of the current function, suitable prettified
 436    by PRETTY_P. */
 437
 438 const char *
 439 fname_as_string (pretty_p)
 440      int pretty_p;
 441 {
 442   const char *name = NULL;
 443
 444   if (pretty_p)
 445     name = (current_function_decl
 446             ? (*decl_printable_name) (current_function_decl, 2)
 447             : "top level");
 448   else if (current_function_decl && DECL_NAME (current_function_decl))
 449     name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 450   else
 451     name = "";
 452   return name;
 453 }
 454
 455 /* Return the text name of the current function, formatted as
 456    required by the supplied RID value.  */
 457
 458 const char *
 459 fname_string (rid)
 460      unsigned rid;
 461 {
 462   unsigned ix;
 463
 464   for (ix = 0; fname_vars[ix].decl; ix++)
 465     if (fname_vars[ix].rid == rid)
 466       break;
 467   return fname_as_string (fname_vars[ix].pretty);
 468 }
 469
 470 /* Return the VAR_DECL for a const char array naming the current
 471    function. If the VAR_DECL has not yet been created, create it
 472    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 473    ID is its name (unfortunately C and C++ hold the RID values of
 474    keywords in different places, so we can't derive RID from ID in
 475    this language independant code.  */
 476
 477 tree
 478 fname_decl (rid, id)
 479      unsigned rid;
 480      tree id;
 481 {
 482   unsigned ix;
 483   tree decl = NULL_TREE;
 484
 485   for (ix = 0; fname_vars[ix].decl; ix++)
 486     if (fname_vars[ix].rid == rid)
 487       break;
 488
 489   decl = *fname_vars[ix].decl;
 490   if (!decl)
 491     {
 492       tree saved_last_tree = last_tree;
 493
 494       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 495       if (last_tree != saved_last_tree)
 496         {
 497           /* We created some statement tree for the decl. This belongs
 498              at the start of the function, so remove it now and reinsert
 499              it after the function is complete. */
 500           tree stmts = TREE_CHAIN (saved_last_tree);
 501
 502           TREE_CHAIN (saved_last_tree) = NULL_TREE;
 503           last_tree = saved_last_tree;
 504           saved_function_name_decls = tree_cons (decl, stmts,
 505                                                  saved_function_name_decls);
 506         }
 507       *fname_vars[ix].decl = decl;
 508     }
 509   if (!ix && !current_function_decl)
 510     pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
 511
 512   return decl;
 513 }
 514
 515 /* Given a chain of STRING_CST nodes,
 516    concatenate them into one STRING_CST
 517    and give it a suitable array-of-chars data type.  */
 518
 519 tree
 520 combine_strings (strings)
 521      tree strings;
 522 {
 523   register tree value, t;
 524   register int length = 1;
 525   int wide_length = 0;
 526   int wide_flag = 0;
 527   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 528   int nchars;
 529   const int nchars_max = flag_isoc99 ? 4095 : 509;
 530
 531   if (TREE_CHAIN (strings))
 532     {
 533       /* More than one in the chain, so concatenate.  */
 534       register char *p, *q;
 535
 536       /* Don't include the \0 at the end of each substring,
 537          except for the last one.
 538          Count wide strings and ordinary strings separately.  */
 539       for (t = strings; t; t = TREE_CHAIN (t))
 540         {
 541           if (TREE_TYPE (t) == wchar_array_type_node)
 542             {
 543               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 544               wide_flag = 1;
 545             }
 546           else
 547             length += (TREE_STRING_LENGTH (t) - 1);
 548         }
 549
 550       /* If anything is wide, the non-wides will be converted,
 551          which makes them take more space.  */
 552       if (wide_flag)
 553         length = length * wchar_bytes + wide_length;
 554
 555       p = alloca (length);
 556
 557       /* Copy the individual strings into the new combined string.
 558          If the combined string is wide, convert the chars to ints
 559          for any individual strings that are not wide.  */
 560
 561       q = p;
 562       for (t = strings; t; t = TREE_CHAIN (t))
 563         {
 564           int len = (TREE_STRING_LENGTH (t)
 565                      - ((TREE_TYPE (t) == wchar_array_type_node)
 566                         ? wchar_bytes : 1));
 567           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 568             {
 569               memcpy (q, TREE_STRING_POINTER (t), len);
 570               q += len;
 571             }
 572           else
 573             {
 574               int i, j;
 575               for (i = 0; i < len; i++)
 576                 {
 577                   if (BYTES_BIG_ENDIAN)
 578                     {
 579                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 580                         *q++ = 0;
 581                       *q++ = TREE_STRING_POINTER (t)[i];
 582                     }
 583                   else
 584                     {
 585                       *q++ = TREE_STRING_POINTER (t)[i];
 586                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 587                         *q++ = 0;
 588                     }
 589                 }
 590             }
 591         }
 592       if (wide_flag)
 593         {
 594           int i;
 595           for (i = 0; i < wchar_bytes; i++)
 596             *q++ = 0;
 597         }
 598       else
 599         *q = 0;
 600
 601       value = build_string (length, p);
 602     }
 603   else
 604     {
 605       value = strings;
 606       length = TREE_STRING_LENGTH (value);
 607       if (TREE_TYPE (value) == wchar_array_type_node)
 608         wide_flag = 1;
 609     }
 610
 611   /* Compute the number of elements, for the array type.  */
 612   nchars = wide_flag ? length / wchar_bytes : length;
 613
 614   if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
 615     pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
 616              nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
 617
 618   /* Create the array type for the string constant.
 619      -Wwrite-strings says make the string constant an array of const char
 620      so that copying it to a non-const pointer will get a warning.
 621      For C++, this is the standard behavior.  */
 622   if (flag_const_strings
 623       && (! flag_traditional  && ! flag_writable_strings))
 624     {
 625       tree elements
 626         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 627                               1, 0);
 628       TREE_TYPE (value)
 629         = build_array_type (elements,
 630                             build_index_type (build_int_2 (nchars - 1, 0)));
 631     }
 632   else
 633     TREE_TYPE (value)
 634       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 635                           build_index_type (build_int_2 (nchars - 1, 0)));
 636
 637   TREE_CONSTANT (value) = 1;
 638   TREE_READONLY (value) = ! flag_writable_strings;
 639   TREE_STATIC (value) = 1;
 640   return value;
 641 }
 642 \f
 643 /* To speed up processing of attributes, we maintain an array of
 644    IDENTIFIER_NODES and the corresponding attribute types.  */
 645
 646 /* Array to hold attribute information.  */
 647
 648 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 649
 650 static int attrtab_idx = 0;
 651
 652 /* Add an entry to the attribute table above.  */
 653
 654 static void
 655 add_attribute (id, string, min_len, max_len, decl_req)
 656      enum attrs id;
 657      const char *string;
 658      int min_len, max_len;
 659      int decl_req;
 660 {
 661   char buf[100];
 662
 663   attrtab[attrtab_idx].id = id;
 664   attrtab[attrtab_idx].name = get_identifier (string);
 665   attrtab[attrtab_idx].min = min_len;
 666   attrtab[attrtab_idx].max = max_len;
 667   attrtab[attrtab_idx++].decl_req = decl_req;
 668
 669   sprintf (buf, "__%s__", string);
 670
 671   attrtab[attrtab_idx].id = id;
 672   attrtab[attrtab_idx].name = get_identifier (buf);
 673   attrtab[attrtab_idx].min = min_len;
 674   attrtab[attrtab_idx].max = max_len;
 675   attrtab[attrtab_idx++].decl_req = decl_req;
 676 }
 677
 678 /* Initialize attribute table.  */
 679
 680 static void
 681 init_attributes ()
 682 {
 683   add_attribute (A_PACKED, "packed", 0, 0, 0);
 684   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 685   add_attribute (A_COMMON, "common", 0, 0, 1);
 686   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 687   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 688   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 689   add_attribute (A_CONST, "const", 0, 0, 1);
 690   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 691   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 692   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 693   add_attribute (A_MODE, "mode", 1, 1, 1);
 694   add_attribute (A_SECTION, "section", 1, 1, 1);
 695   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 696   add_attribute (A_FORMAT, "format", 3, 3, 1);
 697   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 698   add_attribute (A_WEAK, "weak", 0, 0, 1);
 699   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 700   add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
 701   add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
 702   add_attribute (A_MALLOC, "malloc", 0, 0, 1);
 703   add_attribute (A_NO_LIMIT_STACK, "no_stack_limit", 0, 0, 1);
 704   add_attribute (A_PURE, "pure", 0, 0, 1);
 705 }
 706 \f
 707 /* Default implementation of valid_lang_attribute, below.  By default, there
 708    are no language-specific attributes.  */
 709
 710 static int
 711 default_valid_lang_attribute (attr_name, attr_args, decl, type)
 712   tree attr_name ATTRIBUTE_UNUSED;
 713   tree attr_args ATTRIBUTE_UNUSED;
 714   tree decl ATTRIBUTE_UNUSED;
 715   tree type ATTRIBUTE_UNUSED;
 716 {
 717   return 0;
 718 }
 719
 720 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
 721    attribute for either declaration DECL or type TYPE and 0 otherwise.  */
 722
 723 int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree))
 724      = default_valid_lang_attribute;
 725
 726 /* Process the attributes listed in ATTRIBUTES and install them in NODE,
 727    which is either a DECL (including a TYPE_DECL) or a TYPE.  */
 728
 729 void
 730 decl_attributes (node, attributes)
 731      tree node, attributes;
 732 {
 733   tree decl = 0, type = 0;
 734   int is_type = 0;
 735   tree a;
 736
 737   if (attrtab_idx == 0)
 738     init_attributes ();
 739
 740   if (DECL_P (node))
 741     {
 742       decl = node;
 743       type = TREE_TYPE (decl);
 744       is_type = TREE_CODE (node) == TYPE_DECL;
 745     }
 746   else if (TYPE_P (node))
 747     type = node, is_type = 1;
 748
 749   (*targetm.insert_attributes) (node, &attributes);
 750
 751   for (a = attributes; a; a = TREE_CHAIN (a))
 752     {
 753       tree name = TREE_PURPOSE (a);
 754       tree args = TREE_VALUE (a);
 755       int i;
 756       enum attrs id;
 757
 758       for (i = 0; i < attrtab_idx; i++)
 759         if (attrtab[i].name == name)
 760           break;
 761
 762       if (i == attrtab_idx)
 763         {
 764           if (! valid_machine_attribute (name, args, decl, type)
 765               && ! (* valid_lang_attribute) (name, args, decl, type))
 766             warning ("`%s' attribute directive ignored",
 767                      IDENTIFIER_POINTER (name));
 768           else if (decl != 0)
 769             type = TREE_TYPE (decl);
 770           continue;
 771         }
 772       else if (attrtab[i].decl_req && decl == 0)
 773         {
 774           warning ("`%s' attribute does not apply to types",
 775                    IDENTIFIER_POINTER (name));
 776           continue;
 777         }
 778       else if (list_length (args) < attrtab[i].min
 779                || list_length (args) > attrtab[i].max)
 780         {
 781           error ("wrong number of arguments specified for `%s' attribute",
 782                  IDENTIFIER_POINTER (name));
 783           continue;
 784         }
 785
 786       id = attrtab[i].id;
 787       switch (id)
 788         {
 789         case A_PACKED:
 790           if (is_type)
 791             TYPE_PACKED (type) = 1;
 792           else if (TREE_CODE (decl) == FIELD_DECL)
 793             DECL_PACKED (decl) = 1;
 794           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 795              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 796           else
 797             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 798           break;
 799
 800         case A_NOCOMMON:
 801           if (TREE_CODE (decl) == VAR_DECL)
 802             DECL_COMMON (decl) = 0;
 803           else
 804             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 805           break;
 806
 807         case A_COMMON:
 808           if (TREE_CODE (decl) == VAR_DECL)
 809             DECL_COMMON (decl) = 1;
 810           else
 811             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 812           break;
 813
 814         case A_NORETURN:
 815           if (TREE_CODE (decl) == FUNCTION_DECL)
 816             TREE_THIS_VOLATILE (decl) = 1;
 817           else if (TREE_CODE (type) == POINTER_TYPE
 818                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 819             TREE_TYPE (decl) = type
 820               = build_pointer_type
 821                 (build_type_variant (TREE_TYPE (type),
 822                                      TREE_READONLY (TREE_TYPE (type)), 1));
 823           else
 824             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 825           break;
 826
 827         case A_MALLOC:
 828           if (TREE_CODE (decl) == FUNCTION_DECL)
 829             DECL_IS_MALLOC (decl) = 1;
 830           /* ??? TODO: Support types.  */
 831           else
 832             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 833           break;
 834
 835         case A_UNUSED:
 836           if (is_type)
 837             if (decl)
 838               TREE_USED (decl) = 1;
 839             else
 840               TREE_USED (type) = 1;
 841           else if (TREE_CODE (decl) == PARM_DECL
 842                    || TREE_CODE (decl) == VAR_DECL
 843                    || TREE_CODE (decl) == FUNCTION_DECL
 844                    || TREE_CODE (decl) == LABEL_DECL)
 845             TREE_USED (decl) = 1;
 846           else
 847             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 848           break;
 849
 850         case A_CONST:
 851           if (TREE_CODE (decl) == FUNCTION_DECL)
 852             TREE_READONLY (decl) = 1;
 853           else if (TREE_CODE (type) == POINTER_TYPE
 854                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 855             TREE_TYPE (decl) = type
 856               = build_pointer_type
 857                 (build_type_variant (TREE_TYPE (type), 1,
 858                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 859           else
 860             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 861           break;
 862
 863         case A_PURE:
 864           if (TREE_CODE (decl) == FUNCTION_DECL)
 865             DECL_IS_PURE (decl) = 1;
 866           /* ??? TODO: Support types.  */
 867           else
 868             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 869           break;
 870
 871
 872         case A_T_UNION:
 873           if (is_type
 874               && TREE_CODE (type) == UNION_TYPE
 875               && (decl == 0
 876                   || (TYPE_FIELDS (type) != 0
 877                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 878             TYPE_TRANSPARENT_UNION (type) = 1;
 879           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 880                    && TREE_CODE (type) == UNION_TYPE
 881                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 882             DECL_TRANSPARENT_UNION (decl) = 1;
 883           else
 884             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 885           break;
 886
 887         case A_CONSTRUCTOR:
 888           if (TREE_CODE (decl) == FUNCTION_DECL
 889               && TREE_CODE (type) == FUNCTION_TYPE
 890               && decl_function_context (decl) == 0)
 891             {
 892               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 893               TREE_USED (decl) = 1;
 894             }
 895           else
 896             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 897           break;
 898
 899         case A_DESTRUCTOR:
 900           if (TREE_CODE (decl) == FUNCTION_DECL
 901               && TREE_CODE (type) == FUNCTION_TYPE
 902               && decl_function_context (decl) == 0)
 903             {
 904               DECL_STATIC_DESTRUCTOR (decl) = 1;
 905               TREE_USED (decl) = 1;
 906             }
 907           else
 908             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 909           break;
 910
 911         case A_MODE:
 912           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 913             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 914           else
 915             {
 916               int j;
 917               const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 918               int len = strlen (p);
 919               enum machine_mode mode = VOIDmode;
 920               tree typefm;
 921
 922               if (len > 4 && p[0] == '_' && p[1] == '_'
 923                   && p[len - 1] == '_' && p[len - 2] == '_')
 924                 {
 925                   char *newp = (char *) alloca (len - 1);
 926
 927                   strcpy (newp, &p[2]);
 928                   newp[len - 4] = '\0';
 929                   p = newp;
 930                 }
 931
 932               /* Give this decl a type with the specified mode.
 933                  First check for the special modes.  */
 934               if (! strcmp (p, "byte"))
 935                 mode = byte_mode;
 936               else if (!strcmp (p, "word"))
 937                 mode = word_mode;
 938               else if (! strcmp (p, "pointer"))
 939                 mode = ptr_mode;
 940               else
 941                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 942                   if (!strcmp (p, GET_MODE_NAME (j)))
 943                     mode = (enum machine_mode) j;
 944
 945               if (mode == VOIDmode)
 946                 error ("unknown machine mode `%s'", p);
 947               else if (0 == (typefm = type_for_mode (mode,
 948                                                      TREE_UNSIGNED (type))))
 949                 error ("no data type for mode `%s'", p);
 950               else
 951                 {
 952                   if (TYPE_PRECISION (typefm) > (TREE_UNSIGNED (type)
 953                                                  ? TYPE_PRECISION(uintmax_type_node)
 954                                                  : TYPE_PRECISION(intmax_type_node))
 955                       && pedantic)
 956                     pedwarn ("type with more precision than %s",
 957                              TREE_UNSIGNED (type) ? "uintmax_t" : "intmax_t");
 958                   TREE_TYPE (decl) = type = typefm;
 959                   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
 960                   if (TREE_CODE (decl) != FIELD_DECL)
 961                     layout_decl (decl, 0);
 962                 }
 963             }
 964           break;
 965
 966         case A_SECTION:
 967 #ifdef ASM_OUTPUT_SECTION_NAME
 968           if ((TREE_CODE (decl) == FUNCTION_DECL
 969                || TREE_CODE (decl) == VAR_DECL)
 970               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 971             {
 972               if (TREE_CODE (decl) == VAR_DECL
 973                   && current_function_decl != NULL_TREE
 974                   && ! TREE_STATIC (decl))
 975                 error_with_decl (decl,
 976                   "section attribute cannot be specified for local variables");
 977               /* The decl may have already been given a section attribute from
 978                  a previous declaration.  Ensure they match.  */
 979               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 980                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 981                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 982                 error_with_decl (node,
 983                                  "section of `%s' conflicts with previous declaration");
 984               else
 985                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 986             }
 987           else
 988             error_with_decl (node,
 989                            "section attribute not allowed for `%s'");
 990 #else
 991           error_with_decl (node,
 992                   "section attributes are not supported for this target");
 993 #endif
 994           break;
 995
 996         case A_ALIGNED:
 997           {
 998             tree align_expr
 999               = (args ? TREE_VALUE (args)
1000                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1001             int i;
1002
1003             /* Strip any NOPs of any kind.  */
1004             while (TREE_CODE (align_expr) == NOP_EXPR
1005                    || TREE_CODE (align_expr) == CONVERT_EXPR
1006                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
1007               align_expr = TREE_OPERAND (align_expr, 0);
1008
1009             if (TREE_CODE (align_expr) != INTEGER_CST)
1010               {
1011                 error ("requested alignment is not a constant");
1012                 continue;
1013               }
1014
1015             if ((i = tree_log2 (align_expr)) == -1)
1016               error ("requested alignment is not a power of 2");
1017             else if (i > HOST_BITS_PER_INT - 2)
1018               error ("requested alignment is too large");
1019             else if (is_type)
1020               {
1021                 /* If we have a TYPE_DECL, then copy the type, so that we
1022                    don't accidentally modify a builtin type.  See pushdecl.  */
1023                 if (decl && TREE_TYPE (decl) != error_mark_node
1024                     && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
1025                   {
1026                     tree tt = TREE_TYPE (decl);
1027                     DECL_ORIGINAL_TYPE (decl) = tt;
1028                     tt = build_type_copy (tt);
1029                     TYPE_NAME (tt) = decl;
1030                     TREE_USED (tt) = TREE_USED (decl);
1031                     TREE_TYPE (decl) = tt;
1032                     type = tt;
1033                   }
1034
1035                 TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
1036                 TYPE_USER_ALIGN (type) = 1;
1037               }
1038             else if (TREE_CODE (decl) != VAR_DECL
1039                      && TREE_CODE (decl) != FIELD_DECL)
1040               error_with_decl (decl,
1041                                "alignment may not be specified for `%s'");
1042             else
1043               {
1044                 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
1045                 DECL_USER_ALIGN (decl) = 1;
1046               }
1047           }
1048           break;
1049
1050         case A_FORMAT:
1051           decl_handle_format_attribute (decl, args);
1052           break;
1053
1054         case A_FORMAT_ARG:
1055           decl_handle_format_arg_attribute (decl, args);
1056           break;
1057
1058         case A_WEAK:
1059           declare_weak (decl);
1060           break;
1061
1062         case A_ALIAS:
1063           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
1064               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
1065             error_with_decl (decl,
1066                              "`%s' defined both normally and as an alias");
1067           else if (decl_function_context (decl) == 0)
1068             {
1069               tree id;
1070
1071               id = TREE_VALUE (args);
1072               if (TREE_CODE (id) != STRING_CST)
1073                 {
1074                   error ("alias arg not a string");
1075                   break;
1076                 }
1077               id = get_identifier (TREE_STRING_POINTER (id));
1078               /* This counts as a use of the object pointed to.  */
1079               TREE_USED (id) = 1;
1080
1081               if (TREE_CODE (decl) == FUNCTION_DECL)
1082                 DECL_INITIAL (decl) = error_mark_node;
1083               else
1084                 DECL_EXTERNAL (decl) = 0;
1085               assemble_alias (decl, id);
1086             }
1087           else
1088             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1089           break;
1090
1091         case A_NO_CHECK_MEMORY_USAGE:
1092           if (TREE_CODE (decl) != FUNCTION_DECL)
1093             {
1094               error_with_decl (decl,
1095                                "`%s' attribute applies only to functions",
1096                                IDENTIFIER_POINTER (name));
1097             }
1098           else if (DECL_INITIAL (decl))
1099             {
1100               error_with_decl (decl,
1101                                "can't set `%s' attribute after definition",
1102                                IDENTIFIER_POINTER (name));
1103             }
1104           else
1105             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1106           break;
1107
1108         case A_NO_INSTRUMENT_FUNCTION:
1109           if (TREE_CODE (decl) != FUNCTION_DECL)
1110             {
1111               error_with_decl (decl,
1112                                "`%s' attribute applies only to functions",
1113                                IDENTIFIER_POINTER (name));
1114             }
1115           else if (DECL_INITIAL (decl))
1116             {
1117               error_with_decl (decl,
1118                                "can't set `%s' attribute after definition",
1119                                IDENTIFIER_POINTER (name));
1120             }
1121           else
1122             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1123           break;
1124
1125         case A_NO_LIMIT_STACK:
1126           if (TREE_CODE (decl) != FUNCTION_DECL)
1127             {
1128               error_with_decl (decl,
1129                                "`%s' attribute applies only to functions",
1130                                IDENTIFIER_POINTER (name));
1131             }
1132           else if (DECL_INITIAL (decl))
1133             {
1134               error_with_decl (decl,
1135                                "can't set `%s' attribute after definition",
1136                                IDENTIFIER_POINTER (name));
1137             }
1138           else
1139             DECL_NO_LIMIT_STACK (decl) = 1;
1140           break;
1141         }
1142     }
1143 }
1144
1145 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1146    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1147
1148    The head of the declspec list is stored in DECLSPECS.
1149    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1150
1151    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1152    the list elements.  We drop the containing TREE_LIST nodes and link the
1153    resulting attributes together the way decl_attributes expects them.  */
1154
1155 void
1156 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1157      tree specs_attrs;
1158      tree *declspecs, *prefix_attributes;
1159 {
1160   tree t, s, a, next, specs, attrs;
1161
1162   /* This can happen after an __extension__ in pedantic mode.  */
1163   if (specs_attrs != NULL_TREE
1164       && TREE_CODE (specs_attrs) == INTEGER_CST)
1165     {
1166       *declspecs = NULL_TREE;
1167       *prefix_attributes = NULL_TREE;
1168       return;
1169     }
1170
1171   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1172   if (specs_attrs != NULL_TREE
1173       && TREE_CODE (specs_attrs) != TREE_LIST)
1174     {
1175       *declspecs = specs_attrs;
1176       *prefix_attributes = NULL_TREE;
1177       return;
1178     }
1179
1180   /* Remember to keep the lists in the same order, element-wise.  */
1181
1182   specs = s = NULL_TREE;
1183   attrs = a = NULL_TREE;
1184   for (t = specs_attrs; t; t = next)
1185     {
1186       next = TREE_CHAIN (t);
1187       /* Declspecs have a non-NULL TREE_VALUE.  */
1188       if (TREE_VALUE (t) != NULL_TREE)
1189         {
1190           if (specs == NULL_TREE)
1191             specs = s = t;
1192           else
1193             {
1194               TREE_CHAIN (s) = t;
1195               s = t;
1196             }
1197         }
1198       else
1199         {
1200           if (attrs == NULL_TREE)
1201             attrs = a = TREE_PURPOSE (t);
1202           else
1203             {
1204               TREE_CHAIN (a) = TREE_PURPOSE (t);
1205               a = TREE_PURPOSE (t);
1206             }
1207           /* More attrs can be linked here, move A to the end.  */
1208           while (TREE_CHAIN (a) != NULL_TREE)
1209             a = TREE_CHAIN (a);
1210         }
1211     }
1212
1213   /* Terminate the lists.  */
1214   if (s != NULL_TREE)
1215     TREE_CHAIN (s) = NULL_TREE;
1216   if (a != NULL_TREE)
1217     TREE_CHAIN (a) = NULL_TREE;
1218
1219   /* All done.  */
1220   *declspecs = specs;
1221   *prefix_attributes = attrs;
1222 }
1223
1224 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1225    This function is used by the parser when a rule will accept attributes
1226    in a particular position, but we don't want to support that just yet.
1227
1228    A warning is issued for every ignored attribute.  */
1229
1230 tree
1231 strip_attrs (specs_attrs)
1232      tree specs_attrs;
1233 {
1234   tree specs, attrs;
1235
1236   split_specs_attrs (specs_attrs, &specs, &attrs);
1237
1238   while (attrs)
1239     {
1240       warning ("`%s' attribute ignored",
1241                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1242       attrs = TREE_CHAIN (attrs);
1243     }
1244
1245   return specs;
1246 }
1247 \f
1248 static int is_valid_printf_arglist PARAMS ((tree));
1249 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1250 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1251                                             enum expand_modifier, int));
1252 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1253                                              enum expand_modifier, int));
1254 \f
1255 /* Print a warning if a constant expression had overflow in folding.
1256    Invoke this function on every expression that the language
1257    requires to be a constant expression.
1258    Note the ANSI C standard says it is erroneous for a
1259    constant expression to overflow.  */
1260
1261 void
1262 constant_expression_warning (value)
1263      tree value;
1264 {
1265   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1266        || TREE_CODE (value) == COMPLEX_CST)
1267       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1268     pedwarn ("overflow in constant expression");
1269 }
1270
1271 /* Print a warning if an expression had overflow in folding.
1272    Invoke this function on every expression that
1273    (1) appears in the source code, and
1274    (2) might be a constant expression that overflowed, and
1275    (3) is not already checked by convert_and_check;
1276    however, do not invoke this function on operands of explicit casts.  */
1277
1278 void
1279 overflow_warning (value)
1280      tree value;
1281 {
1282   if ((TREE_CODE (value) == INTEGER_CST
1283        || (TREE_CODE (value) == COMPLEX_CST
1284            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1285       && TREE_OVERFLOW (value))
1286     {
1287       TREE_OVERFLOW (value) = 0;
1288       if (skip_evaluation == 0)
1289         warning ("integer overflow in expression");
1290     }
1291   else if ((TREE_CODE (value) == REAL_CST
1292             || (TREE_CODE (value) == COMPLEX_CST
1293                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1294            && TREE_OVERFLOW (value))
1295     {
1296       TREE_OVERFLOW (value) = 0;
1297       if (skip_evaluation == 0)
1298         warning ("floating point overflow in expression");
1299     }
1300 }
1301
1302 /* Print a warning if a large constant is truncated to unsigned,
1303    or if -Wconversion is used and a constant < 0 is converted to unsigned.
1304    Invoke this function on every expression that might be implicitly
1305    converted to an unsigned type.  */
1306
1307 void
1308 unsigned_conversion_warning (result, operand)
1309      tree result, operand;
1310 {
1311   if (TREE_CODE (operand) == INTEGER_CST
1312       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
1313       && TREE_UNSIGNED (TREE_TYPE (result))
1314       && skip_evaluation == 0
1315       && !int_fits_type_p (operand, TREE_TYPE (result)))
1316     {
1317       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
1318         /* This detects cases like converting -129 or 256 to unsigned char.  */
1319         warning ("large integer implicitly truncated to unsigned type");
1320       else if (warn_conversion)
1321         warning ("negative integer implicitly converted to unsigned type");
1322     }
1323 }
1324
1325 /* Nonzero if constant C has a value that is permissible
1326    for type TYPE (an INTEGER_TYPE).  */
1327
1328 static int
1329 constant_fits_type_p (c, type)
1330      tree c, type;
1331 {
1332   if (TREE_CODE (c) == INTEGER_CST)
1333     return int_fits_type_p (c, type);
1334
1335   c = convert (type, c);
1336   return !TREE_OVERFLOW (c);
1337 }
1338
1339 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1340    Invoke this function on every expression that is converted implicitly,
1341    i.e. because of language rules and not because of an explicit cast.  */
1342
1343 tree
1344 convert_and_check (type, expr)
1345      tree type, expr;
1346 {
1347   tree t = convert (type, expr);
1348   if (TREE_CODE (t) == INTEGER_CST)
1349     {
1350       if (TREE_OVERFLOW (t))
1351         {
1352           TREE_OVERFLOW (t) = 0;
1353
1354           /* Do not diagnose overflow in a constant expression merely
1355              because a conversion overflowed.  */
1356           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1357
1358           /* No warning for converting 0x80000000 to int.  */
1359           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1360                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1361                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1362             /* If EXPR fits in the unsigned version of TYPE,
1363                don't warn unless pedantic.  */
1364             if ((pedantic
1365                  || TREE_UNSIGNED (type)
1366                  || ! constant_fits_type_p (expr, unsigned_type (type)))
1367                 && skip_evaluation == 0)
1368               warning ("overflow in implicit constant conversion");
1369         }
1370       else
1371         unsigned_conversion_warning (t, expr);
1372     }
1373   return t;
1374 }
1375 \f
1376 /* A node in a list that describes references to variables (EXPR), which are
1377    either read accesses if WRITER is zero, or write accesses, in which case
1378    WRITER is the parent of EXPR.  */
1379 struct tlist
1380 {
1381   struct tlist *next;
1382   tree expr, writer;
1383 };
1384
1385 /* Used to implement a cache the results of a call to verify_tree.  We only
1386    use this for SAVE_EXPRs.  */
1387 struct tlist_cache
1388 {
1389   struct tlist_cache *next;
1390   struct tlist *cache_before_sp;
1391   struct tlist *cache_after_sp;
1392   tree expr;
1393 };
1394
1395 /* Obstack to use when allocating tlist structures, and corresponding
1396    firstobj.  */
1397 static struct obstack tlist_obstack;
1398 static char *tlist_firstobj = 0;
1399
1400 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1401    warnings.  */
1402 static struct tlist *warned_ids;
1403 /* SAVE_EXPRs need special treatment.  We process them only once and then
1404    cache the results.  */
1405 static struct tlist_cache *save_expr_cache;
1406
1407 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1408 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1409 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1410 static int warning_candidate_p PARAMS ((tree));
1411 static void warn_for_collisions PARAMS ((struct tlist *));
1412 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1413 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1414 static void verify_sequence_points PARAMS ((tree));
1415
1416 /* Create a new struct tlist and fill in its fields.  */
1417 static struct tlist *
1418 new_tlist (next, t, writer)
1419      struct tlist *next;
1420      tree t;
1421      tree writer;
1422 {
1423   struct tlist *l;
1424   l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1425   l->next = next;
1426   l->expr = t;
1427   l->writer = writer;
1428   return l;
1429 }
1430
1431 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1432    is nonnull, we ignore any node we find which has a writer equal to it.  */
1433
1434 static void
1435 add_tlist (to, add, exclude_writer, copy)
1436      struct tlist **to;
1437      struct tlist *add;
1438      tree exclude_writer;
1439      int copy;
1440 {
1441   while (add)
1442     {
1443       struct tlist *next = add->next;
1444       if (! copy)
1445         add->next = *to;
1446       if (! exclude_writer || add->writer != exclude_writer)
1447         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1448       add = next;
1449     }
1450 }
1451
1452 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1453    each variable that already exists in TO, no new node is added; however if
1454    there is a write access recorded in ADD, and an occurrence on TO is only
1455    a read access, then the occurrence in TO will be modified to record the
1456    write.  */
1457
1458 static void
1459 merge_tlist (to, add, copy)
1460      struct tlist **to;
1461      struct tlist *add;
1462      int copy;
1463 {
1464   struct tlist **end = to;
1465
1466   while (*end)
1467     end = &(*end)->next;
1468
1469   while (add)
1470     {
1471       int found = 0;
1472       struct tlist *tmp2;
1473       struct tlist *next = add->next;
1474
1475       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1476         if (tmp2->expr == add->expr)
1477           {
1478             found = 1;
1479             if (! tmp2->writer)
1480               tmp2->writer = add->writer;
1481           }
1482       if (! found)
1483         {
1484           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1485           end = &(*end)->next;
1486           *end = 0;
1487         }
1488       add = next;
1489     }
1490 }
1491
1492 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1493    references in list LIST conflict with it, excluding reads if ONLY writers
1494    is nonzero.  */
1495
1496 static void
1497 warn_for_collisions_1 (written, writer, list, only_writes)
1498      tree written, writer;
1499      struct tlist *list;
1500      int only_writes;
1501 {
1502   struct tlist *tmp;
1503
1504   /* Avoid duplicate warnings.  */
1505   for (tmp = warned_ids; tmp; tmp = tmp->next)
1506     if (tmp->expr == written)
1507       return;
1508
1509   while (list)
1510     {
1511       if (list->expr == written
1512           && list->writer != writer
1513           && (! only_writes || list->writer))
1514         {
1515           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1516           warning ("operation on `%s' may be undefined",
1517                    IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1518         }
1519       list = list->next;
1520     }
1521 }
1522
1523 /* Given a list LIST of references to variables, find whether any of these
1524    can cause conflicts due to missing sequence points.  */
1525
1526 static void
1527 warn_for_collisions (list)
1528      struct tlist *list;
1529 {
1530   struct tlist *tmp;
1531
1532   for (tmp = list; tmp; tmp = tmp->next)
1533     {
1534       if (tmp->writer)
1535         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1536     }
1537 }
1538
1539 /* Return nonzero if X is a tree that can be verified by the sequence poitn
1540    warnings.  */
1541 static int
1542 warning_candidate_p (x)
1543      tree x;
1544 {
1545   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1546 }
1547
1548 /* Walk the tree X, and record accesses to variables.  If X is written by the
1549    parent tree, WRITER is the parent.
1550    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1551    expression or its only operand forces a sequence point, then everything up
1552    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1553    in PNO_SP.
1554    Once we return, we will have emitted warnings if any subexpression before
1555    such a sequence point could be undefined.  On a higher level, however, the
1556    sequence point may not be relevant, and we'll merge the two lists.
1557
1558    Example: (b++, a) + b;
1559    The call that processes the COMPOUND_EXPR will store the increment of B
1560    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1561    processes the PLUS_EXPR will need to merge the two lists so that
1562    eventually, all accesses end up on the same list (and we'll warn about the
1563    unordered subexpressions b++ and b.
1564
1565    A note on merging.  If we modify the former example so that our expression
1566    becomes
1567      (b++, b) + a
1568    care must be taken not simply to add all three expressions into the final
1569    PNO_SP list.  The function merge_tlist takes care of that by merging the
1570    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1571    way, so that no more than one access to B is recorded.  */
1572
1573 static void
1574 verify_tree (x, pbefore_sp, pno_sp, writer)
1575      tree x;
1576      struct tlist **pbefore_sp, **pno_sp;
1577      tree writer;
1578 {
1579   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1580   enum tree_code code;
1581   char class;
1582
1583   /* X may be NULL if it is the operand of an empty statement expression
1584      ({ }).  */
1585   if (x == NULL)
1586     return;
1587
1588  restart:
1589   code = TREE_CODE (x);
1590   class = TREE_CODE_CLASS (code);
1591
1592   if (warning_candidate_p (x))
1593     {
1594       *pno_sp = new_tlist (*pno_sp, x, writer);
1595       return;
1596     }
1597
1598   switch (code)
1599     {
1600     case CONSTRUCTOR:
1601       return;
1602
1603     case COMPOUND_EXPR:
1604     case TRUTH_ANDIF_EXPR:
1605     case TRUTH_ORIF_EXPR:
1606       tmp_before = tmp_nosp = tmp_list3 = 0;
1607       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1608       warn_for_collisions (tmp_nosp);
1609       merge_tlist (pbefore_sp, tmp_before, 0);
1610       merge_tlist (pbefore_sp, tmp_nosp, 0);
1611       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1612       merge_tlist (pbefore_sp, tmp_list3, 0);
1613       return;
1614
1615     case COND_EXPR:
1616       tmp_before = tmp_list2 = 0;
1617       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1618       warn_for_collisions (tmp_list2);
1619       merge_tlist (pbefore_sp, tmp_before, 0);
1620       merge_tlist (pbefore_sp, tmp_list2, 1);
1621
1622       tmp_list3 = tmp_nosp = 0;
1623       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1624       warn_for_collisions (tmp_nosp);
1625       merge_tlist (pbefore_sp, tmp_list3, 0);
1626
1627       tmp_list3 = tmp_list2 = 0;
1628       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1629       warn_for_collisions (tmp_list2);
1630       merge_tlist (pbefore_sp, tmp_list3, 0);
1631       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1632          two first, to avoid warning for (a ? b++ : b++).  */
1633       merge_tlist (&tmp_nosp, tmp_list2, 0);
1634       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1635       return;
1636
1637     case PREDECREMENT_EXPR:
1638     case PREINCREMENT_EXPR:
1639     case POSTDECREMENT_EXPR:
1640     case POSTINCREMENT_EXPR:
1641       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1642       return;
1643
1644     case MODIFY_EXPR:
1645       tmp_before = tmp_nosp = tmp_list3 = 0;
1646       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1647       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1648       /* Expressions inside the LHS are not ordered wrt. the sequence points
1649          in the RHS.  Example:
1650            *a = (a++, 2)
1651          Despite the fact that the modification of "a" is in the before_sp
1652          list (tmp_before), it conflicts with the use of "a" in the LHS.
1653          We can handle this by adding the contents of tmp_list3
1654          to those of tmp_before, and redoing the collision warnings for that
1655          list.  */
1656       add_tlist (&tmp_before, tmp_list3, x, 1);
1657       warn_for_collisions (tmp_before);
1658       /* Exclude the LHS itself here; we first have to merge it into the
1659          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1660          didn't exclude the LHS, we'd get it twice, once as a read and once
1661          as a write.  */
1662       add_tlist (pno_sp, tmp_list3, x, 0);
1663       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1664
1665       merge_tlist (pbefore_sp, tmp_before, 0);
1666       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1667         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1668       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1669       return;
1670
1671     case CALL_EXPR:
1672       /* We need to warn about conflicts among arguments and conflicts between
1673          args and the function address.  Side effects of the function address,
1674          however, are not ordered by the sequence point of the call.  */
1675       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1676       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1677       if (TREE_OPERAND (x, 1))
1678         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1679       merge_tlist (&tmp_list3, tmp_list2, 0);
1680       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1681       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1682       warn_for_collisions (tmp_before);
1683       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1684       return;
1685
1686     case TREE_LIST:
1687       /* Scan all the list, e.g. indices of multi dimensional array.  */
1688       while (x)
1689         {
1690           tmp_before = tmp_nosp = 0;
1691           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1692           merge_tlist (&tmp_nosp, tmp_before, 0);
1693           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1694           x = TREE_CHAIN (x);
1695         }
1696       return;
1697
1698     case SAVE_EXPR:
1699       {
1700         struct tlist_cache *t;
1701         for (t = save_expr_cache; t; t = t->next)
1702           if (t->expr == x)
1703             break;
1704
1705         if (! t)
1706           {
1707             t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1708                                                       sizeof *t);
1709             t->next = save_expr_cache;
1710             t->expr = x;
1711             save_expr_cache = t;
1712
1713             tmp_before = tmp_nosp = 0;
1714             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1715             warn_for_collisions (tmp_nosp);
1716
1717             tmp_list3 = 0;
1718             while (tmp_nosp)
1719               {
1720                 struct tlist *t = tmp_nosp;
1721                 tmp_nosp = t->next;
1722                 merge_tlist (&tmp_list3, t, 0);
1723               }
1724             t->cache_before_sp = tmp_before;
1725             t->cache_after_sp = tmp_list3;
1726           }
1727         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1728         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1729         return;
1730       }
1731     default:
1732       break;
1733     }
1734
1735   if (class == '1')
1736     {
1737       if (first_rtl_op (code) == 0)
1738         return;
1739       x = TREE_OPERAND (x, 0);
1740       writer = 0;
1741       goto restart;
1742     }
1743
1744   switch (class)
1745     {
1746     case 'r':
1747     case '<':
1748     case '2':
1749     case 'b':
1750     case 'e':
1751     case 's':
1752     case 'x':
1753       {
1754         int lp;
1755         int max = first_rtl_op (TREE_CODE (x));
1756         for (lp = 0; lp < max; lp++)
1757           {
1758             tmp_before = tmp_nosp = 0;
1759             verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1760             merge_tlist (&tmp_nosp, tmp_before, 0);
1761             add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1762           }
1763         break;
1764       }
1765     }
1766 }
1767
1768 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1769    points.  */
1770
1771 static void
1772 verify_sequence_points (expr)
1773      tree expr;
1774 {
1775   struct tlist *before_sp = 0, *after_sp = 0;
1776
1777   warned_ids = 0;
1778   save_expr_cache = 0;
1779   if (tlist_firstobj == 0)
1780     {
1781       gcc_obstack_init (&tlist_obstack);
1782       tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1783     }
1784
1785   verify_tree (expr, &before_sp, &after_sp, 0);
1786   warn_for_collisions (after_sp);
1787   obstack_free (&tlist_obstack, tlist_firstobj);
1788 }
1789
1790 tree
1791 c_expand_expr_stmt (expr)
1792      tree expr;
1793 {
1794   /* Do default conversion if safe and possibly important,
1795      in case within ({...}).  */
1796   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1797       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1798     expr = default_conversion (expr);
1799
1800   if (warn_sequence_point)
1801     verify_sequence_points (expr);
1802
1803   if (TREE_TYPE (expr) != error_mark_node
1804       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1805       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1806     error ("expression statement has incomplete type");
1807
1808   last_expr_type = TREE_TYPE (expr);
1809   return add_stmt (build_stmt (EXPR_STMT, expr));
1810 }
1811 \f
1812 /* Validate the expression after `case' and apply default promotions.  */
1813
1814 tree
1815 check_case_value (value)
1816      tree value;
1817 {
1818   if (value == NULL_TREE)
1819     return value;
1820
1821   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1822   STRIP_TYPE_NOPS (value);
1823   /* In C++, the following is allowed:
1824
1825        const int i = 3;
1826        switch (...) { case i: ... }
1827
1828      So, we try to reduce the VALUE to a constant that way.  */
1829   if (c_language == clk_cplusplus)
1830     {
1831       value = decl_constant_value (value);
1832       STRIP_TYPE_NOPS (value);
1833       value = fold (value);
1834     }
1835
1836   if (TREE_CODE (value) != INTEGER_CST
1837       && value != error_mark_node)
1838     {
1839       error ("case label does not reduce to an integer constant");
1840       value = error_mark_node;
1841     }
1842   else
1843     /* Promote char or short to int.  */
1844     value = default_conversion (value);
1845
1846   constant_expression_warning (value);
1847
1848   return value;
1849 }
1850 \f
1851 /* Return an integer type with BITS bits of precision,
1852    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1853
1854 tree
1855 type_for_size (bits, unsignedp)
1856      unsigned bits;
1857      int unsignedp;
1858 {
1859   if (bits == TYPE_PRECISION (integer_type_node))
1860     return unsignedp ? unsigned_type_node : integer_type_node;
1861
1862   if (bits == TYPE_PRECISION (signed_char_type_node))
1863     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1864
1865   if (bits == TYPE_PRECISION (short_integer_type_node))
1866     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1867
1868   if (bits == TYPE_PRECISION (long_integer_type_node))
1869     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1870
1871   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1872     return (unsignedp ? long_long_unsigned_type_node
1873             : long_long_integer_type_node);
1874
1875   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1876     return (unsignedp ? widest_unsigned_literal_type_node
1877             : widest_integer_literal_type_node);
1878
1879   if (bits <= TYPE_PRECISION (intQI_type_node))
1880     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1881
1882   if (bits <= TYPE_PRECISION (intHI_type_node))
1883     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1884
1885   if (bits <= TYPE_PRECISION (intSI_type_node))
1886     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1887
1888   if (bits <= TYPE_PRECISION (intDI_type_node))
1889     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1890
1891   return 0;
1892 }
1893
1894 /* Return a data type that has machine mode MODE.
1895    If the mode is an integer,
1896    then UNSIGNEDP selects between signed and unsigned types.  */
1897
1898 tree
1899 type_for_mode (mode, unsignedp)
1900      enum machine_mode mode;
1901      int unsignedp;
1902 {
1903   if (mode == TYPE_MODE (integer_type_node))
1904     return unsignedp ? unsigned_type_node : integer_type_node;
1905
1906   if (mode == TYPE_MODE (signed_char_type_node))
1907     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1908
1909   if (mode == TYPE_MODE (short_integer_type_node))
1910     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1911
1912   if (mode == TYPE_MODE (long_integer_type_node))
1913     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1914
1915   if (mode == TYPE_MODE (long_long_integer_type_node))
1916     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1917
1918   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1919     return unsignedp ? widest_unsigned_literal_type_node
1920                      : widest_integer_literal_type_node;
1921
1922   if (mode == TYPE_MODE (intQI_type_node))
1923     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1924
1925   if (mode == TYPE_MODE (intHI_type_node))
1926     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1927
1928   if (mode == TYPE_MODE (intSI_type_node))
1929     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1930
1931   if (mode == TYPE_MODE (intDI_type_node))
1932     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1933
1934 #if HOST_BITS_PER_WIDE_INT >= 64
1935   if (mode == TYPE_MODE (intTI_type_node))
1936     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1937 #endif
1938
1939   if (mode == TYPE_MODE (float_type_node))
1940     return float_type_node;
1941
1942   if (mode == TYPE_MODE (double_type_node))
1943     return double_type_node;
1944
1945   if (mode == TYPE_MODE (long_double_type_node))
1946     return long_double_type_node;
1947
1948   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1949     return build_pointer_type (char_type_node);
1950
1951   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1952     return build_pointer_type (integer_type_node);
1953
1954 #ifdef VECTOR_MODE_SUPPORTED_P
1955   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1956     return V4SF_type_node;
1957   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1958     return V4SI_type_node;
1959   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1960     return V2SI_type_node;
1961   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1962     return V4HI_type_node;
1963   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1964     return V8QI_type_node;
1965 #endif
1966
1967   return 0;
1968 }
1969
1970 /* Return an unsigned type the same as TYPE in other respects. */
1971 tree
1972 unsigned_type (type)
1973      tree type;
1974 {
1975   tree type1 = TYPE_MAIN_VARIANT (type);
1976   if (type1 == signed_char_type_node || type1 == char_type_node)
1977     return unsigned_char_type_node;
1978   if (type1 == integer_type_node)
1979     return unsigned_type_node;
1980   if (type1 == short_integer_type_node)
1981     return short_unsigned_type_node;
1982   if (type1 == long_integer_type_node)
1983     return long_unsigned_type_node;
1984   if (type1 == long_long_integer_type_node)
1985     return long_long_unsigned_type_node;
1986   if (type1 == widest_integer_literal_type_node)
1987     return widest_unsigned_literal_type_node;
1988 #if HOST_BITS_PER_WIDE_INT >= 64
1989   if (type1 == intTI_type_node)
1990     return unsigned_intTI_type_node;
1991 #endif
1992   if (type1 == intDI_type_node)
1993     return unsigned_intDI_type_node;
1994   if (type1 == intSI_type_node)
1995     return unsigned_intSI_type_node;
1996   if (type1 == intHI_type_node)
1997     return unsigned_intHI_type_node;
1998   if (type1 == intQI_type_node)
1999     return unsigned_intQI_type_node;
2000
2001   return signed_or_unsigned_type (1, type);
2002 }
2003
2004 /* Return a signed type the same as TYPE in other respects.  */
2005
2006 tree
2007 signed_type (type)
2008      tree type;
2009 {
2010   tree type1 = TYPE_MAIN_VARIANT (type);
2011   if (type1 == unsigned_char_type_node || type1 == char_type_node)
2012     return signed_char_type_node;
2013   if (type1 == unsigned_type_node)
2014     return integer_type_node;
2015   if (type1 == short_unsigned_type_node)
2016     return short_integer_type_node;
2017   if (type1 == long_unsigned_type_node)
2018     return long_integer_type_node;
2019   if (type1 == long_long_unsigned_type_node)
2020     return long_long_integer_type_node;
2021   if (type1 == widest_unsigned_literal_type_node)
2022     return widest_integer_literal_type_node;
2023 #if HOST_BITS_PER_WIDE_INT >= 64
2024   if (type1 == unsigned_intTI_type_node)
2025     return intTI_type_node;
2026 #endif
2027   if (type1 == unsigned_intDI_type_node)
2028     return intDI_type_node;
2029   if (type1 == unsigned_intSI_type_node)
2030     return intSI_type_node;
2031   if (type1 == unsigned_intHI_type_node)
2032     return intHI_type_node;
2033   if (type1 == unsigned_intQI_type_node)
2034     return intQI_type_node;
2035
2036   return signed_or_unsigned_type (0, type);
2037 }
2038
2039 /* Return a type the same as TYPE except unsigned or
2040    signed according to UNSIGNEDP.  */
2041
2042 tree
2043 signed_or_unsigned_type (unsignedp, type)
2044      int unsignedp;
2045      tree type;
2046 {
2047   if (! INTEGRAL_TYPE_P (type)
2048       || TREE_UNSIGNED (type) == unsignedp)
2049     return type;
2050
2051   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2052     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2053   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2054     return unsignedp ? unsigned_type_node : integer_type_node;
2055   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2056     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2057   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2058     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2059   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2060     return (unsignedp ? long_long_unsigned_type_node
2061             : long_long_integer_type_node);
2062   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2063     return (unsignedp ? widest_unsigned_literal_type_node
2064             : widest_integer_literal_type_node);
2065   return type;
2066 }
2067 \f
2068 /* Return the minimum number of bits needed to represent VALUE in a
2069    signed or unsigned type, UNSIGNEDP says which.  */
2070
2071 unsigned int
2072 min_precision (value, unsignedp)
2073      tree value;
2074      int unsignedp;
2075 {
2076   int log;
2077
2078   /* If the value is negative, compute its negative minus 1.  The latter
2079      adjustment is because the absolute value of the largest negative value
2080      is one larger than the largest positive value.  This is equivalent to
2081      a bit-wise negation, so use that operation instead.  */
2082
2083   if (tree_int_cst_sgn (value) < 0)
2084     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2085
2086   /* Return the number of bits needed, taking into account the fact
2087      that we need one more bit for a signed than unsigned type.  */
2088
2089   if (integer_zerop (value))
2090     log = 0;
2091   else
2092     log = tree_floor_log2 (value);
2093
2094   return log + 1 + ! unsignedp;
2095 }
2096 \f
2097 /* Print an error message for invalid operands to arith operation CODE.
2098    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2099
2100 void
2101 binary_op_error (code)
2102      enum tree_code code;
2103 {
2104   register const char *opname;
2105
2106   switch (code)
2107     {
2108     case NOP_EXPR:
2109       error ("invalid truth-value expression");
2110       return;
2111
2112     case PLUS_EXPR:
2113       opname = "+"; break;
2114     case MINUS_EXPR:
2115       opname = "-"; break;
2116     case MULT_EXPR:
2117       opname = "*"; break;
2118     case MAX_EXPR:
2119       opname = "max"; break;
2120     case MIN_EXPR:
2121       opname = "min"; break;
2122     case EQ_EXPR:
2123       opname = "=="; break;
2124     case NE_EXPR:
2125       opname = "!="; break;
2126     case LE_EXPR:
2127       opname = "<="; break;
2128     case GE_EXPR:
2129       opname = ">="; break;
2130     case LT_EXPR:
2131       opname = "<"; break;
2132     case GT_EXPR:
2133       opname = ">"; break;
2134     case LSHIFT_EXPR:
2135       opname = "<<"; break;
2136     case RSHIFT_EXPR:
2137       opname = ">>"; break;
2138     case TRUNC_MOD_EXPR:
2139     case FLOOR_MOD_EXPR:
2140       opname = "%"; break;
2141     case TRUNC_DIV_EXPR:
2142     case FLOOR_DIV_EXPR:
2143       opname = "/"; break;
2144     case BIT_AND_EXPR:
2145       opname = "&"; break;
2146     case BIT_IOR_EXPR:
2147       opname = "|"; break;
2148     case TRUTH_ANDIF_EXPR:
2149       opname = "&&"; break;
2150     case TRUTH_ORIF_EXPR:
2151       opname = "||"; break;
2152     case BIT_XOR_EXPR:
2153       opname = "^"; break;
2154     case LROTATE_EXPR:
2155     case RROTATE_EXPR:
2156       opname = "rotate"; break;
2157     default:
2158       opname = "unknown"; break;
2159     }
2160   error ("invalid operands to binary %s", opname);
2161 }
2162 \f
2163 /* Subroutine of build_binary_op, used for comparison operations.
2164    See if the operands have both been converted from subword integer types
2165    and, if so, perhaps change them both back to their original type.
2166    This function is also responsible for converting the two operands
2167    to the proper common type for comparison.
2168
2169    The arguments of this function are all pointers to local variables
2170    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2171    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2172
2173    If this function returns nonzero, it means that the comparison has
2174    a constant value.  What this function returns is an expression for
2175    that value.  */
2176
2177 tree
2178 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2179      tree *op0_ptr, *op1_ptr;
2180      tree *restype_ptr;
2181      enum tree_code *rescode_ptr;
2182 {
2183   register tree type;
2184   tree op0 = *op0_ptr;
2185   tree op1 = *op1_ptr;
2186   int unsignedp0, unsignedp1;
2187   int real1, real2;
2188   tree primop0, primop1;
2189   enum tree_code code = *rescode_ptr;
2190
2191   /* Throw away any conversions to wider types
2192      already present in the operands.  */
2193
2194   primop0 = get_narrower (op0, &unsignedp0);
2195   primop1 = get_narrower (op1, &unsignedp1);
2196
2197   /* Handle the case that OP0 does not *contain* a conversion
2198      but it *requires* conversion to FINAL_TYPE.  */
2199
2200   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2201     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2202   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2203     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2204
2205   /* If one of the operands must be floated, we cannot optimize.  */
2206   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2207   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2208
2209   /* If first arg is constant, swap the args (changing operation
2210      so value is preserved), for canonicalization.  Don't do this if
2211      the second arg is 0.  */
2212
2213   if (TREE_CONSTANT (primop0)
2214       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2215     {
2216       register tree tem = primop0;
2217       register int temi = unsignedp0;
2218       primop0 = primop1;
2219       primop1 = tem;
2220       tem = op0;
2221       op0 = op1;
2222       op1 = tem;
2223       *op0_ptr = op0;
2224       *op1_ptr = op1;
2225       unsignedp0 = unsignedp1;
2226       unsignedp1 = temi;
2227       temi = real1;
2228       real1 = real2;
2229       real2 = temi;
2230
2231       switch (code)
2232         {
2233         case LT_EXPR:
2234           code = GT_EXPR;
2235           break;
2236         case GT_EXPR:
2237           code = LT_EXPR;
2238           break;
2239         case LE_EXPR:
2240           code = GE_EXPR;
2241           break;
2242         case GE_EXPR:
2243           code = LE_EXPR;
2244           break;
2245         default:
2246           break;
2247         }
2248       *rescode_ptr = code;
2249     }
2250
2251   /* If comparing an integer against a constant more bits wide,
2252      maybe we can deduce a value of 1 or 0 independent of the data.
2253      Or else truncate the constant now
2254      rather than extend the variable at run time.
2255
2256      This is only interesting if the constant is the wider arg.
2257      Also, it is not safe if the constant is unsigned and the
2258      variable arg is signed, since in this case the variable
2259      would be sign-extended and then regarded as unsigned.
2260      Our technique fails in this case because the lowest/highest
2261      possible unsigned results don't follow naturally from the
2262      lowest/highest possible values of the variable operand.
2263      For just EQ_EXPR and NE_EXPR there is another technique that
2264      could be used: see if the constant can be faithfully represented
2265      in the other operand's type, by truncating it and reextending it
2266      and see if that preserves the constant's value.  */
2267
2268   if (!real1 && !real2
2269       && TREE_CODE (primop1) == INTEGER_CST
2270       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2271     {
2272       int min_gt, max_gt, min_lt, max_lt;
2273       tree maxval, minval;
2274       /* 1 if comparison is nominally unsigned.  */
2275       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2276       tree val;
2277
2278       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2279
2280       /* If TYPE is an enumeration, then we need to get its min/max
2281          values from it's underlying integral type, not the enumerated
2282          type itself.  */
2283       if (TREE_CODE (type) == ENUMERAL_TYPE)
2284         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
2285
2286       maxval = TYPE_MAX_VALUE (type);
2287       minval = TYPE_MIN_VALUE (type);
2288
2289       if (unsignedp && !unsignedp0)
2290         *restype_ptr = signed_type (*restype_ptr);
2291
2292       if (TREE_TYPE (primop1) != *restype_ptr)
2293         primop1 = convert (*restype_ptr, primop1);
2294       if (type != *restype_ptr)
2295         {
2296           minval = convert (*restype_ptr, minval);
2297           maxval = convert (*restype_ptr, maxval);
2298         }
2299
2300       if (unsignedp && unsignedp0)
2301         {
2302           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2303           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2304           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2305           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2306         }
2307       else
2308         {
2309           min_gt = INT_CST_LT (primop1, minval);
2310           max_gt = INT_CST_LT (primop1, maxval);
2311           min_lt = INT_CST_LT (minval, primop1);
2312           max_lt = INT_CST_LT (maxval, primop1);
2313         }
2314
2315       val = 0;
2316       /* This used to be a switch, but Genix compiler can't handle that.  */
2317       if (code == NE_EXPR)
2318         {
2319           if (max_lt || min_gt)
2320             val = boolean_true_node;
2321         }
2322       else if (code == EQ_EXPR)
2323         {
2324           if (max_lt || min_gt)
2325             val = boolean_false_node;
2326         }
2327       else if (code == LT_EXPR)
2328         {
2329           if (max_lt)
2330             val = boolean_true_node;
2331           if (!min_lt)
2332             val = boolean_false_node;
2333         }
2334       else if (code == GT_EXPR)
2335         {
2336           if (min_gt)
2337             val = boolean_true_node;
2338           if (!max_gt)
2339             val = boolean_false_node;
2340         }
2341       else if (code == LE_EXPR)
2342         {
2343           if (!max_gt)
2344             val = boolean_true_node;
2345           if (min_gt)
2346             val = boolean_false_node;
2347         }
2348       else if (code == GE_EXPR)
2349         {
2350           if (!min_lt)
2351             val = boolean_true_node;
2352           if (max_lt)
2353             val = boolean_false_node;
2354         }
2355
2356       /* If primop0 was sign-extended and unsigned comparison specd,
2357          we did a signed comparison above using the signed type bounds.
2358          But the comparison we output must be unsigned.
2359
2360          Also, for inequalities, VAL is no good; but if the signed
2361          comparison had *any* fixed result, it follows that the
2362          unsigned comparison just tests the sign in reverse
2363          (positive values are LE, negative ones GE).
2364          So we can generate an unsigned comparison
2365          against an extreme value of the signed type.  */
2366
2367       if (unsignedp && !unsignedp0)
2368         {
2369           if (val != 0)
2370             switch (code)
2371               {
2372               case LT_EXPR:
2373               case GE_EXPR:
2374                 primop1 = TYPE_MIN_VALUE (type);
2375                 val = 0;
2376                 break;
2377
2378               case LE_EXPR:
2379               case GT_EXPR:
2380                 primop1 = TYPE_MAX_VALUE (type);
2381                 val = 0;
2382                 break;
2383
2384               default:
2385                 break;
2386               }
2387           type = unsigned_type (type);
2388         }
2389
2390       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2391         {
2392           /* This is the case of (char)x >?< 0x80, which people used to use
2393              expecting old C compilers to change the 0x80 into -0x80.  */
2394           if (val == boolean_false_node)
2395             warning ("comparison is always false due to limited range of data type");
2396           if (val == boolean_true_node)
2397             warning ("comparison is always true due to limited range of data type");
2398         }
2399
2400       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2401         {
2402           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2403           if (val == boolean_false_node)
2404             warning ("comparison is always false due to limited range of data type");
2405           if (val == boolean_true_node)
2406             warning ("comparison is always true due to limited range of data type");
2407         }
2408
2409       if (val != 0)
2410         {
2411           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2412           if (TREE_SIDE_EFFECTS (primop0))
2413             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2414           return val;
2415         }
2416
2417       /* Value is not predetermined, but do the comparison
2418          in the type of the operand that is not constant.
2419          TYPE is already properly set.  */
2420     }
2421   else if (real1 && real2
2422            && (TYPE_PRECISION (TREE_TYPE (primop0))
2423                == TYPE_PRECISION (TREE_TYPE (primop1))))
2424     type = TREE_TYPE (primop0);
2425
2426   /* If args' natural types are both narrower than nominal type
2427      and both extend in the same manner, compare them
2428      in the type of the wider arg.
2429      Otherwise must actually extend both to the nominal
2430      common type lest different ways of extending
2431      alter the result.
2432      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2433
2434   else if (unsignedp0 == unsignedp1 && real1 == real2
2435            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2436            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2437     {
2438       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2439       type = signed_or_unsigned_type (unsignedp0
2440                                       || TREE_UNSIGNED (*restype_ptr),
2441                                       type);
2442       /* Make sure shorter operand is extended the right way
2443          to match the longer operand.  */
2444       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2445                          primop0);
2446       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2447                          primop1);
2448     }
2449   else
2450     {
2451       /* Here we must do the comparison on the nominal type
2452          using the args exactly as we received them.  */
2453       type = *restype_ptr;
2454       primop0 = op0;
2455       primop1 = op1;
2456
2457       if (!real1 && !real2 && integer_zerop (primop1)
2458           && TREE_UNSIGNED (*restype_ptr))
2459         {
2460           tree value = 0;
2461           switch (code)
2462             {
2463             case GE_EXPR:
2464               /* All unsigned values are >= 0, so we warn if extra warnings
2465                  are requested.  However, if OP0 is a constant that is
2466                  >= 0, the signedness of the comparison isn't an issue,
2467                  so suppress the warning.  */
2468               if (extra_warnings && !in_system_header
2469                   && ! (TREE_CODE (primop0) == INTEGER_CST
2470                         && ! TREE_OVERFLOW (convert (signed_type (type),
2471                                                      primop0))))
2472                 warning ("comparison of unsigned expression >= 0 is always true");
2473               value = boolean_true_node;
2474               break;
2475
2476             case LT_EXPR:
2477               if (extra_warnings && !in_system_header
2478                   && ! (TREE_CODE (primop0) == INTEGER_CST
2479                         && ! TREE_OVERFLOW (convert (signed_type (type),
2480                                                      primop0))))
2481                 warning ("comparison of unsigned expression < 0 is always false");
2482               value = boolean_false_node;
2483               break;
2484
2485             default:
2486               break;
2487             }
2488
2489           if (value != 0)
2490             {
2491               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2492               if (TREE_SIDE_EFFECTS (primop0))
2493                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2494                               primop0, value);
2495               return value;
2496             }
2497         }
2498     }
2499
2500   *op0_ptr = convert (type, primop0);
2501   *op1_ptr = convert (type, primop1);
2502
2503   *restype_ptr = boolean_type_node;
2504
2505   return 0;
2506 }
2507 \f
2508 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2509    or validate its data type for an `if' or `while' statement or ?..: exp.
2510
2511    This preparation consists of taking the ordinary
2512    representation of an expression expr and producing a valid tree
2513    boolean expression describing whether expr is nonzero.  We could
2514    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2515    but we optimize comparisons, &&, ||, and !.
2516
2517    The resulting type should always be `boolean_type_node'.  */
2518
2519 tree
2520 truthvalue_conversion (expr)
2521      tree expr;
2522 {
2523   if (TREE_CODE (expr) == ERROR_MARK)
2524     return expr;
2525
2526 #if 0 /* This appears to be wrong for C++.  */
2527   /* These really should return error_mark_node after 2.4 is stable.
2528      But not all callers handle ERROR_MARK properly.  */
2529   switch (TREE_CODE (TREE_TYPE (expr)))
2530     {
2531     case RECORD_TYPE:
2532       error ("struct type value used where scalar is required");
2533       return boolean_false_node;
2534
2535     case UNION_TYPE:
2536       error ("union type value used where scalar is required");
2537       return boolean_false_node;
2538
2539     case ARRAY_TYPE:
2540       error ("array type value used where scalar is required");
2541       return boolean_false_node;
2542
2543     default:
2544       break;
2545     }
2546 #endif /* 0 */
2547
2548   switch (TREE_CODE (expr))
2549     {
2550     case EQ_EXPR:
2551     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2552     case TRUTH_ANDIF_EXPR:
2553     case TRUTH_ORIF_EXPR:
2554     case TRUTH_AND_EXPR:
2555     case TRUTH_OR_EXPR:
2556     case TRUTH_XOR_EXPR:
2557     case TRUTH_NOT_EXPR:
2558       TREE_TYPE (expr) = boolean_type_node;
2559       return expr;
2560
2561     case ERROR_MARK:
2562       return expr;
2563
2564     case INTEGER_CST:
2565       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2566
2567     case REAL_CST:
2568       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2569
2570     case ADDR_EXPR:
2571       /* If we are taking the address of a external decl, it might be zero
2572          if it is weak, so we cannot optimize.  */
2573       if (DECL_P (TREE_OPERAND (expr, 0))
2574           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2575         break;
2576
2577       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2578         return build (COMPOUND_EXPR, boolean_type_node,
2579                       TREE_OPERAND (expr, 0), boolean_true_node);
2580       else
2581         return boolean_true_node;
2582
2583     case COMPLEX_EXPR:
2584       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2585                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2586                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2587                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2588                               0);
2589
2590     case NEGATE_EXPR:
2591     case ABS_EXPR:
2592     case FLOAT_EXPR:
2593     case FFS_EXPR:
2594       /* These don't change whether an object is non-zero or zero.  */
2595       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2596
2597     case LROTATE_EXPR:
2598     case RROTATE_EXPR:
2599       /* These don't change whether an object is zero or non-zero, but
2600          we can't ignore them if their second arg has side-effects.  */
2601       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2602         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2603                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2604       else
2605         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2606
2607     case COND_EXPR:
2608       /* Distribute the conversion into the arms of a COND_EXPR.  */
2609       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2610                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2611                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2612
2613     case CONVERT_EXPR:
2614       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2615          since that affects how `default_conversion' will behave.  */
2616       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2617           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2618         break;
2619       /* fall through...  */
2620     case NOP_EXPR:
2621       /* If this is widening the argument, we can ignore it.  */
2622       if (TYPE_PRECISION (TREE_TYPE (expr))
2623           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2624         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2625       break;
2626
2627     case MINUS_EXPR:
2628       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2629          this case.  */
2630       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2631           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2632         break;
2633       /* fall through...  */
2634     case BIT_XOR_EXPR:
2635       /* This and MINUS_EXPR can be changed into a comparison of the
2636          two objects.  */
2637       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2638           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2639         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2640                                 TREE_OPERAND (expr, 1), 1);
2641       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2642                               fold (build1 (NOP_EXPR,
2643                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2644                                             TREE_OPERAND (expr, 1))), 1);
2645
2646     case BIT_AND_EXPR:
2647       if (integer_onep (TREE_OPERAND (expr, 1))
2648           && TREE_TYPE (expr) != boolean_type_node)
2649         /* Using convert here would cause infinite recursion.  */
2650         return build1 (NOP_EXPR, boolean_type_node, expr);
2651       break;
2652
2653     case MODIFY_EXPR:
2654       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2655         warning ("suggest parentheses around assignment used as truth value");
2656       break;
2657
2658     default:
2659       break;
2660     }
2661
2662   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2663     {
2664       tree tem = save_expr (expr);
2665       return (build_binary_op
2666               ((TREE_SIDE_EFFECTS (expr)
2667                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2668                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2669                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2670                0));
2671     }
2672
2673   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2674 }
2675 \f
2676 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2677                                         int, enum built_in_class, int, int,
2678                                         int));
2679
2680 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2681    down to the element type of an array.  */
2682
2683 tree
2684 c_build_qualified_type (type, type_quals)
2685      tree type;
2686      int type_quals;
2687 {
2688   /* A restrict-qualified pointer type must be a pointer to object or
2689      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2690      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
2691      the C++ front-end also use POINTER_TYPE for pointer-to-member
2692      values, so even though it should be illegal to use `restrict'
2693      with such an entity we don't flag that here.  Thus, special case
2694      code for that case is required in the C++ front-end.  */
2695   if ((type_quals & TYPE_QUAL_RESTRICT)
2696       && (!POINTER_TYPE_P (type)
2697           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2698     {
2699       error ("invalid use of `restrict'");
2700       type_quals &= ~TYPE_QUAL_RESTRICT;
2701     }
2702
2703   if (TREE_CODE (type) == ARRAY_TYPE)
2704     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2705                                                      type_quals),
2706                              TYPE_DOMAIN (type));
2707   return build_qualified_type (type, type_quals);
2708 }
2709
2710 /* Apply the TYPE_QUALS to the new DECL.  */
2711
2712 void
2713 c_apply_type_quals_to_decl (type_quals, decl)
2714      int type_quals;
2715      tree decl;
2716 {
2717   if ((type_quals & TYPE_QUAL_CONST)
2718       || (TREE_TYPE (decl)
2719           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2720     TREE_READONLY (decl) = 1;
2721   if (type_quals & TYPE_QUAL_VOLATILE)
2722     {
2723       TREE_SIDE_EFFECTS (decl) = 1;
2724       TREE_THIS_VOLATILE (decl) = 1;
2725     }
2726   if (type_quals & TYPE_QUAL_RESTRICT)
2727     {
2728       if (!TREE_TYPE (decl)
2729           || !POINTER_TYPE_P (TREE_TYPE (decl))
2730           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2731         error ("invalid use of `restrict'");
2732       else if (flag_strict_aliasing)
2733         {
2734           /* No two restricted pointers can point at the same thing.
2735              However, a restricted pointer can point at the same thing
2736              as an unrestricted pointer, if that unrestricted pointer
2737              is based on the restricted pointer.  So, we make the
2738              alias set for the restricted pointer a subset of the
2739              alias set for the type pointed to by the type of the
2740              decl.  */
2741
2742           HOST_WIDE_INT pointed_to_alias_set
2743             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
2744
2745           if (pointed_to_alias_set == 0)
2746             /* It's not legal to make a subset of alias set zero.  */
2747             ;
2748           else
2749             {
2750               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
2751               record_alias_subset  (pointed_to_alias_set,
2752                                     DECL_POINTER_ALIAS_SET (decl));
2753             }
2754         }
2755     }
2756 }
2757
2758
2759 /* Return the typed-based alias set for T, which may be an expression
2760    or a type.  Return -1 if we don't do anything special.  */
2761
2762 HOST_WIDE_INT
2763 lang_get_alias_set (t)
2764      tree t;
2765 {
2766   tree u;
2767
2768   /* We know nothing about vector types */
2769   if (TREE_CODE (t) == VECTOR_TYPE)
2770     return 0;
2771
2772   /* Permit type-punning when accessing a union, provided the access
2773      is directly through the union.  For example, this code does not
2774      permit taking the address of a union member and then storing
2775      through it.  Even the type-punning allowed here is a GCC
2776      extension, albeit a common and useful one; the C standard says
2777      that such accesses have implementation-defined behavior.  */
2778   for (u = t;
2779        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2780        u = TREE_OPERAND (u, 0))
2781     if (TREE_CODE (u) == COMPONENT_REF
2782         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2783       return 0;
2784
2785   /* If this is a char *, the ANSI C standard says it can alias
2786      anything.  Note that all references need do this.  */
2787   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2788       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2789       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2790     return 0;
2791
2792   /* That's all the expressions we handle specially.  */
2793   if (! TYPE_P (t))
2794     return -1;
2795
2796   /* The C standard specifically allows aliasing between signed and
2797      unsigned variants of the same type.  We treat the signed
2798      variant as canonical.  */
2799   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2800     {
2801       tree t1 = signed_type (t);
2802
2803       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2804       if (t1 != t)
2805         return get_alias_set (t1);
2806     }
2807   else if (POINTER_TYPE_P (t))
2808     {
2809       tree t1;
2810
2811       /* Unfortunately, there is no canonical form of a pointer type.
2812          In particular, if we have `typedef int I', then `int *', and
2813          `I *' are different types.  So, we have to pick a canonical
2814          representative.  We do this below.
2815
2816          Technically, this approach is actually more conservative that
2817          it needs to be.  In particular, `const int *' and `int *'
2818          chould be in different alias sets, according to the C and C++
2819          standard, since their types are not the same, and so,
2820          technically, an `int **' and `const int **' cannot point at
2821          the same thing.
2822
2823          But, the standard is wrong.  In particular, this code is
2824          legal C++:
2825
2826             int *ip;
2827             int **ipp = &ip;
2828             const int* const* cipp = &ipp;
2829
2830          And, it doesn't make sense for that to be legal unless you
2831          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2832          the pointed-to types.  This issue has been reported to the
2833          C++ committee.  */
2834       t1 = build_type_no_quals (t);
2835       if (t1 != t)
2836         return get_alias_set (t1);
2837     }
2838   /* It's not yet safe to use alias sets for classes in C++ because
2839      the TYPE_FIELDs list for a class doesn't mention base classes.  */
2840   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
2841     return 0;
2842
2843   return -1;
2844 }
2845
2846 /* Build tree nodes and builtin functions common to both C and C++ language
2847    frontends.  */
2848
2849 void
2850 c_common_nodes_and_builtins ()
2851 {
2852   enum builtin_type
2853   {
2854 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2855 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2856 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2857 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2858 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2859 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2860 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2861 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2862 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2863 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2864 #include "builtin-types.def"
2865 #undef DEF_PRIMITIVE_TYPE
2866 #undef DEF_FUNCTION_TYPE_0
2867 #undef DEF_FUNCTION_TYPE_1
2868 #undef DEF_FUNCTION_TYPE_2
2869 #undef DEF_FUNCTION_TYPE_3
2870 #undef DEF_FUNCTION_TYPE_4
2871 #undef DEF_FUNCTION_TYPE_VAR_0
2872 #undef DEF_FUNCTION_TYPE_VAR_1
2873 #undef DEF_FUNCTION_TYPE_VAR_2
2874 #undef DEF_POINTER_TYPE
2875     BT_LAST
2876   };
2877
2878   typedef enum builtin_type builtin_type;
2879
2880   tree builtin_types[(int)BT_LAST];
2881   int wchar_type_size;
2882   tree array_domain_type;
2883   /* Either char* or void*.  */
2884   tree traditional_ptr_type_node;
2885   /* Either const char* or const void*.  */
2886   tree traditional_cptr_type_node;
2887   tree traditional_len_type_node;
2888   tree va_list_ref_type_node;
2889   tree va_list_arg_type_node;
2890
2891   /* Define `int' and `char' first so that dbx will output them first.  */
2892   record_builtin_type (RID_INT, NULL, integer_type_node);
2893   record_builtin_type (RID_CHAR, "char", char_type_node);
2894
2895   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2896      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2897      but not C.  Are the conditionals here needed?  */
2898   if (c_language == clk_cplusplus)
2899     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2900   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2901   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2902   record_builtin_type (RID_MAX, "long unsigned int",
2903                        long_unsigned_type_node);
2904   if (c_language == clk_cplusplus)
2905     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2906   record_builtin_type (RID_MAX, "long long int",
2907                        long_long_integer_type_node);
2908   record_builtin_type (RID_MAX, "long long unsigned int",
2909                        long_long_unsigned_type_node);
2910   if (c_language == clk_cplusplus)
2911     record_builtin_type (RID_MAX, "long long unsigned",
2912                          long_long_unsigned_type_node);
2913   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2914   record_builtin_type (RID_MAX, "short unsigned int",
2915                        short_unsigned_type_node);
2916   if (c_language == clk_cplusplus)
2917     record_builtin_type (RID_MAX, "unsigned short",
2918                          short_unsigned_type_node);
2919
2920   /* Define both `signed char' and `unsigned char'.  */
2921   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2922   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2923
2924   /* These are types that type_for_size and type_for_mode use.  */
2925   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2926   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2927   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2928   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2929 #if HOST_BITS_PER_WIDE_INT >= 64
2930   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2931 #endif
2932   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2933   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2934   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2935   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2936 #if HOST_BITS_PER_WIDE_INT >= 64
2937   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2938 #endif
2939
2940   /* Create the widest literal types.  */
2941   widest_integer_literal_type_node
2942     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2943   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2944                         widest_integer_literal_type_node));
2945
2946   widest_unsigned_literal_type_node
2947     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2948   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2949                         widest_unsigned_literal_type_node));
2950
2951   /* `unsigned long' is the standard type for sizeof.
2952      Note that stddef.h uses `unsigned long',
2953      and this must agree, even if long and int are the same size.  */
2954   c_size_type_node =
2955     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2956   signed_size_type_node = signed_type (c_size_type_node);
2957   if (flag_traditional)
2958     c_size_type_node = signed_size_type_node;
2959   set_sizetype (c_size_type_node);
2960
2961   build_common_tree_nodes_2 (flag_short_double);
2962
2963   record_builtin_type (RID_FLOAT, NULL, float_type_node);
2964   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2965   record_builtin_type (RID_MAX, "long double", long_double_type_node);
2966
2967   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2968                         complex_integer_type_node));
2969   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2970                         complex_float_type_node));
2971   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2972                         complex_double_type_node));
2973   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2974                         complex_long_double_type_node));
2975
2976   record_builtin_type (RID_VOID, NULL, void_type_node);
2977
2978   void_zero_node = build_int_2 (0, 0);
2979   TREE_TYPE (void_zero_node) = void_type_node;
2980
2981   void_list_node = build_void_list_node ();
2982
2983   /* Make a type to be the domain of a few array types
2984      whose domains don't really matter.
2985      200 is small enough that it always fits in size_t
2986      and large enough that it can hold most function names for the
2987      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
2988   array_domain_type = build_index_type (size_int (200));
2989
2990   /* Make a type for arrays of characters.
2991      With luck nothing will ever really depend on the length of this
2992      array type.  */
2993   char_array_type_node
2994     = build_array_type (char_type_node, array_domain_type);
2995
2996   /* Likewise for arrays of ints.  */
2997   int_array_type_node
2998     = build_array_type (integer_type_node, array_domain_type);
2999
3000   string_type_node = build_pointer_type (char_type_node);
3001   const_string_type_node
3002     = build_pointer_type (build_qualified_type
3003                           (char_type_node, TYPE_QUAL_CONST));
3004
3005   traditional_ptr_type_node = ((flag_traditional &&
3006                                 c_language != clk_cplusplus)
3007                                ? string_type_node : ptr_type_node);
3008   traditional_cptr_type_node = ((flag_traditional &&
3009                                  c_language != clk_cplusplus)
3010                                ? const_string_type_node : const_ptr_type_node);
3011
3012   MD_INIT_BUILTINS;
3013
3014   /* This is special for C++ so functions can be overloaded.  */
3015   wchar_type_node = get_identifier (flag_short_wchar
3016                                     ? "short unsigned int"
3017                                     : WCHAR_TYPE);
3018   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3019   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3020   if (c_language == clk_cplusplus)
3021     {
3022       if (TREE_UNSIGNED (wchar_type_node))
3023         wchar_type_node = make_unsigned_type (wchar_type_size);
3024       else
3025         wchar_type_node = make_signed_type (wchar_type_size);
3026       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3027     }
3028   else
3029     {
3030       signed_wchar_type_node = signed_type (wchar_type_node);
3031       unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3032     }
3033
3034   /* This is for wide string constants.  */
3035   wchar_array_type_node
3036     = build_array_type (wchar_type_node, array_domain_type);
3037
3038   wint_type_node =
3039     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3040
3041   intmax_type_node =
3042     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3043   uintmax_type_node =
3044     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3045
3046   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3047   ptrdiff_type_node
3048     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3049   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
3050
3051   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3052                         va_list_type_node));
3053
3054   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3055                         ptrdiff_type_node));
3056
3057   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3058                         sizetype));
3059
3060   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3061     {
3062       va_list_arg_type_node = va_list_ref_type_node =
3063         build_pointer_type (TREE_TYPE (va_list_type_node));
3064     }
3065   else
3066     {
3067       va_list_arg_type_node = va_list_type_node;
3068       va_list_ref_type_node = build_reference_type (va_list_type_node);
3069     }
3070
3071   traditional_len_type_node = ((flag_traditional &&
3072                                 c_language != clk_cplusplus)
3073                                ? integer_type_node : sizetype);
3074
3075 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3076   builtin_types[(int) ENUM] = VALUE;
3077 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3078   builtin_types[(int) ENUM]                             \
3079     = build_function_type (builtin_types[(int) RETURN], \
3080                            void_list_node);
3081 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3082   builtin_types[(int) ENUM]                                             \
3083     = build_function_type (builtin_types[(int) RETURN],                 \
3084                            tree_cons (NULL_TREE,                        \
3085                                       builtin_types[(int) ARG1],        \
3086                                       void_list_node));
3087 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3088   builtin_types[(int) ENUM]                             \
3089     = build_function_type                               \
3090       (builtin_types[(int) RETURN],                     \
3091        tree_cons (NULL_TREE,                            \
3092                   builtin_types[(int) ARG1],            \
3093                   tree_cons (NULL_TREE,                 \
3094                              builtin_types[(int) ARG2], \
3095                              void_list_node)));
3096 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3097   builtin_types[(int) ENUM]                                              \
3098     = build_function_type                                                \
3099       (builtin_types[(int) RETURN],                                      \
3100        tree_cons (NULL_TREE,                                             \
3101                   builtin_types[(int) ARG1],                             \
3102                   tree_cons (NULL_TREE,                                  \
3103                              builtin_types[(int) ARG2],                  \
3104                              tree_cons (NULL_TREE,                       \
3105                                         builtin_types[(int) ARG3],       \
3106                                         void_list_node))));
3107 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3108   builtin_types[(int) ENUM]                                             \
3109     = build_function_type                                               \
3110       (builtin_types[(int) RETURN],                                     \
3111        tree_cons (NULL_TREE,                                            \
3112                   builtin_types[(int) ARG1],                            \
3113                   tree_cons (NULL_TREE,                                 \
3114                              builtin_types[(int) ARG2],                 \
3115                              tree_cons                                  \
3116                              (NULL_TREE,                                \
3117                               builtin_types[(int) ARG3],                \
3118                               tree_cons (NULL_TREE,                     \
3119                                          builtin_types[(int) ARG4],     \
3120                                          void_list_node)))));
3121 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3122   builtin_types[(int) ENUM]                                             \
3123     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3124 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3125    builtin_types[(int) ENUM]                                             \
3126     = build_function_type (builtin_types[(int) RETURN],                  \
3127                            tree_cons (NULL_TREE,                         \
3128                                       builtin_types[(int) ARG1],         \
3129                                       NULL_TREE));
3130
3131 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3132    builtin_types[(int) ENUM]                                    \
3133     = build_function_type                                       \
3134       (builtin_types[(int) RETURN],                             \
3135        tree_cons (NULL_TREE,                                    \
3136                   builtin_types[(int) ARG1],                    \
3137                   tree_cons (NULL_TREE,                         \
3138                              builtin_types[(int) ARG2],         \
3139                              NULL_TREE)));
3140 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3141   builtin_types[(int) ENUM]                             \
3142     = build_pointer_type (builtin_types[(int) TYPE]);
3143 #include "builtin-types.def"
3144 #undef DEF_PRIMITIVE_TYPE
3145 #undef DEF_FUNCTION_TYPE_1
3146 #undef DEF_FUNCTION_TYPE_2
3147 #undef DEF_FUNCTION_TYPE_3
3148 #undef DEF_FUNCTION_TYPE_4
3149 #undef DEF_FUNCTION_TYPE_VAR_0
3150 #undef DEF_FUNCTION_TYPE_VAR_1
3151 #undef DEF_POINTER_TYPE
3152
3153 #define DEF_BUILTIN(ENUM, NAME, CLASS,                                  \
3154                     TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P)       \
3155   if (NAME)                                                             \
3156     {                                                                   \
3157       tree decl;                                                        \
3158                                                                         \
3159       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
3160         abort ();                                                       \
3161                                                                         \
3162       if (!BOTH_P)                                                      \
3163         decl = builtin_function (NAME, builtin_types[TYPE], ENUM,       \
3164                                  CLASS,                                 \
3165                                  (FALLBACK_P                            \
3166                                   ? (NAME + strlen ("__builtin_"))      \
3167                                   : NULL));                             \
3168       else                                                              \
3169         decl = builtin_function_2 (NAME,                                \
3170                                    NAME + strlen ("__builtin_"),        \
3171                                    builtin_types[TYPE],                 \
3172                                    builtin_types[LIBTYPE],              \
3173                                    ENUM,                                \
3174                                    CLASS,                               \
3175                                    FALLBACK_P,                          \
3176                                    NONANSI_P,                           \
3177                                    /*noreturn_p=*/0);                   \
3178                                                                         \
3179       built_in_decls[(int) ENUM] = decl;                                \
3180     }
3181 #include "builtins.def"
3182 #undef DEF_BUILTIN
3183
3184   /* Declare _exit and _Exit just to mark them as non-returning.  */
3185   builtin_function_2 (NULL, "_exit", NULL_TREE,
3186                       builtin_types[BT_FN_VOID_INT],
3187                       0, NOT_BUILT_IN, 0, 1, 1);
3188   builtin_function_2 (NULL, "_Exit", NULL_TREE,
3189                       builtin_types[BT_FN_VOID_INT],
3190                       0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
3191
3192   /* Declare these functions non-returning
3193      to avoid spurious "control drops through" warnings.  */
3194   builtin_function_2 (NULL, "abort",
3195                       NULL_TREE, ((c_language == clk_cplusplus)
3196                                   ? builtin_types[BT_FN_VOID]
3197                                   : builtin_types[BT_FN_VOID_VAR]),
3198                       0, NOT_BUILT_IN, 0, 0, 1);
3199
3200   builtin_function_2 (NULL, "exit",
3201                       NULL_TREE, ((c_language == clk_cplusplus)
3202                                   ? builtin_types[BT_FN_VOID_INT]
3203                                   : builtin_types[BT_FN_VOID_VAR]),
3204                       0, NOT_BUILT_IN, 0, 0, 1);
3205
3206   main_identifier_node = get_identifier ("main");
3207
3208   /* ??? Perhaps there's a better place to do this.  But it is related
3209      to __builtin_va_arg, so it isn't that off-the-wall.  */
3210   lang_type_promotes_to = simple_type_promotes_to;
3211 }
3212
3213 tree
3214 build_va_arg (expr, type)
3215      tree expr, type;
3216 {
3217   return build1 (VA_ARG_EXPR, type, expr);
3218 }
3219
3220
3221 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3222    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3223    of these may be NULL (though both being NULL is useless).
3224    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3225    TYPE is the type of the function with the ordinary name.  These
3226    may differ if the ordinary name is declared with a looser type to avoid
3227    conflicts with headers.  FUNCTION_CODE and CLASS are as for
3228    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3229    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3230    If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3231    NORETURN_P is nonzero, the function is marked as non-returning.
3232    Returns the declaration of BUILTIN_NAME, if any, otherwise
3233    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3234    or if NONANSI_P and flag_no_nonansi_builtin.  */
3235
3236 static tree
3237 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3238                     class, library_name_p, nonansi_p, noreturn_p)
3239      const char *builtin_name;
3240      const char *name;
3241      tree builtin_type;
3242      tree type;
3243      int function_code;
3244      enum built_in_class class;
3245      int library_name_p;
3246      int nonansi_p;
3247      int noreturn_p;
3248 {
3249   tree bdecl = NULL_TREE;
3250   tree decl = NULL_TREE;
3251   if (builtin_name != 0)
3252     {
3253       bdecl = builtin_function (builtin_name, builtin_type, function_code,
3254                                 class, library_name_p ? name : NULL);
3255       if (noreturn_p)
3256         {
3257           TREE_THIS_VOLATILE (bdecl) = 1;
3258           TREE_SIDE_EFFECTS (bdecl) = 1;
3259         }
3260     }
3261   if (name != 0 && !flag_no_builtin && !(nonansi_p && flag_no_nonansi_builtin))
3262     {
3263       decl = builtin_function (name, type, function_code, class, NULL);
3264       if (nonansi_p)
3265         DECL_BUILT_IN_NONANSI (decl) = 1;
3266       if (noreturn_p)
3267         {
3268           TREE_THIS_VOLATILE (decl) = 1;
3269           TREE_SIDE_EFFECTS (decl) = 1;
3270         }
3271     }
3272   return (bdecl != 0 ? bdecl : decl);
3273 }
3274 \f
3275 /* Nonzero if the type T promotes to int.  This is (nearly) the
3276    integral promotions defined in ISO C99 6.3.1.1/2.  */
3277
3278 bool
3279 c_promoting_integer_type_p (t)
3280      tree t;
3281 {
3282   switch (TREE_CODE (t))
3283     {
3284     case INTEGER_TYPE:
3285       return (TYPE_MAIN_VARIANT (t) == char_type_node
3286               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3287               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3288               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3289               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node);
3290
3291     case ENUMERAL_TYPE:
3292       /* ??? Technically all enumerations not larger than an int
3293          promote to an int.  But this is used along code paths
3294          that only want to notice a size change.  */
3295       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3296
3297     case BOOLEAN_TYPE:
3298       return 1;
3299
3300     default:
3301       return 0;
3302     }
3303 }
3304
3305 /* Given a type, apply default promotions wrt unnamed function arguments
3306    and return the new type.  Return NULL_TREE if no change.  */
3307 /* ??? There is a function of the same name in the C++ front end that
3308    does something similar, but is more thorough and does not return NULL
3309    if no change.  We could perhaps share code, but it would make the
3310    self_promoting_type property harder to identify.  */
3311
3312 tree
3313 simple_type_promotes_to (type)
3314      tree type;
3315 {
3316   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3317     return double_type_node;
3318
3319   if (c_promoting_integer_type_p (type))
3320     {
3321       /* Traditionally, unsignedness is preserved in default promotions.
3322          Also preserve unsignedness if not really getting any wider.  */
3323       if (TREE_UNSIGNED (type)
3324           && (flag_traditional
3325               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3326         return unsigned_type_node;
3327       return integer_type_node;
3328     }
3329
3330   return NULL_TREE;
3331 }
3332
3333 /* Return 1 if PARMS specifies a fixed number of parameters
3334    and none of their types is affected by default promotions.  */
3335
3336 int
3337 self_promoting_args_p (parms)
3338      tree parms;
3339 {
3340   register tree t;
3341   for (t = parms; t; t = TREE_CHAIN (t))
3342     {
3343       register tree type = TREE_VALUE (t);
3344
3345       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3346         return 0;
3347
3348       if (type == 0)
3349         return 0;
3350
3351       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3352         return 0;
3353
3354       if (c_promoting_integer_type_p (type))
3355         return 0;
3356     }
3357   return 1;
3358 }
3359
3360 /* Recursively examines the array elements of TYPE, until a non-array
3361    element type is found.  */
3362
3363 tree
3364 strip_array_types (type)
3365      tree type;
3366 {
3367   while (TREE_CODE (type) == ARRAY_TYPE)
3368     type = TREE_TYPE (type);
3369
3370   return type;
3371 }
3372
3373 /* Recognize certain built-in functions so we can make tree-codes
3374    other than CALL_EXPR.  We do this when it enables fold-const.c
3375    to do something useful.  */
3376 /* ??? By rights this should go in builtins.c, but only C and C++
3377    implement build_{binary,unary}_op.  Not exactly sure what bits
3378    of functionality are actually needed from those functions, or
3379    where the similar functionality exists in the other front ends.  */
3380
3381 tree
3382 expand_tree_builtin (function, params, coerced_params)
3383      tree function, params, coerced_params;
3384 {
3385   enum tree_code code;
3386
3387   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3388     return NULL_TREE;
3389
3390   switch (DECL_FUNCTION_CODE (function))
3391     {
3392     case BUILT_IN_ABS:
3393     case BUILT_IN_LABS:
3394     case BUILT_IN_LLABS:
3395     case BUILT_IN_IMAXABS:
3396     case BUILT_IN_FABS:
3397     case BUILT_IN_FABSL:
3398     case BUILT_IN_FABSF:
3399       if (coerced_params == 0)
3400         return integer_zero_node;
3401       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3402
3403     case BUILT_IN_CONJ:
3404     case BUILT_IN_CONJF:
3405     case BUILT_IN_CONJL:
3406       if (coerced_params == 0)
3407         return integer_zero_node;
3408       return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3409
3410     case BUILT_IN_CREAL:
3411     case BUILT_IN_CREALF:
3412     case BUILT_IN_CREALL:
3413       if (coerced_params == 0)
3414         return integer_zero_node;
3415       return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3416
3417     case BUILT_IN_CIMAG:
3418     case BUILT_IN_CIMAGF:
3419     case BUILT_IN_CIMAGL:
3420       if (coerced_params == 0)
3421         return integer_zero_node;
3422       return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3423
3424     case BUILT_IN_ISGREATER:
3425       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3426         code = UNLE_EXPR;
3427       else
3428         code = LE_EXPR;
3429       goto unordered_cmp;
3430
3431     case BUILT_IN_ISGREATEREQUAL:
3432       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3433         code = UNLT_EXPR;
3434       else
3435         code = LT_EXPR;
3436       goto unordered_cmp;
3437
3438     case BUILT_IN_ISLESS:
3439       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3440         code = UNGE_EXPR;
3441       else
3442         code = GE_EXPR;
3443       goto unordered_cmp;
3444
3445     case BUILT_IN_ISLESSEQUAL:
3446       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3447         code = UNGT_EXPR;
3448       else
3449         code = GT_EXPR;
3450       goto unordered_cmp;
3451
3452     case BUILT_IN_ISLESSGREATER:
3453       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3454         code = UNEQ_EXPR;
3455       else
3456         code = EQ_EXPR;
3457       goto unordered_cmp;
3458
3459     case BUILT_IN_ISUNORDERED:
3460       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3461         return integer_zero_node;
3462       code = UNORDERED_EXPR;
3463       goto unordered_cmp;
3464
3465     unordered_cmp:
3466       {
3467         tree arg0, arg1;
3468
3469         if (params == 0
3470             || TREE_CHAIN (params) == 0)
3471           {
3472             error ("too few arguments to function `%s'",
3473                    IDENTIFIER_POINTER (DECL_NAME (function)));
3474             return error_mark_node;
3475           }
3476         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3477           {
3478             error ("too many arguments to function `%s'",
3479                    IDENTIFIER_POINTER (DECL_NAME (function)));
3480             return error_mark_node;
3481           }
3482
3483         arg0 = TREE_VALUE (params);
3484         arg1 = TREE_VALUE (TREE_CHAIN (params));
3485         arg0 = build_binary_op (code, arg0, arg1, 0);
3486         if (code != UNORDERED_EXPR)
3487           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3488         return arg0;
3489       }
3490       break;
3491
3492     default:
3493       break;
3494     }
3495
3496   return NULL_TREE;
3497 }
3498
3499 /* Returns non-zero if CODE is the code for a statement.  */
3500
3501 int
3502 statement_code_p (code)
3503      enum tree_code code;
3504 {
3505   switch (code)
3506     {
3507     case EXPR_STMT:
3508     case COMPOUND_STMT:
3509     case DECL_STMT:
3510     case IF_STMT:
3511     case FOR_STMT:
3512     case WHILE_STMT:
3513     case DO_STMT:
3514     case RETURN_STMT:
3515     case BREAK_STMT:
3516     case CONTINUE_STMT:
3517     case SCOPE_STMT:
3518     case SWITCH_STMT:
3519     case GOTO_STMT:
3520     case LABEL_STMT:
3521     case ASM_STMT:
3522     case CASE_LABEL:
3523       return 1;
3524
3525     default:
3526       if (lang_statement_code_p)
3527         return (*lang_statement_code_p) (code);
3528       return 0;
3529     }
3530 }
3531
3532 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3533    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3534    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3535    value, the traversal is aborted, and the value returned by FUNC is
3536    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3537    the node being visited are not walked.
3538
3539    We don't need a without_duplicates variant of this one because the
3540    statement tree is a tree, not a graph.  */
3541
3542 tree
3543 walk_stmt_tree (tp, func, data)
3544      tree *tp;
3545      walk_tree_fn func;
3546      void *data;
3547 {
3548   enum tree_code code;
3549   int walk_subtrees;
3550   tree result;
3551   int i, len;
3552
3553 #define WALK_SUBTREE(NODE)                              \
3554   do                                                    \
3555     {                                                   \
3556       result = walk_stmt_tree (&(NODE), func, data);    \
3557       if (result)                                       \
3558         return result;                                  \
3559     }                                                   \
3560   while (0)
3561
3562   /* Skip empty subtrees.  */
3563   if (!*tp)
3564     return NULL_TREE;
3565
3566   /* Skip subtrees below non-statement nodes.  */
3567   if (!statement_code_p (TREE_CODE (*tp)))
3568     return NULL_TREE;
3569
3570   /* Call the function.  */
3571   walk_subtrees = 1;
3572   result = (*func) (tp, &walk_subtrees, data);
3573
3574   /* If we found something, return it.  */
3575   if (result)
3576     return result;
3577
3578   /* FUNC may have modified the tree, recheck that we're looking at a
3579      statement node.  */
3580   code = TREE_CODE (*tp);
3581   if (!statement_code_p (code))
3582     return NULL_TREE;
3583
3584   /* Visit the subtrees unless FUNC decided that there was nothing
3585      interesting below this point in the tree.  */
3586   if (walk_subtrees)
3587     {
3588       /* Walk over all the sub-trees of this operand.  Statement nodes
3589          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3590       len = TREE_CODE_LENGTH (code);
3591
3592       /* Go through the subtrees.  We need to do this in forward order so
3593          that the scope of a FOR_EXPR is handled properly.  */
3594       for (i = 0; i < len; ++i)
3595         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3596     }
3597
3598   /* Finally visit the chain.  This can be tail-recursion optimized if
3599      we write it this way.  */
3600   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3601
3602 #undef WALK_SUBTREE
3603 }
3604
3605 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3606    representing case labels, or NULL_TREE for a `default' label.
3607    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3608    K2, and 0 if K1 and K2 are equal.  */
3609
3610 int
3611 case_compare (k1, k2)
3612      splay_tree_key k1;
3613      splay_tree_key k2;
3614 {
3615   /* Consider a NULL key (such as arises with a `default' label) to be
3616      smaller than anything else.  */
3617   if (!k1)
3618     return k2 ? -1 : 0;
3619   else if (!k2)
3620     return k1 ? 1 : 0;
3621
3622   return tree_int_cst_compare ((tree) k1, (tree) k2);
3623 }
3624
3625 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3626    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3627    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3628    case label was declared using the usual C/C++ syntax, rather than
3629    the GNU case range extension.  CASES is a tree containing all the
3630    case ranges processed so far; COND is the condition for the
3631    switch-statement itself.  Returns the CASE_LABEL created, or
3632    ERROR_MARK_NODE if no CASE_LABEL is created.  */
3633
3634 tree
3635 c_add_case_label (cases, cond, low_value, high_value)
3636      splay_tree cases;
3637      tree cond;
3638      tree low_value;
3639      tree high_value;
3640 {
3641   tree type;
3642   tree label;
3643   tree case_label;
3644   splay_tree_node node;
3645
3646   /* Create the LABEL_DECL itself.  */
3647   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3648   DECL_CONTEXT (label) = current_function_decl;
3649
3650   /* If there was an error processing the switch condition, bail now
3651      before we get more confused.  */
3652   if (!cond || cond == error_mark_node)
3653     {
3654       /* Add a label anyhow so that the back-end doesn't think that
3655          the beginning of the switch is unreachable.  */
3656       if (!cases->root)
3657         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3658       return error_mark_node;
3659     }
3660
3661   if ((low_value && TREE_TYPE (low_value)
3662        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3663       || (high_value && TREE_TYPE (high_value)
3664           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3665     error ("pointers are not permitted as case values");
3666
3667   /* Case ranges are a GNU extension.  */
3668   if (high_value && pedantic)
3669     {
3670       if (c_language == clk_cplusplus)
3671         pedwarn ("ISO C++ forbids range expressions in switch statements");
3672       else
3673         pedwarn ("ISO C forbids range expressions in switch statements");
3674     }
3675
3676   type = TREE_TYPE (cond);
3677   if (low_value)
3678     {
3679       low_value = check_case_value (low_value);
3680       low_value = convert_and_check (type, low_value);
3681     }
3682   if (high_value)
3683     {
3684       high_value = check_case_value (high_value);
3685       high_value = convert_and_check (type, high_value);
3686     }
3687
3688   /* If an error has occurred, bail out now.  */
3689   if (low_value == error_mark_node || high_value == error_mark_node)
3690     {
3691       if (!cases->root)
3692         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3693       return error_mark_node;
3694     }
3695
3696   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3697      really a case range, even though it was written that way.  Remove
3698      the HIGH_VALUE to simplify later processing.  */
3699   if (tree_int_cst_equal (low_value, high_value))
3700     high_value = NULL_TREE;
3701   if (low_value && high_value
3702       && !tree_int_cst_lt (low_value, high_value))
3703     warning ("empty range specified");
3704
3705   /* Look up the LOW_VALUE in the table of case labels we already
3706      have.  */
3707   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3708   /* If there was not an exact match, check for overlapping ranges.
3709      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3710      that's a `default' label and the only overlap is an exact match.  */
3711   if (!node && (low_value || high_value))
3712     {
3713       splay_tree_node low_bound;
3714       splay_tree_node high_bound;
3715
3716       /* Even though there wasn't an exact match, there might be an
3717          overlap between this case range and another case range.
3718          Since we've (inductively) not allowed any overlapping case
3719          ranges, we simply need to find the greatest low case label
3720          that is smaller that LOW_VALUE, and the smallest low case
3721          label that is greater than LOW_VALUE.  If there is an overlap
3722          it will occur in one of these two ranges.  */
3723       low_bound = splay_tree_predecessor (cases,
3724                                           (splay_tree_key) low_value);
3725       high_bound = splay_tree_successor (cases,
3726                                          (splay_tree_key) low_value);
3727
3728       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3729          the LOW_VALUE, so there is no need to check unless the
3730          LOW_BOUND is in fact itself a case range.  */
3731       if (low_bound
3732           && CASE_HIGH ((tree) low_bound->value)
3733           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3734                                     low_value) >= 0)
3735         node = low_bound;
3736       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3737          range is bigger than the low end of the current range, so we
3738          are only interested if the current range is a real range, and
3739          not an ordinary case label.  */
3740       else if (high_bound
3741                && high_value
3742                && (tree_int_cst_compare ((tree) high_bound->key,
3743                                          high_value)
3744                    <= 0))
3745         node = high_bound;
3746     }
3747   /* If there was an overlap, issue an error.  */
3748   if (node)
3749     {
3750       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3751
3752       if (high_value)
3753         {
3754           error ("duplicate (or overlapping) case value");
3755           error_with_decl (duplicate,
3756                            "this is the first entry overlapping that value");
3757         }
3758       else if (low_value)
3759         {
3760           error ("duplicate case value") ;
3761           error_with_decl (duplicate, "previously used here");
3762         }
3763       else
3764         {
3765           error ("multiple default labels in one switch");
3766           error_with_decl (duplicate, "this is the first default label");
3767         }
3768       if (!cases->root)
3769         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3770     }
3771
3772   /* Add a CASE_LABEL to the statement-tree.  */
3773   case_label = add_stmt (build_case_label (low_value, high_value, label));
3774   /* Register this case label in the splay tree.  */
3775   splay_tree_insert (cases,
3776                      (splay_tree_key) low_value,
3777                      (splay_tree_value) case_label);
3778
3779   return case_label;
3780 }
3781
3782 /* Finish an expression taking the address of LABEL.  Returns an
3783    expression for the address.  */
3784
3785 tree
3786 finish_label_address_expr (label)
3787      tree label;
3788 {
3789   tree result;
3790
3791   if (pedantic)
3792     {
3793       if (c_language == clk_cplusplus)
3794         pedwarn ("ISO C++ forbids taking the address of a label");
3795       else
3796         pedwarn ("ISO C forbids taking the address of a label");
3797     }
3798
3799   label = lookup_label (label);
3800   if (label == NULL_TREE)
3801     result = null_pointer_node;
3802   else
3803     {
3804       TREE_USED (label) = 1;
3805       result = build1 (ADDR_EXPR, ptr_type_node, label);
3806       TREE_CONSTANT (result) = 1;
3807       /* The current function in not necessarily uninlinable.
3808          Computed gotos are incompatible with inlining, but the value
3809          here could be used only in a diagnostic, for example.  */
3810     }
3811
3812   return result;
3813 }
3814
3815 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
3816    parameter allows this function to be used as a GC-marking
3817    function.  */
3818
3819 void
3820 mark_stmt_tree (p)
3821      void *p;
3822 {
3823   stmt_tree st = (stmt_tree) p;
3824
3825   ggc_mark_tree (st->x_last_stmt);
3826   ggc_mark_tree (st->x_last_expr_type);
3827 }
3828
3829 /* Mark LD for GC.  */
3830
3831 void
3832 c_mark_lang_decl (c)
3833      struct c_lang_decl *c;
3834 {
3835   ggc_mark_tree (c->saved_tree);
3836 }
3837
3838 /* Mark F for GC.  */
3839
3840 void
3841 mark_c_language_function (f)
3842      struct language_function *f;
3843 {
3844   if (!f)
3845     return;
3846
3847   mark_stmt_tree (&f->x_stmt_tree);
3848   ggc_mark_tree (f->x_scope_stmt_stack);
3849 }
3850
3851 /* Hook used by expand_expr to expand language-specific tree codes.  */
3852
3853 rtx
3854 c_expand_expr (exp, target, tmode, modifier)
3855      tree exp;
3856      rtx target;
3857      enum machine_mode tmode;
3858      enum expand_modifier modifier;
3859 {
3860   switch (TREE_CODE (exp))
3861     {
3862     case STMT_EXPR:
3863       {
3864         tree rtl_expr;
3865         rtx result;
3866
3867         /* Since expand_expr_stmt calls free_temp_slots after every
3868            expression statement, we must call push_temp_slots here.
3869            Otherwise, any temporaries in use now would be considered
3870            out-of-scope after the first EXPR_STMT from within the
3871            STMT_EXPR.  */
3872         push_temp_slots ();
3873         rtl_expr = expand_start_stmt_expr ();
3874         expand_stmt (STMT_EXPR_STMT (exp));
3875         expand_end_stmt_expr (rtl_expr);
3876         result = expand_expr (rtl_expr, target, tmode, modifier);
3877         pop_temp_slots ();
3878         return result;
3879       }
3880       break;
3881
3882     case CALL_EXPR:
3883       {
3884         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3885             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3886                 == FUNCTION_DECL)
3887             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3888             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3889                 == BUILT_IN_FRONTEND))
3890           return c_expand_builtin (exp, target, tmode, modifier);
3891         else
3892           abort();
3893       }
3894       break;
3895
3896     default:
3897       abort ();
3898     }
3899
3900   abort ();
3901   return NULL;
3902 }
3903
3904 /* Hook used by safe_from_p to handle language-specific tree codes.  */
3905
3906 int
3907 c_safe_from_p (target, exp)
3908      rtx target;
3909      tree exp;
3910 {
3911   /* We can see statements here when processing the body of a
3912      statement-expression.  For a declaration statement declaring a
3913      variable, look at the variable's initializer.  */
3914   if (TREE_CODE (exp) == DECL_STMT)
3915     {
3916       tree decl = DECL_STMT_DECL (exp);
3917
3918       if (TREE_CODE (decl) == VAR_DECL
3919           && DECL_INITIAL (decl)
3920           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3921         return 0;
3922     }
3923
3924   /* For any statement, we must follow the statement-chain.  */
3925   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3926     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3927
3928   /* Assume everything else is safe.  */
3929   return 1;
3930 }
3931
3932 /* Hook used by unsafe_for_reeval to handle language-specific tree codes.  */
3933
3934 int
3935 c_unsafe_for_reeval (exp)
3936      tree exp;
3937 {
3938   /* Statement expressions may not be reevaluated.  */
3939   if (TREE_CODE (exp) == STMT_EXPR)
3940     return 2;
3941
3942   /* Walk all other expressions.  */
3943   return -1;
3944 }
3945
3946 /* Tree code classes. */
3947
3948 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3949
3950 static char c_tree_code_type[] = {
3951   'x',
3952 #include "c-common.def"
3953 };
3954 #undef DEFTREECODE
3955
3956 /* Table indexed by tree code giving number of expression
3957    operands beyond the fixed part of the node structure.
3958    Not used for types or decls.  */
3959
3960 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3961
3962 static int c_tree_code_length[] = {
3963   0,
3964 #include "c-common.def"
3965 };
3966 #undef DEFTREECODE
3967
3968 /* Names of tree components.
3969    Used for printing out the tree and error messages.  */
3970 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3971
3972 static const char *c_tree_code_name[] = {
3973   "@@dummy",
3974 #include "c-common.def"
3975 };
3976 #undef DEFTREECODE
3977
3978 /* Adds the tree codes specific to the C front end to the list of all
3979    tree codes. */
3980
3981 void
3982 add_c_tree_codes ()
3983 {
3984   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3985           c_tree_code_type,
3986           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3987   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3988           c_tree_code_length,
3989           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3990   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3991           c_tree_code_name,
3992           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
3993   lang_unsafe_for_reeval = c_unsafe_for_reeval;
3994 }
3995
3996 #define CALLED_AS_BUILT_IN(NODE) \
3997    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3998
3999 static rtx
4000 c_expand_builtin (exp, target, tmode, modifier)
4001      tree exp;
4002      rtx target;
4003      enum machine_mode tmode;
4004      enum expand_modifier modifier;
4005 {
4006   tree type = TREE_TYPE (exp);
4007   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4008   tree arglist = TREE_OPERAND (exp, 1);
4009   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4010   enum tree_code code = TREE_CODE (exp);
4011   const int ignore = (target == const0_rtx
4012                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4013                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
4014                            || code == COND_EXPR)
4015                           && TREE_CODE (type) == VOID_TYPE));
4016
4017   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4018     return expand_call (exp, target, ignore);
4019
4020   switch (fcode)
4021     {
4022     case BUILT_IN_PRINTF:
4023       target = c_expand_builtin_printf (arglist, target, tmode,
4024                                         modifier, ignore);
4025       if (target)
4026         return target;
4027       break;
4028
4029     case BUILT_IN_FPRINTF:
4030       target = c_expand_builtin_fprintf (arglist, target, tmode,
4031                                          modifier, ignore);
4032       if (target)
4033         return target;
4034       break;
4035
4036     default:                    /* just do library call, if unknown builtin */
4037       error ("built-in function `%s' not currently supported",
4038              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4039     }
4040
4041   /* The switch statement above can drop through to cause the function
4042      to be called normally.  */
4043   return expand_call (exp, target, ignore);
4044 }
4045
4046 /* Check an arglist to *printf for problems.  The arglist should start
4047    at the format specifier, with the remaining arguments immediately
4048    following it. */
4049 static int
4050 is_valid_printf_arglist (arglist)
4051   tree arglist;
4052 {
4053   /* Save this value so we can restore it later. */
4054   const int SAVE_pedantic = pedantic;
4055   int diagnostic_occurred = 0;
4056
4057   /* Set this to a known value so the user setting won't affect code
4058      generation.  */
4059   pedantic = 1;
4060   /* Check to make sure there are no format specifier errors. */
4061   check_function_format (&diagnostic_occurred,
4062                          maybe_get_identifier("printf"),
4063                          NULL_TREE, arglist);
4064
4065   /* Restore the value of `pedantic'. */
4066   pedantic = SAVE_pedantic;
4067
4068   /* If calling `check_function_format_ptr' produces a warning, we
4069      return false, otherwise we return true. */
4070   return ! diagnostic_occurred;
4071 }
4072
4073 /* If the arguments passed to printf are suitable for optimizations,
4074    we attempt to transform the call. */
4075 static rtx
4076 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
4077      tree arglist;
4078      rtx target;
4079      enum machine_mode tmode;
4080      enum expand_modifier modifier;
4081      int ignore;
4082 {
4083   tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
4084     fn_puts = built_in_decls[BUILT_IN_PUTS];
4085   tree fn, format_arg, stripped_string;
4086
4087   /* If the return value is used, or the replacement _DECL isn't
4088      initialized, don't do the transformation. */
4089   if (!ignore || !fn_putchar || !fn_puts)
4090     return 0;
4091
4092   /* Verify the required arguments in the original call. */
4093   if (arglist == 0
4094       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4095     return 0;
4096
4097   /* Check the specifier vs. the parameters. */
4098   if (!is_valid_printf_arglist (arglist))
4099     return 0;
4100
4101   format_arg = TREE_VALUE (arglist);
4102   stripped_string = format_arg;
4103   STRIP_NOPS (stripped_string);
4104   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4105     stripped_string = TREE_OPERAND (stripped_string, 0);
4106
4107   /* If the format specifier isn't a STRING_CST, punt.  */
4108   if (TREE_CODE (stripped_string) != STRING_CST)
4109     return 0;
4110
4111   /* OK!  We can attempt optimization.  */
4112
4113   /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4114   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4115     {
4116       arglist = TREE_CHAIN (arglist);
4117       fn = fn_puts;
4118     }
4119   /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4120   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4121     {
4122       arglist = TREE_CHAIN (arglist);
4123       fn = fn_putchar;
4124     }
4125   else
4126     {
4127      /* We can't handle anything else with % args or %% ... yet. */
4128       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4129         return 0;
4130
4131       /* If the resulting constant string has a length of 1, call
4132          putchar.  Note, TREE_STRING_LENGTH includes the terminating
4133          NULL in its count.  */
4134       if (TREE_STRING_LENGTH (stripped_string) == 2)
4135         {
4136           /* Given printf("c"), (where c is any one character,)
4137              convert "c"[0] to an int and pass that to the replacement
4138              function. */
4139           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4140           arglist = build_tree_list (NULL_TREE, arglist);
4141
4142           fn = fn_putchar;
4143         }
4144       /* If the resulting constant was "string\n", call
4145          __builtin_puts("string").  Ensure "string" has at least one
4146          character besides the trailing \n.  Note, TREE_STRING_LENGTH
4147          includes the terminating NULL in its count.  */
4148       else if (TREE_STRING_LENGTH (stripped_string) > 2
4149                && TREE_STRING_POINTER (stripped_string)
4150                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4151         {
4152           /* Create a NULL-terminated string that's one char shorter
4153              than the original, stripping off the trailing '\n'.  */
4154           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4155           char *newstr = (char *) alloca (newlen);
4156           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4157           newstr[newlen - 1] = 0;
4158
4159           arglist = combine_strings (build_string (newlen, newstr));
4160           arglist = build_tree_list (NULL_TREE, arglist);
4161           fn = fn_puts;
4162         }
4163       else
4164         /* We'd like to arrange to call fputs(string) here, but we
4165            need stdout and don't have a way to get it ... yet.  */
4166         return 0;
4167     }
4168
4169   return expand_expr (build_function_call (fn, arglist),
4170                       (ignore ? const0_rtx : target),
4171                       tmode, modifier);
4172 }
4173
4174 /* If the arguments passed to fprintf are suitable for optimizations,
4175    we attempt to transform the call. */
4176 static rtx
4177 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
4178      tree arglist;
4179      rtx target;
4180      enum machine_mode tmode;
4181      enum expand_modifier modifier;
4182      int ignore;
4183 {
4184   tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
4185     fn_fputs = built_in_decls[BUILT_IN_FPUTS];
4186   tree fn, format_arg, stripped_string;
4187
4188   /* If the return value is used, or the replacement _DECL isn't
4189      initialized, don't do the transformation. */
4190   if (!ignore || !fn_fputc || !fn_fputs)
4191     return 0;
4192
4193   /* Verify the required arguments in the original call. */
4194   if (arglist == 0
4195       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4196       || (TREE_CHAIN (arglist) == 0)
4197       || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4198           POINTER_TYPE))
4199     return 0;
4200
4201   /* Check the specifier vs. the parameters. */
4202   if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4203     return 0;
4204
4205   format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4206   stripped_string = format_arg;
4207   STRIP_NOPS (stripped_string);
4208   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4209     stripped_string = TREE_OPERAND (stripped_string, 0);
4210
4211   /* If the format specifier isn't a STRING_CST, punt.  */
4212   if (TREE_CODE (stripped_string) != STRING_CST)
4213     return 0;
4214
4215   /* OK!  We can attempt optimization.  */
4216
4217   /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4218   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4219     {
4220       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4221       arglist = tree_cons (NULL_TREE,
4222                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4223                            newarglist);
4224       fn = fn_fputs;
4225     }
4226   /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4227   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4228     {
4229       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4230       arglist = tree_cons (NULL_TREE,
4231                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4232                            newarglist);
4233       fn = fn_fputc;
4234     }
4235   else
4236     {
4237      /* We can't handle anything else with % args or %% ... yet. */
4238       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4239         return 0;
4240
4241       /* When "string" doesn't contain %, replace all cases of
4242          fprintf(stream,string) with fputs(string,stream).  The fputs
4243          builtin will take take of special cases like length==1.  */
4244       arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4245                            build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4246       fn = fn_fputs;
4247     }
4248
4249   return expand_expr (build_function_call (fn, arglist),
4250                       (ignore ? const0_rtx : target),
4251                       tmode, modifier);
4252 }
4253 \f
4254
4255 /* Given a boolean expression ARG, return a tree representing an increment
4256    or decrement (as indicated by CODE) of ARG.  The front end must check for
4257    invalid cases (e.g., decrement in C++).  */
4258 tree
4259 boolean_increment (code, arg)
4260      enum tree_code code;
4261      tree arg;
4262 {
4263   tree val;
4264   tree true_res = (c_language == clk_cplusplus
4265                    ? boolean_true_node
4266                    : c_bool_true_node);
4267   arg = stabilize_reference (arg);
4268   switch (code)
4269     {
4270     case PREINCREMENT_EXPR:
4271       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4272       break;
4273     case POSTINCREMENT_EXPR:
4274       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4275       arg = save_expr (arg);
4276       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4277       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4278       break;
4279     case PREDECREMENT_EXPR:
4280       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4281       break;
4282     case POSTDECREMENT_EXPR:
4283       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4284       arg = save_expr (arg);
4285       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4286       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4287       break;
4288     default:
4289       abort ();
4290     }
4291   TREE_SIDE_EFFECTS (val) = 1;
4292   return val;
4293 }
4294 \f
4295
4296 /* Do the parts of lang_init common to C and C++.  */
4297 void
4298 c_common_lang_init ()
4299 {
4300   /* If still "unspecified", make it match -fbounded-pointers.  */
4301   if (flag_bounds_check < 0)
4302     flag_bounds_check = flag_bounded_pointers;
4303
4304   /* Special format checking options don't work without -Wformat; warn if
4305      they are used.  */
4306   if (warn_format_y2k && !warn_format)
4307     warning ("-Wformat-y2k ignored without -Wformat");
4308   if (warn_format_extra_args && !warn_format)
4309     warning ("-Wformat-extra-args ignored without -Wformat");
4310   if (warn_format_nonliteral && !warn_format)
4311     warning ("-Wformat-nonliteral ignored without -Wformat");
4312   if (warn_format_security && !warn_format)
4313     warning ("-Wformat-security ignored without -Wformat");
4314   if (warn_missing_format_attribute && !warn_format)
4315     warning ("-Wmissing-format-attribute ignored without -Wformat");
4316 }