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