gcc/c-common.c

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