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