gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "toplev.h"
  27 #include "output.h"
  28 #include "c-pragma.h"
  29 #include "rtl.h"
  30 #include "ggc.h"
  31 #include "expr.h"
  32 #include "c-common.h"
  33 #include "tree-inline.h"
  34 #include "diagnostic.h"
  35 #include "tm_p.h"
  36 #include "obstack.h"
  37 #include "c-lex.h"
  38 #include "cpplib.h"
  39 #include "target.h"
  40 #include "langhooks.h"
  41 cpp_reader *parse_in;           /* Declared in c-lex.h.  */
  42
  43 #undef WCHAR_TYPE_SIZE
  44 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  45
  46 /* We let tm.h override the types used here, to handle trivial differences
  47    such as the choice of unsigned int or long unsigned int for size_t.
  48    When machines start needing nontrivial differences in the size type,
  49    it would be best to do something here to figure out automatically
  50    from other information what type to use.  */
  51
  52 #ifndef SIZE_TYPE
  53 #define SIZE_TYPE "long unsigned int"
  54 #endif
  55
  56 #ifndef WCHAR_TYPE
  57 #define WCHAR_TYPE "int"
  58 #endif
  59
  60 #ifndef PTRDIFF_TYPE
  61 #define PTRDIFF_TYPE "long int"
  62 #endif
  63
  64 #ifndef WINT_TYPE
  65 #define WINT_TYPE "unsigned int"
  66 #endif
  67
  68 #ifndef INTMAX_TYPE
  69 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  70                      ? "int"                                    \
  71                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  72                         ? "long int"                            \
  73                         : "long long int"))
  74 #endif
  75
  76 #ifndef UINTMAX_TYPE
  77 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  78                      ? "unsigned int"                           \
  79                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  80                         ? "long unsigned int"                   \
  81                         : "long long unsigned int"))
  82 #endif
  83
  84 /* The variant of the C language being processed.  */
  85
  86 enum c_language_kind c_language;
  87
  88 /* The following symbols are subsumed in the c_global_trees array, and
  89    listed here individually for documentation purposes.
  90
  91    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  92
  93         tree short_integer_type_node;
  94         tree long_integer_type_node;
  95         tree long_long_integer_type_node;
  96
  97         tree short_unsigned_type_node;
  98         tree long_unsigned_type_node;
  99         tree long_long_unsigned_type_node;
 100
 101         tree boolean_type_node;
 102         tree boolean_false_node;
 103         tree boolean_true_node;
 104
 105         tree ptrdiff_type_node;
 106
 107         tree unsigned_char_type_node;
 108         tree signed_char_type_node;
 109         tree wchar_type_node;
 110         tree signed_wchar_type_node;
 111         tree unsigned_wchar_type_node;
 112
 113         tree float_type_node;
 114         tree double_type_node;
 115         tree long_double_type_node;
 116
 117         tree complex_integer_type_node;
 118         tree complex_float_type_node;
 119         tree complex_double_type_node;
 120         tree complex_long_double_type_node;
 121
 122         tree intQI_type_node;
 123         tree intHI_type_node;
 124         tree intSI_type_node;
 125         tree intDI_type_node;
 126         tree intTI_type_node;
 127
 128         tree unsigned_intQI_type_node;
 129         tree unsigned_intHI_type_node;
 130         tree unsigned_intSI_type_node;
 131         tree unsigned_intDI_type_node;
 132         tree unsigned_intTI_type_node;
 133
 134         tree widest_integer_literal_type_node;
 135         tree widest_unsigned_literal_type_node;
 136
 137    Nodes for types `void *' and `const void *'.
 138
 139         tree ptr_type_node, const_ptr_type_node;
 140
 141    Nodes for types `char *' and `const char *'.
 142
 143         tree string_type_node, const_string_type_node;
 144
 145    Type `char[SOMENUMBER]'.
 146    Used when an array of char is needed and the size is irrelevant.
 147
 148         tree char_array_type_node;
 149
 150    Type `int[SOMENUMBER]' or something like it.
 151    Used when an array of int needed and the size is irrelevant.
 152
 153         tree int_array_type_node;
 154
 155    Type `wchar_t[SOMENUMBER]' or something like it.
 156    Used when a wide string literal is created.
 157
 158         tree wchar_array_type_node;
 159
 160    Type `int ()' -- used for implicit declaration of functions.
 161
 162         tree default_function_type;
 163
 164    A VOID_TYPE node, packaged in a TREE_LIST.
 165
 166         tree void_list_node;
 167
 168   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 169   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 170   VAR_DECLS, but C++ does.)
 171
 172         tree function_name_decl_node;
 173         tree pretty_function_name_decl_node;
 174         tree c99_function_name_decl_node;
 175
 176   Stack of nested function name VAR_DECLs.
 177
 178         tree saved_function_name_decls;
 179
 180 */
 181
 182 tree c_global_trees[CTI_MAX];
 183
 184 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 185
 186 int flag_no_builtin;
 187
 188 /* Nonzero means don't recognize the non-ANSI builtin functions.
 189    -ansi sets this.  */
 190
 191 int flag_no_nonansi_builtin;
 192
 193 /* Nonzero means give `double' the same size as `float'.  */
 194
 195 int flag_short_double;
 196
 197 /* Nonzero means give `wchar_t' the same size as `short'.  */
 198
 199 int flag_short_wchar;
 200
 201 /* Nonzero means warn about possible violations of sequence point rules.  */
 202
 203 int warn_sequence_point;
 204
 205 /* Nonzero means to warn about compile-time division by zero.  */
 206 int warn_div_by_zero = 1;
 207
 208 /* The elements of `ridpointers' are identifier nodes for the reserved
 209    type names and storage classes.  It is indexed by a RID_... value.  */
 210 tree *ridpointers;
 211
 212 tree (*make_fname_decl)                PARAMS ((tree, int));
 213
 214 /* If non-NULL, the address of a language-specific function that
 215    returns 1 for language-specific statement codes.  */
 216 int (*lang_statement_code_p)           PARAMS ((enum tree_code));
 217
 218 /* If non-NULL, the address of a language-specific function that takes
 219    any action required right before expand_function_end is called.  */
 220 void (*lang_expand_function_end)       PARAMS ((void));
 221
 222 /* Nonzero means the expression being parsed will never be evaluated.
 223    This is a count, since unevaluated expressions can nest.  */
 224 int skip_evaluation;
 225
 226 /* Information about how a function name is generated.  */
 227 struct fname_var_t
 228 {
 229   tree *const decl;     /* pointer to the VAR_DECL.  */
 230   const unsigned rid;   /* RID number for the identifier.  */
 231   const int pretty;     /* How pretty is it? */
 232 };
 233
 234 /* The three ways of getting then name of the current function.  */
 235
 236 const struct fname_var_t fname_vars[] =
 237 {
 238   /* C99 compliant __func__, must be first.  */
 239   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 240   /* GCC __FUNCTION__ compliant.  */
 241   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 242   /* GCC __PRETTY_FUNCTION__ compliant.  */
 243   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 244   {NULL, 0, 0},
 245 };
 246
 247 static int constant_fits_type_p         PARAMS ((tree, tree));
 248
 249 /* Keep a stack of if statements.  We record the number of compound
 250    statements seen up to the if keyword, as well as the line number
 251    and file of the if.  If a potentially ambiguous else is seen, that
 252    fact is recorded; the warning is issued when we can be sure that
 253    the enclosing if statement does not have an else branch.  */
 254 typedef struct
 255 {
 256   int compstmt_count;
 257   int line;
 258   const char *file;
 259   int needs_warning;
 260   tree if_stmt;
 261 } if_elt;
 262
 263 static if_elt *if_stack;
 264
 265 /* Amount of space in the if statement stack.  */
 266 static int if_stack_space = 0;
 267
 268 /* Stack pointer.  */
 269 static int if_stack_pointer = 0;
 270
 271 /* Record the start of an if-then, and record the start of it
 272    for ambiguous else detection.
 273
 274    COND is the condition for the if-then statement.
 275
 276    IF_STMT is the statement node that has already been created for
 277    this if-then statement.  It is created before parsing the
 278    condition to keep line number information accurate.  */
 279
 280 void
 281 c_expand_start_cond (cond, compstmt_count, if_stmt)
 282      tree cond;
 283      int compstmt_count;
 284      tree if_stmt;
 285 {
 286   /* Make sure there is enough space on the stack.  */
 287   if (if_stack_space == 0)
 288     {
 289       if_stack_space = 10;
 290       if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
 291     }
 292   else if (if_stack_space == if_stack_pointer)
 293     {
 294       if_stack_space += 10;
 295       if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 296     }
 297
 298   IF_COND (if_stmt) = cond;
 299   add_stmt (if_stmt);
 300
 301   /* Record this if statement.  */
 302   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 303   if_stack[if_stack_pointer].file = input_filename;
 304   if_stack[if_stack_pointer].line = lineno;
 305   if_stack[if_stack_pointer].needs_warning = 0;
 306   if_stack[if_stack_pointer].if_stmt = if_stmt;
 307   if_stack_pointer++;
 308 }
 309
 310 /* Called after the then-clause for an if-statement is processed.  */
 311
 312 void
 313 c_finish_then ()
 314 {
 315   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 316   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 317 }
 318
 319 /* Record the end of an if-then.  Optionally warn if a nested
 320    if statement had an ambiguous else clause.  */
 321
 322 void
 323 c_expand_end_cond ()
 324 {
 325   if_stack_pointer--;
 326   if (if_stack[if_stack_pointer].needs_warning)
 327     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 328                                 if_stack[if_stack_pointer].line,
 329                                 "suggest explicit braces to avoid ambiguous `else'");
 330   last_expr_type = NULL_TREE;
 331 }
 332
 333 /* Called between the then-clause and the else-clause
 334    of an if-then-else.  */
 335
 336 void
 337 c_expand_start_else ()
 338 {
 339   /* An ambiguous else warning must be generated for the enclosing if
 340      statement, unless we see an else branch for that one, too.  */
 341   if (warn_parentheses
 342       && if_stack_pointer > 1
 343       && (if_stack[if_stack_pointer - 1].compstmt_count
 344           == if_stack[if_stack_pointer - 2].compstmt_count))
 345     if_stack[if_stack_pointer - 2].needs_warning = 1;
 346
 347   /* Even if a nested if statement had an else branch, it can't be
 348      ambiguous if this one also has an else.  So don't warn in that
 349      case.  Also don't warn for any if statements nested in this else.  */
 350   if_stack[if_stack_pointer - 1].needs_warning = 0;
 351   if_stack[if_stack_pointer - 1].compstmt_count--;
 352 }
 353
 354 /* Called after the else-clause for an if-statement is processed.  */
 355
 356 void
 357 c_finish_else ()
 358 {
 359   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 360   RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 361 }
 362
 363 /* Begin an if-statement.  Returns a newly created IF_STMT if
 364    appropriate.
 365
 366    Unlike the C++ front-end, we do not call add_stmt here; it is
 367    probably safe to do so, but I am not very familiar with this
 368    code so I am being extra careful not to change its behavior
 369    beyond what is strictly necessary for correctness.  */
 370
 371 tree
 372 c_begin_if_stmt ()
 373 {
 374   tree r;
 375   r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 376   return r;
 377 }
 378
 379 /* Begin a while statement.  Returns a newly created WHILE_STMT if
 380    appropriate.
 381
 382    Unlike the C++ front-end, we do not call add_stmt here; it is
 383    probably safe to do so, but I am not very familiar with this
 384    code so I am being extra careful not to change its behavior
 385    beyond what is strictly necessary for correctness.  */
 386
 387 tree
 388 c_begin_while_stmt ()
 389 {
 390   tree r;
 391   r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
 392   return r;
 393 }
 394
 395 void
 396 c_finish_while_stmt_cond (cond, while_stmt)
 397      tree while_stmt;
 398      tree cond;
 399 {
 400   WHILE_COND (while_stmt) = cond;
 401 }
 402
 403 /* Push current bindings for the function name VAR_DECLS.  */
 404
 405 void
 406 start_fname_decls ()
 407 {
 408   unsigned ix;
 409   tree saved = NULL_TREE;
 410
 411   for (ix = 0; fname_vars[ix].decl; ix++)
 412     {
 413       tree decl = *fname_vars[ix].decl;
 414
 415       if (decl)
 416         {
 417           saved = tree_cons (decl, build_int_2 (ix, 0), saved);
 418           *fname_vars[ix].decl = NULL_TREE;
 419         }
 420     }
 421   if (saved || saved_function_name_decls)
 422     /* Normally they'll have been NULL, so only push if we've got a
 423        stack, or they are non-NULL.  */
 424     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 425                                            saved_function_name_decls);
 426 }
 427
 428 /* Finish up the current bindings, adding them into the
 429    current function's statement tree. This is done by wrapping the
 430    function's body in a COMPOUND_STMT containing these decls too. This
 431    must be done _before_ finish_stmt_tree is called. If there is no
 432    current function, we must be at file scope and no statements are
 433    involved. Pop the previous bindings.  */
 434
 435 void
 436 finish_fname_decls ()
 437 {
 438   unsigned ix;
 439   tree body = NULL_TREE;
 440   tree stack = saved_function_name_decls;
 441
 442   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 443     body = chainon (TREE_VALUE (stack), body);
 444
 445   if (body)
 446     {
 447       /* They were called into existence, so add to statement tree.  */
 448       body = chainon (body,
 449                       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
 450       body = build_stmt (COMPOUND_STMT, body);
 451
 452       COMPOUND_STMT_NO_SCOPE (body) = 1;
 453       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
 454     }
 455
 456   for (ix = 0; fname_vars[ix].decl; ix++)
 457     *fname_vars[ix].decl = NULL_TREE;
 458
 459   if (stack)
 460     {
 461       /* We had saved values, restore them.  */
 462       tree saved;
 463
 464       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 465         {
 466           tree decl = TREE_PURPOSE (saved);
 467           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 468
 469           *fname_vars[ix].decl = decl;
 470         }
 471       stack = TREE_CHAIN (stack);
 472     }
 473   saved_function_name_decls = stack;
 474 }
 475
 476 /* Return the text name of the current function, suitable prettified
 477    by PRETTY_P.  */
 478
 479 const char *
 480 fname_as_string (pretty_p)
 481      int pretty_p;
 482 {
 483   const char *name = NULL;
 484
 485   if (pretty_p)
 486     name = (current_function_decl
 487             ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
 488             : "top level");
 489   else if (current_function_decl && DECL_NAME (current_function_decl))
 490     name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 491   else
 492     name = "";
 493   return name;
 494 }
 495
 496 /* Return the text name of the current function, formatted as
 497    required by the supplied RID value.  */
 498
 499 const char *
 500 fname_string (rid)
 501      unsigned rid;
 502 {
 503   unsigned ix;
 504
 505   for (ix = 0; fname_vars[ix].decl; ix++)
 506     if (fname_vars[ix].rid == rid)
 507       break;
 508   return fname_as_string (fname_vars[ix].pretty);
 509 }
 510
 511 /* Return the VAR_DECL for a const char array naming the current
 512    function. If the VAR_DECL has not yet been created, create it
 513    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 514    ID is its name (unfortunately C and C++ hold the RID values of
 515    keywords in different places, so we can't derive RID from ID in
 516    this language independent code.  */
 517
 518 tree
 519 fname_decl (rid, id)
 520      unsigned rid;
 521      tree id;
 522 {
 523   unsigned ix;
 524   tree decl = NULL_TREE;
 525
 526   for (ix = 0; fname_vars[ix].decl; ix++)
 527     if (fname_vars[ix].rid == rid)
 528       break;
 529
 530   decl = *fname_vars[ix].decl;
 531   if (!decl)
 532     {
 533       tree saved_last_tree = last_tree;
 534
 535       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 536       if (last_tree != saved_last_tree)
 537         {
 538           /* We created some statement tree for the decl. This belongs
 539              at the start of the function, so remove it now and reinsert
 540              it after the function is complete.  */
 541           tree stmts = TREE_CHAIN (saved_last_tree);
 542
 543           TREE_CHAIN (saved_last_tree) = NULL_TREE;
 544           last_tree = saved_last_tree;
 545           saved_function_name_decls = tree_cons (decl, stmts,
 546                                                  saved_function_name_decls);
 547         }
 548       *fname_vars[ix].decl = decl;
 549     }
 550   if (!ix && !current_function_decl)
 551     pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
 552
 553   return decl;
 554 }
 555
 556 /* Given a chain of STRING_CST nodes,
 557    concatenate them into one STRING_CST
 558    and give it a suitable array-of-chars data type.  */
 559
 560 tree
 561 combine_strings (strings)
 562      tree strings;
 563 {
 564   tree value, t;
 565   int length = 1;
 566   int wide_length = 0;
 567   int wide_flag = 0;
 568   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 569   int nchars;
 570   const int nchars_max = flag_isoc99 ? 4095 : 509;
 571
 572   if (TREE_CHAIN (strings))
 573     {
 574       /* More than one in the chain, so concatenate.  */
 575       char *p, *q;
 576
 577       /* Don't include the \0 at the end of each substring,
 578          except for the last one.
 579          Count wide strings and ordinary strings separately.  */
 580       for (t = strings; t; t = TREE_CHAIN (t))
 581         {
 582           if (TREE_TYPE (t) == wchar_array_type_node)
 583             {
 584               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 585               wide_flag = 1;
 586             }
 587           else
 588             {
 589               length += (TREE_STRING_LENGTH (t) - 1);
 590               if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
 591                 warning ("concatenation of string literals with __FUNCTION__ is deprecated.  This feature will be removed in future");
 592             }
 593         }
 594
 595       /* If anything is wide, the non-wides will be converted,
 596          which makes them take more space.  */
 597       if (wide_flag)
 598         length = length * wchar_bytes + wide_length;
 599
 600       p = alloca (length);
 601
 602       /* Copy the individual strings into the new combined string.
 603          If the combined string is wide, convert the chars to ints
 604          for any individual strings that are not wide.  */
 605
 606       q = p;
 607       for (t = strings; t; t = TREE_CHAIN (t))
 608         {
 609           int len = (TREE_STRING_LENGTH (t)
 610                      - ((TREE_TYPE (t) == wchar_array_type_node)
 611                         ? wchar_bytes : 1));
 612           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 613             {
 614               memcpy (q, TREE_STRING_POINTER (t), len);
 615               q += len;
 616             }
 617           else
 618             {
 619               int i, j;
 620               for (i = 0; i < len; i++)
 621                 {
 622                   if (BYTES_BIG_ENDIAN)
 623                     {
 624                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 625                         *q++ = 0;
 626                       *q++ = TREE_STRING_POINTER (t)[i];
 627                     }
 628                   else
 629                     {
 630                       *q++ = TREE_STRING_POINTER (t)[i];
 631                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 632                         *q++ = 0;
 633                     }
 634                 }
 635             }
 636         }
 637       if (wide_flag)
 638         {
 639           int i;
 640           for (i = 0; i < wchar_bytes; i++)
 641             *q++ = 0;
 642         }
 643       else
 644         *q = 0;
 645
 646       value = build_string (length, p);
 647     }
 648   else
 649     {
 650       value = strings;
 651       length = TREE_STRING_LENGTH (value);
 652       if (TREE_TYPE (value) == wchar_array_type_node)
 653         wide_flag = 1;
 654     }
 655
 656   /* Compute the number of elements, for the array type.  */
 657   nchars = wide_flag ? length / wchar_bytes : length;
 658
 659   if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
 660     pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
 661              nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
 662
 663   /* Create the array type for the string constant.
 664      -Wwrite-strings says make the string constant an array of const char
 665      so that copying it to a non-const pointer will get a warning.
 666      For C++, this is the standard behavior.  */
 667   if (flag_const_strings && ! 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       /* Perhaps reduce (x - y) != 0 to (x != y).  The expressions
2207          aren't guaranteed to the be same for modes that can represent
2208          infinity, since if x and y are both +infinity, or both
2209          -infinity, then x - y is not a number.
2210
2211          Note that this transformation is safe when x or y is NaN.
2212          (x - y) is then NaN, and both (x - y) != 0 and x != y will
2213          be false.  */
2214       if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2215         break;
2216       /* fall through...  */
2217     case BIT_XOR_EXPR:
2218       /* This and MINUS_EXPR can be changed into a comparison of the
2219          two objects.  */
2220       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2221           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2222         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2223                                 TREE_OPERAND (expr, 1), 1);
2224       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2225                               fold (build1 (NOP_EXPR,
2226                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2227                                             TREE_OPERAND (expr, 1))), 1);
2228
2229     case BIT_AND_EXPR:
2230       if (integer_onep (TREE_OPERAND (expr, 1))
2231           && TREE_TYPE (expr) != boolean_type_node)
2232         /* Using convert here would cause infinite recursion.  */
2233         return build1 (NOP_EXPR, boolean_type_node, expr);
2234       break;
2235
2236     case MODIFY_EXPR:
2237       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2238         warning ("suggest parentheses around assignment used as truth value");
2239       break;
2240
2241     default:
2242       break;
2243     }
2244
2245   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2246     {
2247       tree tem = save_expr (expr);
2248       return (build_binary_op
2249               ((TREE_SIDE_EFFECTS (expr)
2250                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2251                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2252                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2253                0));
2254     }
2255
2256   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2257 }
2258 \f
2259 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2260                                         int, enum built_in_class, int, int,
2261                                         int));
2262
2263 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2264    down to the element type of an array.  */
2265
2266 tree
2267 c_build_qualified_type (type, type_quals)
2268      tree type;
2269      int type_quals;
2270 {
2271   /* A restrict-qualified pointer type must be a pointer to object or
2272      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2273      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
2274      the C++ front-end also use POINTER_TYPE for pointer-to-member
2275      values, so even though it should be illegal to use `restrict'
2276      with such an entity we don't flag that here.  Thus, special case
2277      code for that case is required in the C++ front-end.  */
2278   if ((type_quals & TYPE_QUAL_RESTRICT)
2279       && (!POINTER_TYPE_P (type)
2280           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2281     {
2282       error ("invalid use of `restrict'");
2283       type_quals &= ~TYPE_QUAL_RESTRICT;
2284     }
2285
2286   if (TREE_CODE (type) == ARRAY_TYPE)
2287     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2288                                                      type_quals),
2289                              TYPE_DOMAIN (type));
2290   return build_qualified_type (type, type_quals);
2291 }
2292
2293 /* Apply the TYPE_QUALS to the new DECL.  */
2294
2295 void
2296 c_apply_type_quals_to_decl (type_quals, decl)
2297      int type_quals;
2298      tree decl;
2299 {
2300   if ((type_quals & TYPE_QUAL_CONST)
2301       || (TREE_TYPE (decl)
2302           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2303     TREE_READONLY (decl) = 1;
2304   if (type_quals & TYPE_QUAL_VOLATILE)
2305     {
2306       TREE_SIDE_EFFECTS (decl) = 1;
2307       TREE_THIS_VOLATILE (decl) = 1;
2308     }
2309   if (type_quals & TYPE_QUAL_RESTRICT)
2310     {
2311       if (!TREE_TYPE (decl)
2312           || !POINTER_TYPE_P (TREE_TYPE (decl))
2313           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2314         error ("invalid use of `restrict'");
2315       else if (flag_strict_aliasing)
2316         /* Indicate we need to make a unique alias set for this pointer.
2317            We can't do it here because it might be pointing to an
2318            incomplete type.  */
2319         DECL_POINTER_ALIAS_SET (decl) = -2;
2320     }
2321 }
2322
2323
2324 /* Return the typed-based alias set for T, which may be an expression
2325    or a type.  Return -1 if we don't do anything special.  */
2326
2327 HOST_WIDE_INT
2328 c_common_get_alias_set (t)
2329      tree t;
2330 {
2331   tree u;
2332
2333   /* We know nothing about vector types */
2334   if (TREE_CODE (t) == VECTOR_TYPE)
2335     return 0;
2336
2337   /* Permit type-punning when accessing a union, provided the access
2338      is directly through the union.  For example, this code does not
2339      permit taking the address of a union member and then storing
2340      through it.  Even the type-punning allowed here is a GCC
2341      extension, albeit a common and useful one; the C standard says
2342      that such accesses have implementation-defined behavior.  */
2343   for (u = t;
2344        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2345        u = TREE_OPERAND (u, 0))
2346     if (TREE_CODE (u) == COMPONENT_REF
2347         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2348       return 0;
2349
2350   /* If this is a char *, the ANSI C standard says it can alias
2351      anything.  Note that all references need do this.  */
2352   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2353       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2354       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2355     return 0;
2356
2357   /* That's all the expressions we handle specially.  */
2358   if (! TYPE_P (t))
2359     return -1;
2360
2361   /* The C standard specifically allows aliasing between signed and
2362      unsigned variants of the same type.  We treat the signed
2363      variant as canonical.  */
2364   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2365     {
2366       tree t1 = signed_type (t);
2367
2368       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2369       if (t1 != t)
2370         return get_alias_set (t1);
2371     }
2372   else if (POINTER_TYPE_P (t))
2373     {
2374       tree t1;
2375
2376       /* Unfortunately, there is no canonical form of a pointer type.
2377          In particular, if we have `typedef int I', then `int *', and
2378          `I *' are different types.  So, we have to pick a canonical
2379          representative.  We do this below.
2380
2381          Technically, this approach is actually more conservative that
2382          it needs to be.  In particular, `const int *' and `int *'
2383          should be in different alias sets, according to the C and C++
2384          standard, since their types are not the same, and so,
2385          technically, an `int **' and `const int **' cannot point at
2386          the same thing.
2387
2388          But, the standard is wrong.  In particular, this code is
2389          legal C++:
2390
2391             int *ip;
2392             int **ipp = &ip;
2393             const int* const* cipp = &ipp;
2394
2395          And, it doesn't make sense for that to be legal unless you
2396          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2397          the pointed-to types.  This issue has been reported to the
2398          C++ committee.  */
2399       t1 = build_type_no_quals (t);
2400       if (t1 != t)
2401         return get_alias_set (t1);
2402     }
2403
2404   return -1;
2405 }
2406 \f
2407 /* Implement the __alignof keyword: Return the minimum required
2408    alignment of TYPE, measured in bytes.  */
2409
2410 tree
2411 c_alignof (type)
2412      tree type;
2413 {
2414   enum tree_code code = TREE_CODE (type);
2415   tree t;
2416
2417   /* In C++, sizeof applies to the referent.  Handle alignof the same way.  */
2418   if (code == REFERENCE_TYPE)
2419     {
2420       type = TREE_TYPE (type);
2421       code = TREE_CODE (type);
2422     }
2423
2424   if (code == FUNCTION_TYPE)
2425     t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2426   else if (code == VOID_TYPE || code == ERROR_MARK)
2427     t = size_one_node;
2428   else if (!COMPLETE_TYPE_P (type))
2429     {
2430       error ("__alignof__ applied to an incomplete type");
2431       t = size_zero_node;
2432     }
2433   else
2434     t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2435
2436   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2437 }
2438
2439 /* Implement the __alignof keyword: Return the minimum required
2440    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2441    FIELD_DECL's return DECL_ALIGN (which can be set from an
2442    "aligned" __attribute__ specification).  */
2443
2444 tree
2445 c_alignof_expr (expr)
2446      tree expr;
2447 {
2448   tree t;
2449
2450   if (TREE_CODE (expr) == VAR_DECL)
2451     t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2452
2453   else if (TREE_CODE (expr) == COMPONENT_REF
2454            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2455     {
2456       error ("`__alignof' applied to a bit-field");
2457       t = size_one_node;
2458     }
2459   else if (TREE_CODE (expr) == COMPONENT_REF
2460            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2461     t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2462
2463   else if (TREE_CODE (expr) == INDIRECT_REF)
2464     {
2465       tree t = TREE_OPERAND (expr, 0);
2466       tree best = t;
2467       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2468
2469       while (TREE_CODE (t) == NOP_EXPR
2470              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2471         {
2472           int thisalign;
2473
2474           t = TREE_OPERAND (t, 0);
2475           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2476           if (thisalign > bestalign)
2477             best = t, bestalign = thisalign;
2478         }
2479       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2480     }
2481   else
2482     return c_alignof (TREE_TYPE (expr));
2483
2484   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2485 }
2486 \f
2487 /* Give the specifications for the format attributes, used by C and all
2488    descendents.  */
2489
2490 static const struct attribute_spec c_format_attribute_table[] =
2491 {
2492   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2493   { "format",                 3, 3, false, true,  true,
2494                               handle_format_attribute },
2495   { "format_arg",             1, 1, false, true,  true,
2496                               handle_format_arg_attribute },
2497   { NULL,                     0, 0, false, false, false, NULL }
2498 };
2499
2500 /* Build tree nodes and builtin functions common to both C and C++ language
2501    frontends.  */
2502
2503 void
2504 c_common_nodes_and_builtins ()
2505 {
2506   enum builtin_type
2507   {
2508 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2509 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2510 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2511 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2512 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2513 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2514 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2515 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2516 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2517 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2518 #include "builtin-types.def"
2519 #undef DEF_PRIMITIVE_TYPE
2520 #undef DEF_FUNCTION_TYPE_0
2521 #undef DEF_FUNCTION_TYPE_1
2522 #undef DEF_FUNCTION_TYPE_2
2523 #undef DEF_FUNCTION_TYPE_3
2524 #undef DEF_FUNCTION_TYPE_4
2525 #undef DEF_FUNCTION_TYPE_VAR_0
2526 #undef DEF_FUNCTION_TYPE_VAR_1
2527 #undef DEF_FUNCTION_TYPE_VAR_2
2528 #undef DEF_POINTER_TYPE
2529     BT_LAST
2530   };
2531
2532   typedef enum builtin_type builtin_type;
2533
2534   tree builtin_types[(int) BT_LAST];
2535   int wchar_type_size;
2536   tree array_domain_type;
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   set_sizetype (c_size_type_node);
2611
2612   build_common_tree_nodes_2 (flag_short_double);
2613
2614   record_builtin_type (RID_FLOAT, NULL, float_type_node);
2615   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2616   record_builtin_type (RID_MAX, "long double", long_double_type_node);
2617
2618   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2619                         complex_integer_type_node));
2620   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2621                         complex_float_type_node));
2622   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2623                         complex_double_type_node));
2624   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2625                         complex_long_double_type_node));
2626
2627   record_builtin_type (RID_VOID, NULL, void_type_node);
2628
2629   void_zero_node = build_int_2 (0, 0);
2630   TREE_TYPE (void_zero_node) = void_type_node;
2631
2632   void_list_node = build_void_list_node ();
2633
2634   /* Make a type to be the domain of a few array types
2635      whose domains don't really matter.
2636      200 is small enough that it always fits in size_t
2637      and large enough that it can hold most function names for the
2638      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
2639   array_domain_type = build_index_type (size_int (200));
2640
2641   /* Make a type for arrays of characters.
2642      With luck nothing will ever really depend on the length of this
2643      array type.  */
2644   char_array_type_node
2645     = build_array_type (char_type_node, array_domain_type);
2646
2647   /* Likewise for arrays of ints.  */
2648   int_array_type_node
2649     = build_array_type (integer_type_node, array_domain_type);
2650
2651   string_type_node = build_pointer_type (char_type_node);
2652   const_string_type_node
2653     = build_pointer_type (build_qualified_type
2654                           (char_type_node, TYPE_QUAL_CONST));
2655
2656   (*targetm.init_builtins) ();
2657
2658   /* This is special for C++ so functions can be overloaded.  */
2659   wchar_type_node = get_identifier (flag_short_wchar
2660                                     ? "short unsigned int"
2661                                     : WCHAR_TYPE);
2662   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2663   wchar_type_size = TYPE_PRECISION (wchar_type_node);
2664   if (c_language == clk_cplusplus)
2665     {
2666       if (TREE_UNSIGNED (wchar_type_node))
2667         wchar_type_node = make_unsigned_type (wchar_type_size);
2668       else
2669         wchar_type_node = make_signed_type (wchar_type_size);
2670       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2671     }
2672   else
2673     {
2674       signed_wchar_type_node = signed_type (wchar_type_node);
2675       unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2676     }
2677
2678   /* This is for wide string constants.  */
2679   wchar_array_type_node
2680     = build_array_type (wchar_type_node, array_domain_type);
2681
2682   wint_type_node =
2683     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2684
2685   intmax_type_node =
2686     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2687   uintmax_type_node =
2688     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2689
2690   default_function_type = build_function_type (integer_type_node, NULL_TREE);
2691   ptrdiff_type_node
2692     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2693   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2694
2695   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2696                         va_list_type_node));
2697
2698   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2699                         ptrdiff_type_node));
2700
2701   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2702                         sizetype));
2703
2704   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2705     {
2706       va_list_arg_type_node = va_list_ref_type_node =
2707         build_pointer_type (TREE_TYPE (va_list_type_node));
2708     }
2709   else
2710     {
2711       va_list_arg_type_node = va_list_type_node;
2712       va_list_ref_type_node = build_reference_type (va_list_type_node);
2713     }
2714
2715 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2716   builtin_types[(int) ENUM] = VALUE;
2717 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
2718   builtin_types[(int) ENUM]                             \
2719     = build_function_type (builtin_types[(int) RETURN], \
2720                            void_list_node);
2721 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
2722   builtin_types[(int) ENUM]                                             \
2723     = build_function_type (builtin_types[(int) RETURN],                 \
2724                            tree_cons (NULL_TREE,                        \
2725                                       builtin_types[(int) ARG1],        \
2726                                       void_list_node));
2727 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
2728   builtin_types[(int) ENUM]                             \
2729     = build_function_type                               \
2730       (builtin_types[(int) RETURN],                     \
2731        tree_cons (NULL_TREE,                            \
2732                   builtin_types[(int) ARG1],            \
2733                   tree_cons (NULL_TREE,                 \
2734                              builtin_types[(int) ARG2], \
2735                              void_list_node)));
2736 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
2737   builtin_types[(int) ENUM]                                              \
2738     = build_function_type                                                \
2739       (builtin_types[(int) RETURN],                                      \
2740        tree_cons (NULL_TREE,                                             \
2741                   builtin_types[(int) ARG1],                             \
2742                   tree_cons (NULL_TREE,                                  \
2743                              builtin_types[(int) ARG2],                  \
2744                              tree_cons (NULL_TREE,                       \
2745                                         builtin_types[(int) ARG3],       \
2746                                         void_list_node))));
2747 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
2748   builtin_types[(int) ENUM]                                             \
2749     = build_function_type                                               \
2750       (builtin_types[(int) RETURN],                                     \
2751        tree_cons (NULL_TREE,                                            \
2752                   builtin_types[(int) ARG1],                            \
2753                   tree_cons (NULL_TREE,                                 \
2754                              builtin_types[(int) ARG2],                 \
2755                              tree_cons                                  \
2756                              (NULL_TREE,                                \
2757                               builtin_types[(int) ARG3],                \
2758                               tree_cons (NULL_TREE,                     \
2759                                          builtin_types[(int) ARG4],     \
2760                                          void_list_node)))));
2761 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
2762   builtin_types[(int) ENUM]                                             \
2763     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2764 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
2765    builtin_types[(int) ENUM]                                             \
2766     = build_function_type (builtin_types[(int) RETURN],                  \
2767                            tree_cons (NULL_TREE,                         \
2768                                       builtin_types[(int) ARG1],         \
2769                                       NULL_TREE));
2770
2771 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
2772    builtin_types[(int) ENUM]                                    \
2773     = build_function_type                                       \
2774       (builtin_types[(int) RETURN],                             \
2775        tree_cons (NULL_TREE,                                    \
2776                   builtin_types[(int) ARG1],                    \
2777                   tree_cons (NULL_TREE,                         \
2778                              builtin_types[(int) ARG2],         \
2779                              NULL_TREE)));
2780 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
2781   builtin_types[(int) ENUM]                             \
2782     = build_pointer_type (builtin_types[(int) TYPE]);
2783 #include "builtin-types.def"
2784 #undef DEF_PRIMITIVE_TYPE
2785 #undef DEF_FUNCTION_TYPE_1
2786 #undef DEF_FUNCTION_TYPE_2
2787 #undef DEF_FUNCTION_TYPE_3
2788 #undef DEF_FUNCTION_TYPE_4
2789 #undef DEF_FUNCTION_TYPE_VAR_0
2790 #undef DEF_FUNCTION_TYPE_VAR_1
2791 #undef DEF_POINTER_TYPE
2792
2793 #define DEF_BUILTIN(ENUM, NAME, CLASS,                                  \
2794                     TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P)       \
2795   if (NAME)                                                             \
2796     {                                                                   \
2797       tree decl;                                                        \
2798                                                                         \
2799       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
2800         abort ();                                                       \
2801                                                                         \
2802       if (!BOTH_P)                                                      \
2803         decl = builtin_function (NAME, builtin_types[TYPE], ENUM,       \
2804                                  CLASS,                                 \
2805                                  (FALLBACK_P                            \
2806                                   ? (NAME + strlen ("__builtin_"))      \
2807                                   : NULL));                             \
2808       else                                                              \
2809         decl = builtin_function_2 (NAME,                                \
2810                                    NAME + strlen ("__builtin_"),        \
2811                                    builtin_types[TYPE],                 \
2812                                    builtin_types[LIBTYPE],              \
2813                                    ENUM,                                \
2814                                    CLASS,                               \
2815                                    FALLBACK_P,                          \
2816                                    NONANSI_P,                           \
2817                                    /*noreturn_p=*/0);                   \
2818                                                                         \
2819       built_in_decls[(int) ENUM] = decl;                                \
2820     }
2821 #include "builtins.def"
2822 #undef DEF_BUILTIN
2823
2824   /* Declare _exit and _Exit just to mark them as non-returning.  */
2825   builtin_function_2 (NULL, "_exit", NULL_TREE,
2826                       builtin_types[BT_FN_VOID_INT],
2827                       0, NOT_BUILT_IN, 0, 1, 1);
2828   builtin_function_2 (NULL, "_Exit", NULL_TREE,
2829                       builtin_types[BT_FN_VOID_INT],
2830                       0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2831
2832   /* Declare these functions non-returning
2833      to avoid spurious "control drops through" warnings.  */
2834   builtin_function_2 (NULL, "abort",
2835                       NULL_TREE, ((c_language == clk_cplusplus)
2836                                   ? builtin_types[BT_FN_VOID]
2837                                   : builtin_types[BT_FN_VOID_VAR]),
2838                       0, NOT_BUILT_IN, 0, 0, 1);
2839
2840   builtin_function_2 (NULL, "exit",
2841                       NULL_TREE, ((c_language == clk_cplusplus)
2842                                   ? builtin_types[BT_FN_VOID_INT]
2843                                   : builtin_types[BT_FN_VOID_VAR]),
2844                       0, NOT_BUILT_IN, 0, 0, 1);
2845
2846   main_identifier_node = get_identifier ("main");
2847
2848   /* ??? Perhaps there's a better place to do this.  But it is related
2849      to __builtin_va_arg, so it isn't that off-the-wall.  */
2850   lang_type_promotes_to = simple_type_promotes_to;
2851 }
2852
2853 tree
2854 build_va_arg (expr, type)
2855      tree expr, type;
2856 {
2857   return build1 (VA_ARG_EXPR, type, expr);
2858 }
2859
2860
2861 /* Linked list of disabled built-in functions.  */
2862
2863 typedef struct disabled_builtin
2864 {
2865   const char *name;
2866   struct disabled_builtin *next;
2867 } disabled_builtin;
2868 static disabled_builtin *disabled_builtins = NULL;
2869
2870 static bool builtin_function_disabled_p PARAMS ((const char *));
2871
2872 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
2873    begins with "__builtin_", give an error.  */
2874
2875 void
2876 disable_builtin_function (name)
2877      const char *name;
2878 {
2879   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2880     error ("cannot disable built-in function `%s'", name);
2881   else
2882     {
2883       disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2884       new->name = name;
2885       new->next = disabled_builtins;
2886       disabled_builtins = new;
2887     }
2888 }
2889
2890
2891 /* Return true if the built-in function NAME has been disabled, false
2892    otherwise.  */
2893
2894 static bool
2895 builtin_function_disabled_p (name)
2896      const char *name;
2897 {
2898   disabled_builtin *p;
2899   for (p = disabled_builtins; p != NULL; p = p->next)
2900     {
2901       if (strcmp (name, p->name) == 0)
2902         return true;
2903     }
2904   return false;
2905 }
2906
2907
2908 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
2909    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2910    of these may be NULL (though both being NULL is useless).
2911    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2912    TYPE is the type of the function with the ordinary name.  These
2913    may differ if the ordinary name is declared with a looser type to avoid
2914    conflicts with headers.  FUNCTION_CODE and CLASS are as for
2915    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
2916    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2917    If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2918    NORETURN_P is nonzero, the function is marked as non-returning.
2919    Returns the declaration of BUILTIN_NAME, if any, otherwise
2920    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
2921    or if NONANSI_P and flag_no_nonansi_builtin.  */
2922
2923 static tree
2924 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2925                     class, library_name_p, nonansi_p, noreturn_p)
2926      const char *builtin_name;
2927      const char *name;
2928      tree builtin_type;
2929      tree type;
2930      int function_code;
2931      enum built_in_class class;
2932      int library_name_p;
2933      int nonansi_p;
2934      int noreturn_p;
2935 {
2936   tree bdecl = NULL_TREE;
2937   tree decl = NULL_TREE;
2938   if (builtin_name != 0)
2939     {
2940       bdecl = builtin_function (builtin_name, builtin_type, function_code,
2941                                 class, library_name_p ? name : NULL);
2942       if (noreturn_p)
2943         {
2944           TREE_THIS_VOLATILE (bdecl) = 1;
2945           TREE_SIDE_EFFECTS (bdecl) = 1;
2946         }
2947     }
2948   if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
2949       && !(nonansi_p && flag_no_nonansi_builtin))
2950     {
2951       decl = builtin_function (name, type, function_code, class, NULL);
2952       if (nonansi_p)
2953         DECL_BUILT_IN_NONANSI (decl) = 1;
2954       if (noreturn_p)
2955         {
2956           TREE_THIS_VOLATILE (decl) = 1;
2957           TREE_SIDE_EFFECTS (decl) = 1;
2958         }
2959     }
2960   return (bdecl != 0 ? bdecl : decl);
2961 }
2962 \f
2963 /* Nonzero if the type T promotes to int.  This is (nearly) the
2964    integral promotions defined in ISO C99 6.3.1.1/2.  */
2965
2966 bool
2967 c_promoting_integer_type_p (t)
2968      tree t;
2969 {
2970   switch (TREE_CODE (t))
2971     {
2972     case INTEGER_TYPE:
2973       return (TYPE_MAIN_VARIANT (t) == char_type_node
2974               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2975               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2976               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2977               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
2978               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
2979
2980     case ENUMERAL_TYPE:
2981       /* ??? Technically all enumerations not larger than an int
2982          promote to an int.  But this is used along code paths
2983          that only want to notice a size change.  */
2984       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
2985
2986     case BOOLEAN_TYPE:
2987       return 1;
2988
2989     default:
2990       return 0;
2991     }
2992 }
2993
2994 /* Given a type, apply default promotions wrt unnamed function arguments
2995    and return the new type.  Return NULL_TREE if no change.  */
2996 /* ??? There is a function of the same name in the C++ front end that
2997    does something similar, but is more thorough and does not return NULL
2998    if no change.  We could perhaps share code, but it would make the
2999    self_promoting_type property harder to identify.  */
3000
3001 tree
3002 simple_type_promotes_to (type)
3003      tree type;
3004 {
3005   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3006     return double_type_node;
3007
3008   if (c_promoting_integer_type_p (type))
3009     {
3010       /* Preserve unsignedness if not really getting any wider.  */
3011       if (TREE_UNSIGNED (type)
3012           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3013         return unsigned_type_node;
3014       return integer_type_node;
3015     }
3016
3017   return NULL_TREE;
3018 }
3019
3020 /* Return 1 if PARMS specifies a fixed number of parameters
3021    and none of their types is affected by default promotions.  */
3022
3023 int
3024 self_promoting_args_p (parms)
3025      tree parms;
3026 {
3027   tree t;
3028   for (t = parms; t; t = TREE_CHAIN (t))
3029     {
3030       tree type = TREE_VALUE (t);
3031
3032       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3033         return 0;
3034
3035       if (type == 0)
3036         return 0;
3037
3038       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3039         return 0;
3040
3041       if (c_promoting_integer_type_p (type))
3042         return 0;
3043     }
3044   return 1;
3045 }
3046
3047 /* Recursively examines the array elements of TYPE, until a non-array
3048    element type is found.  */
3049
3050 tree
3051 strip_array_types (type)
3052      tree type;
3053 {
3054   while (TREE_CODE (type) == ARRAY_TYPE)
3055     type = TREE_TYPE (type);
3056
3057   return type;
3058 }
3059
3060 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3061                                           enum tree_code));
3062
3063 /* Expand a call to an unordered comparison function such as
3064    __builtin_isgreater().  FUNCTION is the function's declaration and
3065    PARAMS a list of the values passed.  For __builtin_isunordered(),
3066    UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR.  In
3067    other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3068    that give the opposite of the desired result.  UNORDERED_CODE is
3069    used for modes that can hold NaNs and ORDERED_CODE is used for the
3070    rest.  */
3071
3072 static tree
3073 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3074      tree function, params;
3075      enum tree_code unordered_code, ordered_code;
3076 {
3077   tree arg0, arg1, type;
3078   enum tree_code code0, code1;
3079
3080   /* Check that we have exactly two arguments.  */
3081   if (params == 0 || TREE_CHAIN (params) == 0)
3082     {
3083       error ("too few arguments to function `%s'",
3084              IDENTIFIER_POINTER (DECL_NAME (function)));
3085       return error_mark_node;
3086     }
3087   else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3088     {
3089       error ("too many arguments to function `%s'",
3090              IDENTIFIER_POINTER (DECL_NAME (function)));
3091       return error_mark_node;
3092     }
3093
3094   arg0 = TREE_VALUE (params);
3095   arg1 = TREE_VALUE (TREE_CHAIN (params));
3096
3097   code0 = TREE_CODE (TREE_TYPE (arg0));
3098   code1 = TREE_CODE (TREE_TYPE (arg1));
3099
3100   /* Make sure that the arguments have a common type of REAL.  */
3101   type = 0;
3102   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3103       && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3104     type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3105
3106   if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3107     {
3108       error ("non-floating-point argument to function `%s'",
3109              IDENTIFIER_POINTER (DECL_NAME (function)));
3110       return error_mark_node;
3111     }
3112
3113   if (unordered_code == UNORDERED_EXPR)
3114     {
3115       if (MODE_HAS_NANS (TYPE_MODE (type)))
3116         return build_binary_op (unordered_code,
3117                                 convert (type, arg0),
3118                                 convert (type, arg1),
3119                                 0);
3120       else
3121         return integer_zero_node;
3122     }
3123
3124   return build_unary_op (TRUTH_NOT_EXPR,
3125                          build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3126                                           ? unordered_code
3127                                           : ordered_code,
3128                                           convert (type, arg0),
3129                                           convert (type, arg1),
3130                                           0),
3131                          0);
3132 }
3133
3134
3135 /* Recognize certain built-in functions so we can make tree-codes
3136    other than CALL_EXPR.  We do this when it enables fold-const.c
3137    to do something useful.  */
3138 /* ??? By rights this should go in builtins.c, but only C and C++
3139    implement build_{binary,unary}_op.  Not exactly sure what bits
3140    of functionality are actually needed from those functions, or
3141    where the similar functionality exists in the other front ends.  */
3142
3143 tree
3144 expand_tree_builtin (function, params, coerced_params)
3145      tree function, params, coerced_params;
3146 {
3147   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3148     return NULL_TREE;
3149
3150   switch (DECL_FUNCTION_CODE (function))
3151     {
3152     case BUILT_IN_ABS:
3153     case BUILT_IN_LABS:
3154     case BUILT_IN_LLABS:
3155     case BUILT_IN_IMAXABS:
3156     case BUILT_IN_FABS:
3157     case BUILT_IN_FABSL:
3158     case BUILT_IN_FABSF:
3159       if (coerced_params == 0)
3160         return integer_zero_node;
3161       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3162
3163     case BUILT_IN_CONJ:
3164     case BUILT_IN_CONJF:
3165     case BUILT_IN_CONJL:
3166       if (coerced_params == 0)
3167         return integer_zero_node;
3168       return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3169
3170     case BUILT_IN_CREAL:
3171     case BUILT_IN_CREALF:
3172     case BUILT_IN_CREALL:
3173       if (coerced_params == 0)
3174         return integer_zero_node;
3175       return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3176
3177     case BUILT_IN_CIMAG:
3178     case BUILT_IN_CIMAGF:
3179     case BUILT_IN_CIMAGL:
3180       if (coerced_params == 0)
3181         return integer_zero_node;
3182       return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3183
3184     case BUILT_IN_ISGREATER:
3185       return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3186
3187     case BUILT_IN_ISGREATEREQUAL:
3188       return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3189
3190     case BUILT_IN_ISLESS:
3191       return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3192
3193     case BUILT_IN_ISLESSEQUAL:
3194       return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3195
3196     case BUILT_IN_ISLESSGREATER:
3197       return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3198
3199     case BUILT_IN_ISUNORDERED:
3200       return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3201
3202     default:
3203       break;
3204     }
3205
3206   return NULL_TREE;
3207 }
3208
3209 /* Returns non-zero if CODE is the code for a statement.  */
3210
3211 int
3212 statement_code_p (code)
3213      enum tree_code code;
3214 {
3215   switch (code)
3216     {
3217     case CLEANUP_STMT:
3218     case EXPR_STMT:
3219     case COMPOUND_STMT:
3220     case DECL_STMT:
3221     case IF_STMT:
3222     case FOR_STMT:
3223     case WHILE_STMT:
3224     case DO_STMT:
3225     case RETURN_STMT:
3226     case BREAK_STMT:
3227     case CONTINUE_STMT:
3228     case SCOPE_STMT:
3229     case SWITCH_STMT:
3230     case GOTO_STMT:
3231     case LABEL_STMT:
3232     case ASM_STMT:
3233     case FILE_STMT:
3234     case CASE_LABEL:
3235       return 1;
3236
3237     default:
3238       if (lang_statement_code_p)
3239         return (*lang_statement_code_p) (code);
3240       return 0;
3241     }
3242 }
3243
3244 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3245    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3246    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3247    value, the traversal is aborted, and the value returned by FUNC is
3248    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3249    the node being visited are not walked.
3250
3251    We don't need a without_duplicates variant of this one because the
3252    statement tree is a tree, not a graph.  */
3253
3254 tree
3255 walk_stmt_tree (tp, func, data)
3256      tree *tp;
3257      walk_tree_fn func;
3258      void *data;
3259 {
3260   enum tree_code code;
3261   int walk_subtrees;
3262   tree result;
3263   int i, len;
3264
3265 #define WALK_SUBTREE(NODE)                              \
3266   do                                                    \
3267     {                                                   \
3268       result = walk_stmt_tree (&(NODE), func, data);    \
3269       if (result)                                       \
3270         return result;                                  \
3271     }                                                   \
3272   while (0)
3273
3274   /* Skip empty subtrees.  */
3275   if (!*tp)
3276     return NULL_TREE;
3277
3278   /* Skip subtrees below non-statement nodes.  */
3279   if (!statement_code_p (TREE_CODE (*tp)))
3280     return NULL_TREE;
3281
3282   /* Call the function.  */
3283   walk_subtrees = 1;
3284   result = (*func) (tp, &walk_subtrees, data);
3285
3286   /* If we found something, return it.  */
3287   if (result)
3288     return result;
3289
3290   /* FUNC may have modified the tree, recheck that we're looking at a
3291      statement node.  */
3292   code = TREE_CODE (*tp);
3293   if (!statement_code_p (code))
3294     return NULL_TREE;
3295
3296   /* Visit the subtrees unless FUNC decided that there was nothing
3297      interesting below this point in the tree.  */
3298   if (walk_subtrees)
3299     {
3300       /* Walk over all the sub-trees of this operand.  Statement nodes
3301          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3302       len = TREE_CODE_LENGTH (code);
3303
3304       /* Go through the subtrees.  We need to do this in forward order so
3305          that the scope of a FOR_EXPR is handled properly.  */
3306       for (i = 0; i < len; ++i)
3307         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3308     }
3309
3310   /* Finally visit the chain.  This can be tail-recursion optimized if
3311      we write it this way.  */
3312   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3313
3314 #undef WALK_SUBTREE
3315 }
3316
3317 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3318    representing case labels, or NULL_TREE for a `default' label.
3319    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3320    K2, and 0 if K1 and K2 are equal.  */
3321
3322 int
3323 case_compare (k1, k2)
3324      splay_tree_key k1;
3325      splay_tree_key k2;
3326 {
3327   /* Consider a NULL key (such as arises with a `default' label) to be
3328      smaller than anything else.  */
3329   if (!k1)
3330     return k2 ? -1 : 0;
3331   else if (!k2)
3332     return k1 ? 1 : 0;
3333
3334   return tree_int_cst_compare ((tree) k1, (tree) k2);
3335 }
3336
3337 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3338    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3339    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3340    case label was declared using the usual C/C++ syntax, rather than
3341    the GNU case range extension.  CASES is a tree containing all the
3342    case ranges processed so far; COND is the condition for the
3343    switch-statement itself.  Returns the CASE_LABEL created, or
3344    ERROR_MARK_NODE if no CASE_LABEL is created.  */
3345
3346 tree
3347 c_add_case_label (cases, cond, low_value, high_value)
3348      splay_tree cases;
3349      tree cond;
3350      tree low_value;
3351      tree high_value;
3352 {
3353   tree type;
3354   tree label;
3355   tree case_label;
3356   splay_tree_node node;
3357
3358   /* Create the LABEL_DECL itself.  */
3359   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3360   DECL_CONTEXT (label) = current_function_decl;
3361
3362   /* If there was an error processing the switch condition, bail now
3363      before we get more confused.  */
3364   if (!cond || cond == error_mark_node)
3365     {
3366       /* Add a label anyhow so that the back-end doesn't think that
3367          the beginning of the switch is unreachable.  */
3368       if (!cases->root)
3369         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3370       return error_mark_node;
3371     }
3372
3373   if ((low_value && TREE_TYPE (low_value)
3374        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3375       || (high_value && TREE_TYPE (high_value)
3376           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3377     error ("pointers are not permitted as case values");
3378
3379   /* Case ranges are a GNU extension.  */
3380   if (high_value && pedantic)
3381     {
3382       if (c_language == clk_cplusplus)
3383         pedwarn ("ISO C++ forbids range expressions in switch statements");
3384       else
3385         pedwarn ("ISO C forbids range expressions in switch statements");
3386     }
3387
3388   type = TREE_TYPE (cond);
3389   if (low_value)
3390     {
3391       low_value = check_case_value (low_value);
3392       low_value = convert_and_check (type, low_value);
3393     }
3394   if (high_value)
3395     {
3396       high_value = check_case_value (high_value);
3397       high_value = convert_and_check (type, high_value);
3398     }
3399
3400   /* If an error has occurred, bail out now.  */
3401   if (low_value == error_mark_node || high_value == error_mark_node)
3402     {
3403       if (!cases->root)
3404         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3405       return error_mark_node;
3406     }
3407
3408   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3409      really a case range, even though it was written that way.  Remove
3410      the HIGH_VALUE to simplify later processing.  */
3411   if (tree_int_cst_equal (low_value, high_value))
3412     high_value = NULL_TREE;
3413   if (low_value && high_value
3414       && !tree_int_cst_lt (low_value, high_value))
3415     warning ("empty range specified");
3416
3417   /* Look up the LOW_VALUE in the table of case labels we already
3418      have.  */
3419   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3420   /* If there was not an exact match, check for overlapping ranges.
3421      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3422      that's a `default' label and the only overlap is an exact match.  */
3423   if (!node && (low_value || high_value))
3424     {
3425       splay_tree_node low_bound;
3426       splay_tree_node high_bound;
3427
3428       /* Even though there wasn't an exact match, there might be an
3429          overlap between this case range and another case range.
3430          Since we've (inductively) not allowed any overlapping case
3431          ranges, we simply need to find the greatest low case label
3432          that is smaller that LOW_VALUE, and the smallest low case
3433          label that is greater than LOW_VALUE.  If there is an overlap
3434          it will occur in one of these two ranges.  */
3435       low_bound = splay_tree_predecessor (cases,
3436                                           (splay_tree_key) low_value);
3437       high_bound = splay_tree_successor (cases,
3438                                          (splay_tree_key) low_value);
3439
3440       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3441          the LOW_VALUE, so there is no need to check unless the
3442          LOW_BOUND is in fact itself a case range.  */
3443       if (low_bound
3444           && CASE_HIGH ((tree) low_bound->value)
3445           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3446                                     low_value) >= 0)
3447         node = low_bound;
3448       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3449          range is bigger than the low end of the current range, so we
3450          are only interested if the current range is a real range, and
3451          not an ordinary case label.  */
3452       else if (high_bound
3453                && high_value
3454                && (tree_int_cst_compare ((tree) high_bound->key,
3455                                          high_value)
3456                    <= 0))
3457         node = high_bound;
3458     }
3459   /* If there was an overlap, issue an error.  */
3460   if (node)
3461     {
3462       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3463
3464       if (high_value)
3465         {
3466           error ("duplicate (or overlapping) case value");
3467           error_with_decl (duplicate,
3468                            "this is the first entry overlapping that value");
3469         }
3470       else if (low_value)
3471         {
3472           error ("duplicate case value") ;
3473           error_with_decl (duplicate, "previously used here");
3474         }
3475       else
3476         {
3477           error ("multiple default labels in one switch");
3478           error_with_decl (duplicate, "this is the first default label");
3479         }
3480       if (!cases->root)
3481         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3482     }
3483
3484   /* Add a CASE_LABEL to the statement-tree.  */
3485   case_label = add_stmt (build_case_label (low_value, high_value, label));
3486   /* Register this case label in the splay tree.  */
3487   splay_tree_insert (cases,
3488                      (splay_tree_key) low_value,
3489                      (splay_tree_value) case_label);
3490
3491   return case_label;
3492 }
3493
3494 /* Finish an expression taking the address of LABEL.  Returns an
3495    expression for the address.  */
3496
3497 tree
3498 finish_label_address_expr (label)
3499      tree label;
3500 {
3501   tree result;
3502
3503   if (pedantic)
3504     {
3505       if (c_language == clk_cplusplus)
3506         pedwarn ("ISO C++ forbids taking the address of a label");
3507       else
3508         pedwarn ("ISO C forbids taking the address of a label");
3509     }
3510
3511   label = lookup_label (label);
3512   if (label == NULL_TREE)
3513     result = null_pointer_node;
3514   else
3515     {
3516       TREE_USED (label) = 1;
3517       result = build1 (ADDR_EXPR, ptr_type_node, label);
3518       TREE_CONSTANT (result) = 1;
3519       /* The current function in not necessarily uninlinable.
3520          Computed gotos are incompatible with inlining, but the value
3521          here could be used only in a diagnostic, for example.  */
3522     }
3523
3524   return result;
3525 }
3526
3527 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
3528    parameter allows this function to be used as a GC-marking
3529    function.  */
3530
3531 void
3532 mark_stmt_tree (p)
3533      void *p;
3534 {
3535   stmt_tree st = (stmt_tree) p;
3536
3537   ggc_mark_tree (st->x_last_stmt);
3538   ggc_mark_tree (st->x_last_expr_type);
3539 }
3540
3541 /* Mark LD for GC.  */
3542
3543 void
3544 c_mark_lang_decl (c)
3545      struct c_lang_decl *c ATTRIBUTE_UNUSED;
3546 {
3547 }
3548
3549 /* Mark F for GC.  */
3550
3551 void
3552 mark_c_language_function (f)
3553      struct language_function *f;
3554 {
3555   if (!f)
3556     return;
3557
3558   mark_stmt_tree (&f->x_stmt_tree);
3559   ggc_mark_tree (f->x_scope_stmt_stack);
3560 }
3561
3562 /* Hook used by expand_expr to expand language-specific tree codes.  */
3563
3564 rtx
3565 c_expand_expr (exp, target, tmode, modifier)
3566      tree exp;
3567      rtx target;
3568      enum machine_mode tmode;
3569      enum expand_modifier modifier;
3570 {
3571   switch (TREE_CODE (exp))
3572     {
3573     case STMT_EXPR:
3574       {
3575         tree rtl_expr;
3576         rtx result;
3577         bool preserve_result = false;
3578
3579         /* Since expand_expr_stmt calls free_temp_slots after every
3580            expression statement, we must call push_temp_slots here.
3581            Otherwise, any temporaries in use now would be considered
3582            out-of-scope after the first EXPR_STMT from within the
3583            STMT_EXPR.  */
3584         push_temp_slots ();
3585         rtl_expr = expand_start_stmt_expr ();
3586
3587         /* If we want the result of this expression, find the last
3588            EXPR_STMT in the COMPOUND_STMT and mark it as addressable.  */
3589         if (target != const0_rtx
3590             && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3591             && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3592           {
3593             tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3594             tree last = TREE_CHAIN (expr);
3595
3596             while (TREE_CHAIN (last))
3597               {
3598                 expr = last;
3599                 last = TREE_CHAIN (last);
3600               }
3601
3602             if (TREE_CODE (last) == SCOPE_STMT
3603                 && TREE_CODE (expr) == EXPR_STMT)
3604               {
3605                 TREE_ADDRESSABLE (expr) = 1;
3606                 preserve_result = true;
3607               }
3608           }
3609
3610         expand_stmt (STMT_EXPR_STMT (exp));
3611         expand_end_stmt_expr (rtl_expr);
3612
3613         result = expand_expr (rtl_expr, target, tmode, modifier);
3614         if (preserve_result && GET_CODE (result) == MEM)
3615           {
3616             if (GET_MODE (result) != BLKmode)
3617               result = copy_to_reg (result);
3618             else
3619               preserve_temp_slots (result);
3620           }
3621
3622         pop_temp_slots ();
3623         return result;
3624       }
3625       break;
3626
3627     case CALL_EXPR:
3628       {
3629         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3630             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3631                 == FUNCTION_DECL)
3632             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3633             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3634                 == BUILT_IN_FRONTEND))
3635           return c_expand_builtin (exp, target, tmode, modifier);
3636         else
3637           abort ();
3638       }
3639       break;
3640
3641     case COMPOUND_LITERAL_EXPR:
3642       {
3643         /* Initialize the anonymous variable declared in the compound
3644            literal, then return the variable.  */
3645         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3646         emit_local_var (decl);
3647         return expand_expr (decl, target, tmode, modifier);
3648       }
3649
3650     default:
3651       abort ();
3652     }
3653
3654   abort ();
3655   return NULL;
3656 }
3657
3658 /* Hook used by safe_from_p to handle language-specific tree codes.  */
3659
3660 int
3661 c_safe_from_p (target, exp)
3662      rtx target;
3663      tree exp;
3664 {
3665   /* We can see statements here when processing the body of a
3666      statement-expression.  For a declaration statement declaring a
3667      variable, look at the variable's initializer.  */
3668   if (TREE_CODE (exp) == DECL_STMT)
3669     {
3670       tree decl = DECL_STMT_DECL (exp);
3671
3672       if (TREE_CODE (decl) == VAR_DECL
3673           && DECL_INITIAL (decl)
3674           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3675         return 0;
3676     }
3677
3678   /* For any statement, we must follow the statement-chain.  */
3679   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3680     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3681
3682   /* Assume everything else is safe.  */
3683   return 1;
3684 }
3685
3686 /* Hook used by unsafe_for_reeval to handle language-specific tree codes.  */
3687
3688 int
3689 c_unsafe_for_reeval (exp)
3690      tree exp;
3691 {
3692   /* Statement expressions may not be reevaluated, likewise compound
3693      literals.  */
3694   if (TREE_CODE (exp) == STMT_EXPR
3695       || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3696     return 2;
3697
3698   /* Walk all other expressions.  */
3699   return -1;
3700 }
3701
3702 /* Hook used by staticp to handle language-specific tree codes.  */
3703
3704 int
3705 c_staticp (exp)
3706      tree exp;
3707 {
3708   if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3709       && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3710     return 1;
3711   return 0;
3712 }
3713
3714 #define CALLED_AS_BUILT_IN(NODE) \
3715    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3716
3717 static rtx
3718 c_expand_builtin (exp, target, tmode, modifier)
3719      tree exp;
3720      rtx target;
3721      enum machine_mode tmode;
3722      enum expand_modifier modifier;
3723 {
3724   tree type = TREE_TYPE (exp);
3725   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3726   tree arglist = TREE_OPERAND (exp, 1);
3727   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3728   enum tree_code code = TREE_CODE (exp);
3729   const int ignore = (target == const0_rtx
3730                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3731                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
3732                            || code == COND_EXPR)
3733                           && TREE_CODE (type) == VOID_TYPE));
3734
3735   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3736     return expand_call (exp, target, ignore);
3737
3738   switch (fcode)
3739     {
3740     case BUILT_IN_PRINTF:
3741       target = c_expand_builtin_printf (arglist, target, tmode,
3742                                         modifier, ignore, /*unlocked=*/ 0);
3743       if (target)
3744         return target;
3745       break;
3746
3747     case BUILT_IN_PRINTF_UNLOCKED:
3748       target = c_expand_builtin_printf (arglist, target, tmode,
3749                                         modifier, ignore, /*unlocked=*/ 1);
3750       if (target)
3751         return target;
3752       break;
3753
3754     case BUILT_IN_FPRINTF:
3755       target = c_expand_builtin_fprintf (arglist, target, tmode,
3756                                          modifier, ignore, /*unlocked=*/ 0);
3757       if (target)
3758         return target;
3759       break;
3760
3761     case BUILT_IN_FPRINTF_UNLOCKED:
3762       target = c_expand_builtin_fprintf (arglist, target, tmode,
3763                                          modifier, ignore, /*unlocked=*/ 1);
3764       if (target)
3765         return target;
3766       break;
3767
3768     default:                    /* just do library call, if unknown builtin */
3769       error ("built-in function `%s' not currently supported",
3770              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3771     }
3772
3773   /* The switch statement above can drop through to cause the function
3774      to be called normally.  */
3775   return expand_call (exp, target, ignore);
3776 }
3777
3778 /* Check an arglist to *printf for problems.  The arglist should start
3779    at the format specifier, with the remaining arguments immediately
3780    following it.  */
3781 static int
3782 is_valid_printf_arglist (arglist)
3783      tree arglist;
3784 {
3785   /* Save this value so we can restore it later.  */
3786   const int SAVE_pedantic = pedantic;
3787   int diagnostic_occurred = 0;
3788   tree attrs;
3789
3790   /* Set this to a known value so the user setting won't affect code
3791      generation.  */
3792   pedantic = 1;
3793   /* Check to make sure there are no format specifier errors.  */
3794   attrs = tree_cons (get_identifier ("format"),
3795                      tree_cons (NULL_TREE,
3796                                 get_identifier ("printf"),
3797                                 tree_cons (NULL_TREE,
3798                                            integer_one_node,
3799                                            tree_cons (NULL_TREE,
3800                                                       build_int_2 (2, 0),
3801                                                       NULL_TREE))),
3802                      NULL_TREE);
3803   check_function_format (&diagnostic_occurred, attrs, arglist);
3804
3805   /* Restore the value of `pedantic'.  */
3806   pedantic = SAVE_pedantic;
3807
3808   /* If calling `check_function_format_ptr' produces a warning, we
3809      return false, otherwise we return true.  */
3810   return ! diagnostic_occurred;
3811 }
3812
3813 /* If the arguments passed to printf are suitable for optimizations,
3814    we attempt to transform the call.  */
3815 static rtx
3816 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
3817      tree arglist;
3818      rtx target;
3819      enum machine_mode tmode;
3820      enum expand_modifier modifier;
3821      int ignore;
3822      int unlocked;
3823 {
3824   tree fn_putchar = unlocked ?
3825     built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
3826   tree fn_puts = unlocked ?
3827     built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
3828   tree fn, format_arg, stripped_string;
3829
3830   /* If the return value is used, or the replacement _DECL isn't
3831      initialized, don't do the transformation.  */
3832   if (!ignore || !fn_putchar || !fn_puts)
3833     return 0;
3834
3835   /* Verify the required arguments in the original call.  */
3836   if (arglist == 0
3837       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3838     return 0;
3839
3840   /* Check the specifier vs. the parameters.  */
3841   if (!is_valid_printf_arglist (arglist))
3842     return 0;
3843
3844   format_arg = TREE_VALUE (arglist);
3845   stripped_string = format_arg;
3846   STRIP_NOPS (stripped_string);
3847   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3848     stripped_string = TREE_OPERAND (stripped_string, 0);
3849
3850   /* If the format specifier isn't a STRING_CST, punt.  */
3851   if (TREE_CODE (stripped_string) != STRING_CST)
3852     return 0;
3853
3854   /* OK!  We can attempt optimization.  */
3855
3856   /* If the format specifier was "%s\n", call __builtin_puts(arg2).  */
3857   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3858     {
3859       arglist = TREE_CHAIN (arglist);
3860       fn = fn_puts;
3861     }
3862   /* If the format specifier was "%c", call __builtin_putchar (arg2).  */
3863   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3864     {
3865       arglist = TREE_CHAIN (arglist);
3866       fn = fn_putchar;
3867     }
3868   else
3869     {
3870       /* We can't handle anything else with % args or %% ... yet.  */
3871       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3872         return 0;
3873
3874       /* If the resulting constant string has a length of 1, call
3875          putchar.  Note, TREE_STRING_LENGTH includes the terminating
3876          NULL in its count.  */
3877       if (TREE_STRING_LENGTH (stripped_string) == 2)
3878         {
3879           /* Given printf("c"), (where c is any one character,)
3880              convert "c"[0] to an int and pass that to the replacement
3881              function.  */
3882           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3883           arglist = build_tree_list (NULL_TREE, arglist);
3884
3885           fn = fn_putchar;
3886         }
3887       /* If the resulting constant was "string\n", call
3888          __builtin_puts("string").  Ensure "string" has at least one
3889          character besides the trailing \n.  Note, TREE_STRING_LENGTH
3890          includes the terminating NULL in its count.  */
3891       else if (TREE_STRING_LENGTH (stripped_string) > 2
3892                && TREE_STRING_POINTER (stripped_string)
3893                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3894         {
3895           /* Create a NULL-terminated string that's one char shorter
3896              than the original, stripping off the trailing '\n'.  */
3897           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3898           char *newstr = (char *) alloca (newlen);
3899           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3900           newstr[newlen - 1] = 0;
3901
3902           arglist = combine_strings (build_string (newlen, newstr));
3903           arglist = build_tree_list (NULL_TREE, arglist);
3904           fn = fn_puts;
3905         }
3906       else
3907         /* We'd like to arrange to call fputs(string) here, but we
3908            need stdout and don't have a way to get it ... yet.  */
3909         return 0;
3910     }
3911
3912   return expand_expr (build_function_call (fn, arglist),
3913                       (ignore ? const0_rtx : target),
3914                       tmode, modifier);
3915 }
3916
3917 /* If the arguments passed to fprintf are suitable for optimizations,
3918    we attempt to transform the call.  */
3919 static rtx
3920 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
3921      tree arglist;
3922      rtx target;
3923      enum machine_mode tmode;
3924      enum expand_modifier modifier;
3925      int ignore;
3926      int unlocked;
3927 {
3928   tree fn_fputc = unlocked ?
3929     built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
3930   tree fn_fputs = unlocked ?
3931     built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
3932   tree fn, format_arg, stripped_string;
3933
3934   /* If the return value is used, or the replacement _DECL isn't
3935      initialized, don't do the transformation.  */
3936   if (!ignore || !fn_fputc || !fn_fputs)
3937     return 0;
3938
3939   /* Verify the required arguments in the original call.  */
3940   if (arglist == 0
3941       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3942       || (TREE_CHAIN (arglist) == 0)
3943       || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3944           POINTER_TYPE))
3945     return 0;
3946
3947   /* Check the specifier vs. the parameters.  */
3948   if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3949     return 0;
3950
3951   format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3952   stripped_string = format_arg;
3953   STRIP_NOPS (stripped_string);
3954   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3955     stripped_string = TREE_OPERAND (stripped_string, 0);
3956
3957   /* If the format specifier isn't a STRING_CST, punt.  */
3958   if (TREE_CODE (stripped_string) != STRING_CST)
3959     return 0;
3960
3961   /* OK!  We can attempt optimization.  */
3962
3963   /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1).  */
3964   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3965     {
3966       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3967       arglist = tree_cons (NULL_TREE,
3968                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3969                            newarglist);
3970       fn = fn_fputs;
3971     }
3972   /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1).  */
3973   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3974     {
3975       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3976       arglist = tree_cons (NULL_TREE,
3977                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3978                            newarglist);
3979       fn = fn_fputc;
3980     }
3981   else
3982     {
3983       /* We can't handle anything else with % args or %% ... yet.  */
3984       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3985         return 0;
3986
3987       /* When "string" doesn't contain %, replace all cases of
3988          fprintf(stream,string) with fputs(string,stream).  The fputs
3989          builtin will take take of special cases like length==1.  */
3990       arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
3991                            build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
3992       fn = fn_fputs;
3993     }
3994
3995   return expand_expr (build_function_call (fn, arglist),
3996                       (ignore ? const0_rtx : target),
3997                       tmode, modifier);
3998 }
3999 \f
4000
4001 /* Given a boolean expression ARG, return a tree representing an increment
4002    or decrement (as indicated by CODE) of ARG.  The front end must check for
4003    invalid cases (e.g., decrement in C++).  */
4004 tree
4005 boolean_increment (code, arg)
4006      enum tree_code code;
4007      tree arg;
4008 {
4009   tree val;
4010   tree true_res = (c_language == clk_cplusplus
4011                    ? boolean_true_node
4012                    : c_bool_true_node);
4013   arg = stabilize_reference (arg);
4014   switch (code)
4015     {
4016     case PREINCREMENT_EXPR:
4017       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4018       break;
4019     case POSTINCREMENT_EXPR:
4020       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4021       arg = save_expr (arg);
4022       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4023       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4024       break;
4025     case PREDECREMENT_EXPR:
4026       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4027       break;
4028     case POSTDECREMENT_EXPR:
4029       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4030       arg = save_expr (arg);
4031       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4032       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4033       break;
4034     default:
4035       abort ();
4036     }
4037   TREE_SIDE_EFFECTS (val) = 1;
4038   return val;
4039 }
4040 \f
4041 /* Handle C and C++ default attributes.  */
4042
4043 enum built_in_attribute
4044 {
4045 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4046 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4047 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4048 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4049 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum.  */
4050 #include "builtin-attrs.def"
4051 #undef DEF_ATTR_NULL_TREE
4052 #undef DEF_ATTR_INT
4053 #undef DEF_ATTR_IDENT
4054 #undef DEF_ATTR_TREE_LIST
4055 #undef DEF_FN_ATTR
4056   ATTR_LAST
4057 };
4058
4059 static tree built_in_attributes[(int) ATTR_LAST];
4060
4061 static bool c_attrs_initialized = false;
4062
4063 static void c_init_attributes PARAMS ((void));
4064
4065 /* Common initialization before parsing options.  */
4066 void
4067 c_common_init_options (lang)
4068      enum c_language_kind lang;
4069 {
4070   c_language = lang;
4071   parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
4072                                 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
4073
4074   /* Mark as "unspecified" (see c_common_post_options).  */
4075   flag_bounds_check = -1;
4076 }
4077
4078 /* Post-switch processing.  */
4079 void
4080 c_common_post_options ()
4081 {
4082   cpp_post_options (parse_in);
4083
4084   flag_inline_trees = 1;
4085
4086   /* Use tree inlining if possible.  Function instrumentation is only
4087      done in the RTL level, so we disable tree inlining.  */
4088   if (! flag_instrument_function_entry_exit)
4089     {
4090       if (!flag_no_inline)
4091         flag_no_inline = 1;
4092       if (flag_inline_functions)
4093         {
4094           flag_inline_trees = 2;
4095           flag_inline_functions = 0;
4096         }
4097     }
4098
4099   /* If still "unspecified", make it match -fbounded-pointers.  */
4100   if (flag_bounds_check == -1)
4101     flag_bounds_check = flag_bounded_pointers;
4102
4103   /* Special format checking options don't work without -Wformat; warn if
4104      they are used.  */
4105   if (warn_format_y2k && !warn_format)
4106     warning ("-Wformat-y2k ignored without -Wformat");
4107   if (warn_format_extra_args && !warn_format)
4108     warning ("-Wformat-extra-args ignored without -Wformat");
4109   if (warn_format_nonliteral && !warn_format)
4110     warning ("-Wformat-nonliteral ignored without -Wformat");
4111   if (warn_format_security && !warn_format)
4112     warning ("-Wformat-security ignored without -Wformat");
4113   if (warn_missing_format_attribute && !warn_format)
4114     warning ("-Wmissing-format-attribute ignored without -Wformat");
4115 }
4116
4117 /* Front end initialization common to C, ObjC and C++.  */
4118 const char *
4119 c_common_init (filename)
4120      const char *filename;
4121 {
4122   /* Do this before initializing pragmas, as then cpplib's hash table
4123      has been set up.  */
4124   filename = init_c_lex (filename);
4125
4126   init_pragma ();
4127
4128   if (!c_attrs_initialized)
4129     c_init_attributes ();
4130
4131   return filename;
4132 }
4133
4134 /* Common finish hook for the C, ObjC and C++ front ends.  */
4135 void
4136 c_common_finish ()
4137 {
4138   cpp_finish (parse_in);
4139
4140   /* For performance, avoid tearing down cpplib's internal structures.
4141      Call cpp_errors () instead of cpp_destroy ().  */
4142   errorcount += cpp_errors (parse_in);
4143 }
4144
4145 static void
4146 c_init_attributes ()
4147 {
4148   /* Fill in the built_in_attributes array.  */
4149 #define DEF_ATTR_NULL_TREE(ENUM)                \
4150   built_in_attributes[(int) ENUM] = NULL_TREE;
4151 #define DEF_ATTR_INT(ENUM, VALUE)                                            \
4152   built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4153 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
4154   built_in_attributes[(int) ENUM] = get_identifier (STRING);
4155 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4156   built_in_attributes[(int) ENUM]                       \
4157     = tree_cons (built_in_attributes[(int) PURPOSE],    \
4158                  built_in_attributes[(int) VALUE],      \
4159                  built_in_attributes[(int) CHAIN]);
4160 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed.  */
4161 #include "builtin-attrs.def"
4162 #undef DEF_ATTR_NULL_TREE
4163 #undef DEF_ATTR_INT
4164 #undef DEF_ATTR_IDENT
4165 #undef DEF_ATTR_TREE_LIST
4166 #undef DEF_FN_ATTR
4167   ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4168   c_attrs_initialized = true;
4169 }
4170
4171 /* Depending on the name of DECL, apply default attributes to it.  */
4172
4173 void
4174 c_common_insert_default_attributes (decl)
4175      tree decl;
4176 {
4177   tree name = DECL_NAME (decl);
4178
4179   if (!c_attrs_initialized)
4180     c_init_attributes ();
4181
4182 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization.  */
4183 #define DEF_ATTR_INT(ENUM, VALUE)
4184 #define DEF_ATTR_IDENT(ENUM, STRING)
4185 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4186 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE)                     \
4187   if ((PREDICATE) && name == built_in_attributes[(int) NAME])   \
4188     decl_attributes (&decl, built_in_attributes[(int) ATTRS],   \
4189                      ATTR_FLAG_BUILT_IN);
4190 #include "builtin-attrs.def"
4191 #undef DEF_ATTR_NULL_TREE
4192 #undef DEF_ATTR_INT
4193 #undef DEF_ATTR_IDENT
4194 #undef DEF_ATTR_TREE_LIST
4195 #undef DEF_FN_ATTR
4196 }
4197
4198 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4199    additionally give the location of the previous declaration DECL.  */
4200 void
4201 shadow_warning (msgid, name, decl)
4202      const char *msgid;
4203      tree name, decl;
4204 {
4205   warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4206   warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4207                               DECL_SOURCE_LINE (decl),
4208                               "shadowed declaration is here");
4209 }
4210