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