gcc/c-common.c

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